lib/Target/X86/X86InstrSSE.td

   1 //====- X86InstrSSE.td - Describe the X86 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
  17 //===----------------------------------------------------------------------===//
  18 // SSE 1 & 2 Instructions Classes
  19 //===----------------------------------------------------------------------===//
  20
  21 /// sse12_fp_scalar - SSE 1 & 2 scalar instructions class
  22 multiclass sse12_fp_scalar<bits<8> opc, string OpcodeStr, SDNode OpNode,
  23                            RegisterClass RC, X86MemOperand x86memop,
  24                            bit Is2Addr = 1> {
  25   let isCommutable = 1 in {
  26     def rr : SI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
  27        !if(Is2Addr,
  28            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
  29            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  30        [(set RC:$dst, (OpNode RC:$src1, RC:$src2))]>;
  31   }
  32   def rm : SI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
  33        !if(Is2Addr,
  34            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
  35            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  36        [(set RC:$dst, (OpNode RC:$src1, (load addr:$src2)))]>;
  37 }
  38
  39 /// sse12_fp_scalar_int - SSE 1 & 2 scalar instructions intrinsics class
  40 multiclass sse12_fp_scalar_int<bits<8> opc, string OpcodeStr, RegisterClass RC,
  41                              string asm, string SSEVer, string FPSizeStr,
  42                              Operand memopr, ComplexPattern mem_cpat,
  43                              bit Is2Addr = 1> {
  44   def rr_Int : SI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
  45        !if(Is2Addr,
  46            !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
  47            !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  48        [(set RC:$dst, (!cast<Intrinsic>(
  49                  !strconcat("int_x86_sse", SSEVer, "_", OpcodeStr, FPSizeStr))
  50              RC:$src1, RC:$src2))]>;
  51   def rm_Int : SI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, memopr:$src2),
  52        !if(Is2Addr,
  53            !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
  54            !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  55        [(set RC:$dst, (!cast<Intrinsic>(!strconcat("int_x86_sse",
  56                                           SSEVer, "_", OpcodeStr, FPSizeStr))
  57              RC:$src1, mem_cpat:$src2))]>;
  58 }
  59
  60 /// sse12_fp_packed - SSE 1 & 2 packed instructions class
  61 multiclass sse12_fp_packed<bits<8> opc, string OpcodeStr, SDNode OpNode,
  62                            RegisterClass RC, ValueType vt,
  63                            X86MemOperand x86memop, PatFrag mem_frag,
  64                            Domain d, bit Is2Addr = 1> {
  65   let isCommutable = 1 in
  66     def rr : PI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
  67        !if(Is2Addr,
  68            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
  69            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  70        [(set RC:$dst, (vt (OpNode RC:$src1, RC:$src2)))], d>;
  71   let mayLoad = 1 in
  72     def rm : PI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
  73        !if(Is2Addr,
  74            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
  75            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  76        [(set RC:$dst, (OpNode RC:$src1, (mem_frag addr:$src2)))], d>;
  77 }
  78
  79 /// sse12_fp_packed_logical_rm - SSE 1 & 2 packed instructions class
  80 multiclass sse12_fp_packed_logical_rm<bits<8> opc, RegisterClass RC, Domain d,
  81                                       string OpcodeStr, X86MemOperand x86memop,
  82                                       list<dag> pat_rr, list<dag> pat_rm,
  83                                       bit Is2Addr = 1> {
  84   let isCommutable = 1 in
  85     def rr : PI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
  86        !if(Is2Addr,
  87            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
  88            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  89        pat_rr, d>;
  90   def rm : PI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
  91        !if(Is2Addr,
  92            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
  93            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
  94        pat_rm, d>;
  95 }
  96
  97 /// sse12_fp_packed_int - SSE 1 & 2 packed instructions intrinsics class
  98 multiclass sse12_fp_packed_int<bits<8> opc, string OpcodeStr, RegisterClass RC,
  99                            string asm, string SSEVer, string FPSizeStr,
 100                            X86MemOperand x86memop, PatFrag mem_frag,
 101                            Domain d, bit Is2Addr = 1> {
 102   def rr_Int : PI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
 103        !if(Is2Addr,
 104            !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
 105            !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 106            [(set RC:$dst, (!cast<Intrinsic>(
 107                      !strconcat("int_x86_", SSEVer, "_", OpcodeStr, FPSizeStr))
 108                  RC:$src1, RC:$src2))], d>;
 109   def rm_Int : PI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1,x86memop:$src2),
 110        !if(Is2Addr,
 111            !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
 112            !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
 113        [(set RC:$dst, (!cast<Intrinsic>(
 114                      !strconcat("int_x86_", SSEVer, "_", OpcodeStr, FPSizeStr))
 115              RC:$src1, (mem_frag addr:$src2)))], d>;
 116 }
 117
 118 //===----------------------------------------------------------------------===//
 119 //  Non-instruction patterns
 120 //===----------------------------------------------------------------------===//
 121
 122 // A vector extract of the first f32/f64 position is a subregister copy
 123 def : Pat<(f32 (vector_extract (v4f32 VR128:$src), (iPTR 0))),
 124           (f32 (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss))>;
 125 def : Pat<(f64 (vector_extract (v2f64 VR128:$src), (iPTR 0))),
 126           (f64 (EXTRACT_SUBREG (v2f64 VR128:$src), sub_sd))>;
 127
 128 // A 128-bit subvector extract from the first 256-bit vector position
 129 // is a subregister copy that needs no instruction.
 130 def : Pat<(v4i32 (extract_subvector (v8i32 VR256:$src), (i32 0))),
 131           (v4i32 (EXTRACT_SUBREG (v8i32 VR256:$src), sub_xmm))>;
 132 def : Pat<(v4f32 (extract_subvector (v8f32 VR256:$src), (i32 0))),
 133           (v4f32 (EXTRACT_SUBREG (v8f32 VR256:$src), sub_xmm))>;
 134
 135 def : Pat<(v2i64 (extract_subvector (v4i64 VR256:$src), (i32 0))),
 136           (v2i64 (EXTRACT_SUBREG (v4i64 VR256:$src), sub_xmm))>;
 137 def : Pat<(v2f64 (extract_subvector (v4f64 VR256:$src), (i32 0))),
 138           (v2f64 (EXTRACT_SUBREG (v4f64 VR256:$src), sub_xmm))>;
 139
 140 def : Pat<(v8i16 (extract_subvector (v16i16 VR256:$src), (i32 0))),
 141           (v8i16 (EXTRACT_SUBREG (v16i16 VR256:$src), sub_xmm))>;
 142 def : Pat<(v16i8 (extract_subvector (v32i8 VR256:$src), (i32 0))),
 143           (v16i8 (EXTRACT_SUBREG (v32i8 VR256:$src), sub_xmm))>;
 144
 145 // A 128-bit subvector insert to the first 256-bit vector position
 146 // is a subregister copy that needs no instruction.
 147 def : Pat<(insert_subvector undef, (v2i64 VR128:$src), (i32 0)),
 148           (INSERT_SUBREG (v4i64 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 149 def : Pat<(insert_subvector undef, (v2f64 VR128:$src), (i32 0)),
 150           (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 151 def : Pat<(insert_subvector undef, (v4i32 VR128:$src), (i32 0)),
 152           (INSERT_SUBREG (v8i32 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 153 def : Pat<(insert_subvector undef, (v4f32 VR128:$src), (i32 0)),
 154           (INSERT_SUBREG (v8f32 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 155 def : Pat<(insert_subvector undef, (v8i16 VR128:$src), (i32 0)),
 156           (INSERT_SUBREG (v16i16 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 157 def : Pat<(insert_subvector undef, (v16i8 VR128:$src), (i32 0)),
 158           (INSERT_SUBREG (v32i8 (IMPLICIT_DEF)), VR128:$src, sub_xmm)>;
 159
 160 // Implicitly promote a 32-bit scalar to a vector.
 161 def : Pat<(v4f32 (scalar_to_vector FR32:$src)),
 162           (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), FR32:$src, sub_ss)>;
 163 def : Pat<(v8f32 (scalar_to_vector FR32:$src)),
 164           (INSERT_SUBREG (v8f32 (IMPLICIT_DEF)), FR32:$src, sub_ss)>;
 165 // Implicitly promote a 64-bit scalar to a vector.
 166 def : Pat<(v2f64 (scalar_to_vector FR64:$src)),
 167           (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), FR64:$src, sub_sd)>;
 168 def : Pat<(v4f64 (scalar_to_vector FR64:$src)),
 169           (INSERT_SUBREG (v4f64 (IMPLICIT_DEF)), FR64:$src, sub_sd)>;
 170
 171 // Bitcasts between 128-bit vector types. Return the original type since
 172 // no instruction is needed for the conversion
 173 let Predicates = [HasXMMInt] in {
 174   def : Pat<(v2i64 (bitconvert (v4i32 VR128:$src))), (v2i64 VR128:$src)>;
 175   def : Pat<(v2i64 (bitconvert (v8i16 VR128:$src))), (v2i64 VR128:$src)>;
 176   def : Pat<(v2i64 (bitconvert (v16i8 VR128:$src))), (v2i64 VR128:$src)>;
 177   def : Pat<(v2i64 (bitconvert (v2f64 VR128:$src))), (v2i64 VR128:$src)>;
 178   def : Pat<(v2i64 (bitconvert (v4f32 VR128:$src))), (v2i64 VR128:$src)>;
 179   def : Pat<(v4i32 (bitconvert (v2i64 VR128:$src))), (v4i32 VR128:$src)>;
 180   def : Pat<(v4i32 (bitconvert (v8i16 VR128:$src))), (v4i32 VR128:$src)>;
 181   def : Pat<(v4i32 (bitconvert (v16i8 VR128:$src))), (v4i32 VR128:$src)>;
 182   def : Pat<(v4i32 (bitconvert (v2f64 VR128:$src))), (v4i32 VR128:$src)>;
 183   def : Pat<(v4i32 (bitconvert (v4f32 VR128:$src))), (v4i32 VR128:$src)>;
 184   def : Pat<(v8i16 (bitconvert (v2i64 VR128:$src))), (v8i16 VR128:$src)>;
 185   def : Pat<(v8i16 (bitconvert (v4i32 VR128:$src))), (v8i16 VR128:$src)>;
 186   def : Pat<(v8i16 (bitconvert (v16i8 VR128:$src))), (v8i16 VR128:$src)>;
 187   def : Pat<(v8i16 (bitconvert (v2f64 VR128:$src))), (v8i16 VR128:$src)>;
 188   def : Pat<(v8i16 (bitconvert (v4f32 VR128:$src))), (v8i16 VR128:$src)>;
 189   def : Pat<(v16i8 (bitconvert (v2i64 VR128:$src))), (v16i8 VR128:$src)>;
 190   def : Pat<(v16i8 (bitconvert (v4i32 VR128:$src))), (v16i8 VR128:$src)>;
 191   def : Pat<(v16i8 (bitconvert (v8i16 VR128:$src))), (v16i8 VR128:$src)>;
 192   def : Pat<(v16i8 (bitconvert (v2f64 VR128:$src))), (v16i8 VR128:$src)>;
 193   def : Pat<(v16i8 (bitconvert (v4f32 VR128:$src))), (v16i8 VR128:$src)>;
 194   def : Pat<(v4f32 (bitconvert (v2i64 VR128:$src))), (v4f32 VR128:$src)>;
 195   def : Pat<(v4f32 (bitconvert (v4i32 VR128:$src))), (v4f32 VR128:$src)>;
 196   def : Pat<(v4f32 (bitconvert (v8i16 VR128:$src))), (v4f32 VR128:$src)>;
 197   def : Pat<(v4f32 (bitconvert (v16i8 VR128:$src))), (v4f32 VR128:$src)>;
 198   def : Pat<(v4f32 (bitconvert (v2f64 VR128:$src))), (v4f32 VR128:$src)>;
 199   def : Pat<(v2f64 (bitconvert (v2i64 VR128:$src))), (v2f64 VR128:$src)>;
 200   def : Pat<(v2f64 (bitconvert (v4i32 VR128:$src))), (v2f64 VR128:$src)>;
 201   def : Pat<(v2f64 (bitconvert (v8i16 VR128:$src))), (v2f64 VR128:$src)>;
 202   def : Pat<(v2f64 (bitconvert (v16i8 VR128:$src))), (v2f64 VR128:$src)>;
 203   def : Pat<(v2f64 (bitconvert (v4f32 VR128:$src))), (v2f64 VR128:$src)>;
 204 }
 205
 206 // Bitcasts between 256-bit vector types. Return the original type since
 207 // no instruction is needed for the conversion
 208 let Predicates = [HasAVX] in {
 209   def : Pat<(v4f64  (bitconvert (v8f32 VR256:$src))),  (v4f64 VR256:$src)>;
 210   def : Pat<(v4f64  (bitconvert (v8i32 VR256:$src))),  (v4f64 VR256:$src)>;
 211   def : Pat<(v4f64  (bitconvert (v4i64 VR256:$src))),  (v4f64 VR256:$src)>;
 212   def : Pat<(v4f64  (bitconvert (v16i16 VR256:$src))), (v4f64 VR256:$src)>;
 213   def : Pat<(v4f64  (bitconvert (v32i8 VR256:$src))),  (v4f64 VR256:$src)>;
 214   def : Pat<(v8f32  (bitconvert (v8i32 VR256:$src))),  (v8f32 VR256:$src)>;
 215   def : Pat<(v8f32  (bitconvert (v4i64 VR256:$src))),  (v8f32 VR256:$src)>;
 216   def : Pat<(v8f32  (bitconvert (v4f64 VR256:$src))),  (v8f32 VR256:$src)>;
 217   def : Pat<(v8f32  (bitconvert (v32i8 VR256:$src))),  (v8f32 VR256:$src)>;
 218   def : Pat<(v8f32  (bitconvert (v16i16 VR256:$src))), (v8f32 VR256:$src)>;
 219   def : Pat<(v4i64  (bitconvert (v8f32 VR256:$src))),  (v4i64 VR256:$src)>;
 220   def : Pat<(v4i64  (bitconvert (v8i32 VR256:$src))),  (v4i64 VR256:$src)>;
 221   def : Pat<(v4i64  (bitconvert (v4f64 VR256:$src))),  (v4i64 VR256:$src)>;
 222   def : Pat<(v4i64  (bitconvert (v32i8 VR256:$src))),  (v4i64 VR256:$src)>;
 223   def : Pat<(v4i64  (bitconvert (v16i16 VR256:$src))), (v4i64 VR256:$src)>;
 224   def : Pat<(v32i8  (bitconvert (v4f64 VR256:$src))),  (v32i8 VR256:$src)>;
 225   def : Pat<(v32i8  (bitconvert (v4i64 VR256:$src))),  (v32i8 VR256:$src)>;
 226   def : Pat<(v32i8  (bitconvert (v8f32 VR256:$src))),  (v32i8 VR256:$src)>;
 227   def : Pat<(v32i8  (bitconvert (v8i32 VR256:$src))),  (v32i8 VR256:$src)>;
 228   def : Pat<(v32i8  (bitconvert (v16i16 VR256:$src))), (v32i8 VR256:$src)>;
 229   def : Pat<(v8i32  (bitconvert (v32i8 VR256:$src))),  (v8i32 VR256:$src)>;
 230   def : Pat<(v8i32  (bitconvert (v16i16 VR256:$src))), (v8i32 VR256:$src)>;
 231   def : Pat<(v8i32  (bitconvert (v8f32 VR256:$src))),  (v8i32 VR256:$src)>;
 232   def : Pat<(v8i32  (bitconvert (v4i64 VR256:$src))),  (v8i32 VR256:$src)>;
 233   def : Pat<(v8i32  (bitconvert (v4f64 VR256:$src))),  (v8i32 VR256:$src)>;
 234   def : Pat<(v16i16 (bitconvert (v8f32 VR256:$src))),  (v16i16 VR256:$src)>;
 235   def : Pat<(v16i16 (bitconvert (v8i32 VR256:$src))),  (v16i16 VR256:$src)>;
 236   def : Pat<(v16i16 (bitconvert (v4i64 VR256:$src))),  (v16i16 VR256:$src)>;
 237   def : Pat<(v16i16 (bitconvert (v4f64 VR256:$src))),  (v16i16 VR256:$src)>;
 238   def : Pat<(v16i16 (bitconvert (v32i8 VR256:$src))),  (v16i16 VR256:$src)>;
 239 }
 240
 241 // Alias instructions that map fld0 to pxor for sse.
 242 // FIXME: Set encoding to pseudo!
 243 let isReMaterializable = 1, isAsCheapAsAMove = 1, isCodeGenOnly = 1,
 244     canFoldAsLoad = 1 in {
 245   def FsFLD0SS : I<0xEF, MRMInitReg, (outs FR32:$dst), (ins), "",
 246                    [(set FR32:$dst, fp32imm0)]>,
 247                    Requires<[HasSSE1]>, TB, OpSize;
 248   def FsFLD0SD : I<0xEF, MRMInitReg, (outs FR64:$dst), (ins), "",
 249                    [(set FR64:$dst, fpimm0)]>,
 250                  Requires<[HasSSE2]>, TB, OpSize;
 251   def VFsFLD0SS : I<0xEF, MRMInitReg, (outs FR32:$dst), (ins), "",
 252                     [(set FR32:$dst, fp32imm0)]>,
 253                     Requires<[HasAVX]>, TB, OpSize, VEX_4V;
 254   def VFsFLD0SD : I<0xEF, MRMInitReg, (outs FR64:$dst), (ins), "",
 255                     [(set FR64:$dst, fpimm0)]>,
 256                     Requires<[HasAVX]>, TB, OpSize, VEX_4V;
 257 }
 258
 259 //===----------------------------------------------------------------------===//
 260 // AVX & SSE - Zero/One Vectors
 261 //===----------------------------------------------------------------------===//
 262
 263 // Alias instructions that map zero vector to pxor / xorp* for sse.
 264 // We set canFoldAsLoad because this can be converted to a constant-pool
 265 // load of an all-zeros value if folding it would be beneficial.
 266 // FIXME: Change encoding to pseudo! This is blocked right now by the x86
 267 // JIT implementation, it does not expand the instructions below like
 268 // X86MCInstLower does.
 269 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 270     isCodeGenOnly = 1 in {
 271 def V_SET0PS : PSI<0x57, MRMInitReg, (outs VR128:$dst), (ins), "",
 272                  [(set VR128:$dst, (v4f32 immAllZerosV))]>;
 273 def V_SET0PD : PDI<0x57, MRMInitReg, (outs VR128:$dst), (ins), "",
 274                  [(set VR128:$dst, (v2f64 immAllZerosV))]>;
 275 let ExeDomain = SSEPackedInt in
 276 def V_SET0PI : PDI<0xEF, MRMInitReg, (outs VR128:$dst), (ins), "",
 277                  [(set VR128:$dst, (v4i32 immAllZerosV))]>;
 278 }
 279
 280 // The same as done above but for AVX. The 128-bit versions are the
 281 // same, but re-encoded. The 256-bit does not support PI version, and
 282 // doesn't need it because on sandy bridge the register is set to zero
 283 // at the rename stage without using any execution unit, so SET0PSY
 284 // and SET0PDY can be used for vector int instructions without penalty
 285 // FIXME: Change encoding to pseudo! This is blocked right now by the x86
 286 // JIT implementatioan, it does not expand the instructions below like
 287 // X86MCInstLower does.
 288 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 289     isCodeGenOnly = 1, Predicates = [HasAVX] in {
 290 def AVX_SET0PS  : PSI<0x57, MRMInitReg, (outs VR128:$dst), (ins), "",
 291                    [(set VR128:$dst, (v4f32 immAllZerosV))]>, VEX_4V;
 292 def AVX_SET0PD  : PDI<0x57, MRMInitReg, (outs VR128:$dst), (ins), "",
 293                    [(set VR128:$dst, (v2f64 immAllZerosV))]>, VEX_4V;
 294 def AVX_SET0PSY : PSI<0x57, MRMInitReg, (outs VR256:$dst), (ins), "",
 295                    [(set VR256:$dst, (v8f32 immAllZerosV))]>, VEX_4V;
 296 def AVX_SET0PDY : PDI<0x57, MRMInitReg, (outs VR256:$dst), (ins), "",
 297                    [(set VR256:$dst, (v4f64 immAllZerosV))]>, VEX_4V;
 298 let ExeDomain = SSEPackedInt in
 299 def AVX_SET0PI  : PDI<0xEF, MRMInitReg, (outs VR128:$dst), (ins), "",
 300                    [(set VR128:$dst, (v4i32 immAllZerosV))]>;
 301 }
 302
 303 def : Pat<(v2i64 immAllZerosV), (V_SET0PI)>;
 304 def : Pat<(v8i16 immAllZerosV), (V_SET0PI)>;
 305 def : Pat<(v16i8 immAllZerosV), (V_SET0PI)>;
 306
 307 // AVX has no support for 256-bit integer instructions, but since the 128-bit
 308 // VPXOR instruction writes zero to its upper part, it's safe build zeros.
 309 def : Pat<(v8i32 immAllZerosV), (SUBREG_TO_REG (i32 0), (AVX_SET0PI), sub_xmm)>;
 310 def : Pat<(bc_v8i32 (v8f32 immAllZerosV)),
 311           (SUBREG_TO_REG (i32 0), (AVX_SET0PI), sub_xmm)>;
 312
 313 def : Pat<(v4i64 immAllZerosV), (SUBREG_TO_REG (i64 0), (AVX_SET0PI), sub_xmm)>;
 314 def : Pat<(bc_v4i64 (v8f32 immAllZerosV)),
 315           (SUBREG_TO_REG (i64 0), (AVX_SET0PI), sub_xmm)>;
 316
 317 // We set canFoldAsLoad because this can be converted to a constant-pool
 318 // load of an all-ones value if folding it would be beneficial.
 319 // FIXME: Change encoding to pseudo! This is blocked right now by the x86
 320 // JIT implementation, it does not expand the instructions below like
 321 // X86MCInstLower does.
 322 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 323     isCodeGenOnly = 1, ExeDomain = SSEPackedInt in
 324   def V_SETALLONES : PDI<0x76, MRMInitReg, (outs VR128:$dst), (ins), "",
 325                          [(set VR128:$dst, (v4i32 immAllOnesV))]>;
 326 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
 327     isCodeGenOnly = 1, ExeDomain = SSEPackedInt, Predicates = [HasAVX] in
 328   def AVX_SETALLONES : PDI<0x76, MRMInitReg, (outs VR128:$dst), (ins), "",
 329                          [(set VR128:$dst, (v4i32 immAllOnesV))]>, VEX_4V;
 330
 331
 332 //===----------------------------------------------------------------------===//
 333 // SSE 1 & 2 - Move FP Scalar Instructions
 334 //
 335 // Move Instructions. Register-to-register movss/movsd is not used for FR32/64
 336 // register copies because it's a partial register update; FsMOVAPSrr/FsMOVAPDrr
 337 // is used instead. Register-to-register movss/movsd is not modeled as an
 338 // INSERT_SUBREG because INSERT_SUBREG requires that the insert be implementable
 339 // in terms of a copy, and just mentioned, we don't use movss/movsd for copies.
 340 //===----------------------------------------------------------------------===//
 341
 342 class sse12_move_rr<RegisterClass RC, ValueType vt, string asm> :
 343       SI<0x10, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src1, RC:$src2), asm,
 344       [(set (vt VR128:$dst), (movl VR128:$src1, (scalar_to_vector RC:$src2)))]>;
 345
 346 // Loading from memory automatically zeroing upper bits.
 347 class sse12_move_rm<RegisterClass RC, X86MemOperand x86memop,
 348                     PatFrag mem_pat, string OpcodeStr> :
 349       SI<0x10, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
 350          !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
 351                         [(set RC:$dst, (mem_pat addr:$src))]>;
 352
 353 // AVX
 354 def VMOVSSrr : sse12_move_rr<FR32, v4f32,
 355                 "movss\t{$src2, $src1, $dst|$dst, $src1, $src2}">, XS, VEX_4V;
 356 def VMOVSDrr : sse12_move_rr<FR64, v2f64,
 357                 "movsd\t{$src2, $src1, $dst|$dst, $src1, $src2}">, XD, VEX_4V;
 358
 359 // For the disassembler
 360 let isCodeGenOnly = 1 in {
 361   def VMOVSSrr_REV : SI<0x11, MRMDestReg, (outs VR128:$dst),
 362                         (ins VR128:$src1, FR32:$src2),
 363                         "movss\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
 364                         XS, VEX_4V;
 365   def VMOVSDrr_REV : SI<0x11, MRMDestReg, (outs VR128:$dst),
 366                         (ins VR128:$src1, FR64:$src2),
 367                         "movsd\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
 368                         XD, VEX_4V;
 369 }
 370
 371 let canFoldAsLoad = 1, isReMaterializable = 1 in {
 372   def VMOVSSrm : sse12_move_rm<FR32, f32mem, loadf32, "movss">, XS, VEX;
 373   let AddedComplexity = 20 in
 374     def VMOVSDrm : sse12_move_rm<FR64, f64mem, loadf64, "movsd">, XD, VEX;
 375 }
 376
 377 def VMOVSSmr : SI<0x11, MRMDestMem, (outs), (ins f32mem:$dst, FR32:$src),
 378                   "movss\t{$src, $dst|$dst, $src}",
 379                   [(store FR32:$src, addr:$dst)]>, XS, VEX;
 380 def VMOVSDmr : SI<0x11, MRMDestMem, (outs), (ins f64mem:$dst, FR64:$src),
 381                   "movsd\t{$src, $dst|$dst, $src}",
 382                   [(store FR64:$src, addr:$dst)]>, XD, VEX;
 383
 384 // SSE1 & 2
 385 let Constraints = "$src1 = $dst" in {
 386   def MOVSSrr : sse12_move_rr<FR32, v4f32,
 387                           "movss\t{$src2, $dst|$dst, $src2}">, XS;
 388   def MOVSDrr : sse12_move_rr<FR64, v2f64,
 389                           "movsd\t{$src2, $dst|$dst, $src2}">, XD;
 390
 391   // For the disassembler
 392   let isCodeGenOnly = 1 in {
 393     def MOVSSrr_REV : SI<0x11, MRMDestReg, (outs VR128:$dst),
 394                          (ins VR128:$src1, FR32:$src2),
 395                          "movss\t{$src2, $dst|$dst, $src2}", []>, XS;
 396     def MOVSDrr_REV : SI<0x11, MRMDestReg, (outs VR128:$dst),
 397                          (ins VR128:$src1, FR64:$src2),
 398                          "movsd\t{$src2, $dst|$dst, $src2}", []>, XD;
 399   }
 400 }
 401
 402 let canFoldAsLoad = 1, isReMaterializable = 1 in {
 403   def MOVSSrm : sse12_move_rm<FR32, f32mem, loadf32, "movss">, XS;
 404
 405   let AddedComplexity = 20 in
 406     def MOVSDrm : sse12_move_rm<FR64, f64mem, loadf64, "movsd">, XD;
 407 }
 408
 409 def MOVSSmr : SSI<0x11, MRMDestMem, (outs), (ins f32mem:$dst, FR32:$src),
 410                   "movss\t{$src, $dst|$dst, $src}",
 411                   [(store FR32:$src, addr:$dst)]>;
 412 def MOVSDmr : SDI<0x11, MRMDestMem, (outs), (ins f64mem:$dst, FR64:$src),
 413                   "movsd\t{$src, $dst|$dst, $src}",
 414                   [(store FR64:$src, addr:$dst)]>;
 415
 416 // Patterns
 417 let Predicates = [HasSSE1] in {
 418   let AddedComplexity = 15 in {
 419   // Extract the low 32-bit value from one vector and insert it into another.
 420   def : Pat<(v4f32 (movl VR128:$src1, VR128:$src2)),
 421             (MOVSSrr (v4f32 VR128:$src1),
 422                      (EXTRACT_SUBREG (v4f32 VR128:$src2), sub_ss))>;
 423   def : Pat<(v4i32 (movl VR128:$src1, VR128:$src2)),
 424             (MOVSSrr (v4i32 VR128:$src1),
 425                      (EXTRACT_SUBREG (v4i32 VR128:$src2), sub_ss))>;
 426
 427   // Move scalar to XMM zero-extended, zeroing a VR128 then do a
 428   // MOVSS to the lower bits.
 429   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector FR32:$src)))),
 430             (MOVSSrr (v4f32 (V_SET0PS)), FR32:$src)>;
 431   def : Pat<(v4f32 (X86vzmovl (v4f32 VR128:$src))),
 432             (MOVSSrr (v4f32 (V_SET0PS)),
 433                      (f32 (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss)))>;
 434   def : Pat<(v4i32 (X86vzmovl (v4i32 VR128:$src))),
 435             (MOVSSrr (v4i32 (V_SET0PI)),
 436                      (EXTRACT_SUBREG (v4i32 VR128:$src), sub_ss))>;
 437   }
 438
 439   let AddedComplexity = 20 in {
 440   // MOVSSrm zeros the high parts of the register; represent this
 441   // with SUBREG_TO_REG.
 442   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector (loadf32 addr:$src))))),
 443             (SUBREG_TO_REG (i32 0), (MOVSSrm addr:$src), sub_ss)>;
 444   def : Pat<(v4f32 (scalar_to_vector (loadf32 addr:$src))),
 445             (SUBREG_TO_REG (i32 0), (MOVSSrm addr:$src), sub_ss)>;
 446   def : Pat<(v4f32 (X86vzmovl (loadv4f32 addr:$src))),
 447             (SUBREG_TO_REG (i32 0), (MOVSSrm addr:$src), sub_ss)>;
 448   }
 449
 450   // Extract and store.
 451   def : Pat<(store (f32 (vector_extract (v4f32 VR128:$src), (iPTR 0))),
 452                    addr:$dst),
 453             (MOVSSmr addr:$dst,
 454                      (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss))>;
 455
 456   // Shuffle with MOVSS
 457   def : Pat<(v4f32 (X86Movss VR128:$src1, (scalar_to_vector FR32:$src2))),
 458             (MOVSSrr VR128:$src1, FR32:$src2)>;
 459   def : Pat<(v4i32 (X86Movss VR128:$src1, VR128:$src2)),
 460             (MOVSSrr (v4i32 VR128:$src1),
 461                      (EXTRACT_SUBREG (v4i32 VR128:$src2), sub_ss))>;
 462   def : Pat<(v4f32 (X86Movss VR128:$src1, VR128:$src2)),
 463             (MOVSSrr (v4f32 VR128:$src1),
 464                      (EXTRACT_SUBREG (v4f32 VR128:$src2), sub_ss))>;
 465 }
 466
 467 let Predicates = [HasSSE2] in {
 468   let AddedComplexity = 15 in {
 469   // Extract the low 64-bit value from one vector and insert it into another.
 470   def : Pat<(v2f64 (movl VR128:$src1, VR128:$src2)),
 471             (MOVSDrr (v2f64 VR128:$src1),
 472                      (EXTRACT_SUBREG (v2f64 VR128:$src2), sub_sd))>;
 473   def : Pat<(v2i64 (movl VR128:$src1, VR128:$src2)),
 474             (MOVSDrr (v2i64 VR128:$src1),
 475                      (EXTRACT_SUBREG (v2i64 VR128:$src2), sub_sd))>;
 476
 477   // vector_shuffle v1, v2 <4, 5, 2, 3> using movsd
 478   def : Pat<(v4f32 (movlp VR128:$src1, VR128:$src2)),
 479             (MOVSDrr VR128:$src1, (EXTRACT_SUBREG VR128:$src2, sub_sd))>;
 480   def : Pat<(v4i32 (movlp VR128:$src1, VR128:$src2)),
 481             (MOVSDrr VR128:$src1, (EXTRACT_SUBREG VR128:$src2, sub_sd))>;
 482
 483   // Move scalar to XMM zero-extended, zeroing a VR128 then do a
 484   // MOVSD to the lower bits.
 485   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector FR64:$src)))),
 486             (MOVSDrr (v2f64 (V_SET0PS)), FR64:$src)>;
 487   }
 488
 489   let AddedComplexity = 20 in {
 490   // MOVSDrm zeros the high parts of the register; represent this
 491   // with SUBREG_TO_REG.
 492   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector (loadf64 addr:$src))))),
 493             (SUBREG_TO_REG (i64 0), (MOVSDrm addr:$src), sub_sd)>;
 494   def : Pat<(v2f64 (scalar_to_vector (loadf64 addr:$src))),
 495             (SUBREG_TO_REG (i64 0), (MOVSDrm addr:$src), sub_sd)>;
 496   def : Pat<(v2f64 (X86vzmovl (loadv2f64 addr:$src))),
 497             (SUBREG_TO_REG (i64 0), (MOVSDrm addr:$src), sub_sd)>;
 498   def : Pat<(v2f64 (X86vzmovl (bc_v2f64 (loadv4f32 addr:$src)))),
 499             (SUBREG_TO_REG (i64 0), (MOVSDrm addr:$src), sub_sd)>;
 500   def : Pat<(v2f64 (X86vzload addr:$src)),
 501             (SUBREG_TO_REG (i64 0), (MOVSDrm addr:$src), sub_sd)>;
 502   }
 503
 504   // Extract and store.
 505   def : Pat<(store (f64 (vector_extract (v2f64 VR128:$src), (iPTR 0))),
 506                    addr:$dst),
 507             (MOVSDmr addr:$dst,
 508                      (EXTRACT_SUBREG (v2f64 VR128:$src), sub_sd))>;
 509
 510   // Shuffle with MOVSD
 511   def : Pat<(v2f64 (X86Movsd VR128:$src1, (scalar_to_vector FR64:$src2))),
 512             (MOVSDrr VR128:$src1, FR64:$src2)>;
 513   def : Pat<(v2i64 (X86Movsd VR128:$src1, VR128:$src2)),
 514             (MOVSDrr (v2i64 VR128:$src1),
 515                      (EXTRACT_SUBREG (v2i64 VR128:$src2), sub_sd))>;
 516   def : Pat<(v2f64 (X86Movsd VR128:$src1, VR128:$src2)),
 517             (MOVSDrr (v2f64 VR128:$src1),
 518                      (EXTRACT_SUBREG (v2f64 VR128:$src2), sub_sd))>;
 519   def : Pat<(v4f32 (X86Movsd VR128:$src1, VR128:$src2)),
 520             (MOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4f32 VR128:$src2),sub_sd))>;
 521   def : Pat<(v4i32 (X86Movsd VR128:$src1, VR128:$src2)),
 522             (MOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4i32 VR128:$src2),sub_sd))>;
 523
 524   // FIXME: Instead of a X86Movlps there should be a X86Movsd here, the problem
 525   // is during lowering, where it's not possible to recognize the fold cause
 526   // it has two uses through a bitcast. One use disappears at isel time and the
 527   // fold opportunity reappears.
 528   def : Pat<(v4f32 (X86Movlps VR128:$src1, VR128:$src2)),
 529             (MOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4f32 VR128:$src2),sub_sd))>;
 530   def : Pat<(v4i32 (X86Movlps VR128:$src1, VR128:$src2)),
 531             (MOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4i32 VR128:$src2),sub_sd))>;
 532 }
 533
 534 let Predicates = [HasAVX] in {
 535   let AddedComplexity = 15 in {
 536   // Extract the low 32-bit value from one vector and insert it into another.
 537   def : Pat<(v4f32 (movl VR128:$src1, VR128:$src2)),
 538             (VMOVSSrr (v4f32 VR128:$src1),
 539                       (EXTRACT_SUBREG (v4f32 VR128:$src2), sub_ss))>;
 540   def : Pat<(v4i32 (movl VR128:$src1, VR128:$src2)),
 541             (VMOVSSrr (v4i32 VR128:$src1),
 542                       (EXTRACT_SUBREG (v4i32 VR128:$src2), sub_ss))>;
 543
 544   // Extract the low 64-bit value from one vector and insert it into another.
 545   def : Pat<(v2f64 (movl VR128:$src1, VR128:$src2)),
 546             (VMOVSDrr (v2f64 VR128:$src1),
 547                       (EXTRACT_SUBREG (v2f64 VR128:$src2), sub_sd))>;
 548   def : Pat<(v2i64 (movl VR128:$src1, VR128:$src2)),
 549             (VMOVSDrr (v2i64 VR128:$src1),
 550                       (EXTRACT_SUBREG (v2i64 VR128:$src2), sub_sd))>;
 551
 552   // vector_shuffle v1, v2 <4, 5, 2, 3> using movsd
 553   def : Pat<(v4f32 (movlp VR128:$src1, VR128:$src2)),
 554             (VMOVSDrr VR128:$src1, (EXTRACT_SUBREG VR128:$src2, sub_sd))>;
 555   def : Pat<(v4i32 (movlp VR128:$src1, VR128:$src2)),
 556             (VMOVSDrr VR128:$src1, (EXTRACT_SUBREG VR128:$src2, sub_sd))>;
 557
 558   // Move scalar to XMM zero-extended, zeroing a VR128 then do a
 559   // MOVS{S,D} to the lower bits.
 560   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector FR32:$src)))),
 561             (VMOVSSrr (v4f32 (AVX_SET0PS)), FR32:$src)>;
 562   def : Pat<(v4f32 (X86vzmovl (v4f32 VR128:$src))),
 563             (VMOVSSrr (v4f32 (AVX_SET0PS)),
 564                       (f32 (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss)))>;
 565   def : Pat<(v4i32 (X86vzmovl (v4i32 VR128:$src))),
 566             (VMOVSSrr (v4i32 (AVX_SET0PI)),
 567                       (EXTRACT_SUBREG (v4i32 VR128:$src), sub_ss))>;
 568   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector FR64:$src)))),
 569             (VMOVSDrr (v2f64 (AVX_SET0PS)), FR64:$src)>;
 570   }
 571
 572   let AddedComplexity = 20 in {
 573   // MOVSSrm zeros the high parts of the register; represent this
 574   // with SUBREG_TO_REG. The AVX versions also write: DST[255:128] <- 0
 575   def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector (loadf32 addr:$src))))),
 576             (SUBREG_TO_REG (i32 0), (VMOVSSrm addr:$src), sub_ss)>;
 577   def : Pat<(v4f32 (scalar_to_vector (loadf32 addr:$src))),
 578             (SUBREG_TO_REG (i32 0), (VMOVSSrm addr:$src), sub_ss)>;
 579   def : Pat<(v4f32 (X86vzmovl (loadv4f32 addr:$src))),
 580             (SUBREG_TO_REG (i32 0), (VMOVSSrm addr:$src), sub_ss)>;
 581
 582   // MOVSDrm zeros the high parts of the register; represent this
 583   // with SUBREG_TO_REG. The AVX versions also write: DST[255:128] <- 0
 584   def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector (loadf64 addr:$src))))),
 585             (SUBREG_TO_REG (i64 0), (VMOVSDrm addr:$src), sub_sd)>;
 586   def : Pat<(v2f64 (scalar_to_vector (loadf64 addr:$src))),
 587             (SUBREG_TO_REG (i64 0), (VMOVSDrm addr:$src), sub_sd)>;
 588   def : Pat<(v2f64 (X86vzmovl (loadv2f64 addr:$src))),
 589             (SUBREG_TO_REG (i64 0), (VMOVSDrm addr:$src), sub_sd)>;
 590   def : Pat<(v2f64 (X86vzmovl (bc_v2f64 (loadv4f32 addr:$src)))),
 591             (SUBREG_TO_REG (i64 0), (VMOVSDrm addr:$src), sub_sd)>;
 592   def : Pat<(v2f64 (X86vzload addr:$src)),
 593             (SUBREG_TO_REG (i64 0), (VMOVSDrm addr:$src), sub_sd)>;
 594
 595   // Represent the same patterns above but in the form they appear for
 596   // 256-bit types
 597   def : Pat<(v8f32 (X86vzmovl (insert_subvector undef,
 598                    (v4f32 (scalar_to_vector (loadf32 addr:$src))), (i32 0)))),
 599             (SUBREG_TO_REG (i32 0), (VMOVSSrm addr:$src), sub_ss)>;
 600   def : Pat<(v4f64 (X86vzmovl (insert_subvector undef,
 601                    (v2f64 (scalar_to_vector (loadf64 addr:$src))), (i32 0)))),
 602             (SUBREG_TO_REG (i32 0), (VMOVSDrm addr:$src), sub_sd)>;
 603   }
 604   def : Pat<(v8f32 (X86vzmovl (insert_subvector undef,
 605                    (v4f32 (scalar_to_vector FR32:$src)), (i32 0)))),
 606             (SUBREG_TO_REG (i32 0),
 607                            (v4f32 (VMOVSSrr (v4f32 (AVX_SET0PS)), FR32:$src)),
 608                            sub_xmm)>;
 609   def : Pat<(v4f64 (X86vzmovl (insert_subvector undef,
 610                    (v2f64 (scalar_to_vector FR64:$src)), (i32 0)))),
 611             (SUBREG_TO_REG (i64 0),
 612                            (v2f64 (VMOVSDrr (v2f64 (AVX_SET0PS)), FR64:$src)),
 613                            sub_xmm)>;
 614
 615   // Extract and store.
 616   def : Pat<(store (f32 (vector_extract (v4f32 VR128:$src), (iPTR 0))),
 617                    addr:$dst),
 618             (VMOVSSmr addr:$dst,
 619                      (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss))>;
 620   def : Pat<(store (f64 (vector_extract (v2f64 VR128:$src), (iPTR 0))),
 621                    addr:$dst),
 622             (VMOVSDmr addr:$dst,
 623                      (EXTRACT_SUBREG (v2f64 VR128:$src), sub_sd))>;
 624
 625   // Shuffle with VMOVSS
 626   def : Pat<(v4f32 (X86Movss VR128:$src1, (scalar_to_vector FR32:$src2))),
 627             (VMOVSSrr VR128:$src1, FR32:$src2)>;
 628   def : Pat<(v4i32 (X86Movss VR128:$src1, VR128:$src2)),
 629             (VMOVSSrr (v4i32 VR128:$src1),
 630                       (EXTRACT_SUBREG (v4i32 VR128:$src2), sub_ss))>;
 631   def : Pat<(v4f32 (X86Movss VR128:$src1, VR128:$src2)),
 632             (VMOVSSrr (v4f32 VR128:$src1),
 633                       (EXTRACT_SUBREG (v4f32 VR128:$src2), sub_ss))>;
 634
 635   // Shuffle with VMOVSD
 636   def : Pat<(v2f64 (X86Movsd VR128:$src1, (scalar_to_vector FR64:$src2))),
 637             (VMOVSDrr VR128:$src1, FR64:$src2)>;
 638   def : Pat<(v2i64 (X86Movsd VR128:$src1, VR128:$src2)),
 639             (VMOVSDrr (v2i64 VR128:$src1),
 640                      (EXTRACT_SUBREG (v2i64 VR128:$src2), sub_sd))>;
 641   def : Pat<(v2f64 (X86Movsd VR128:$src1, VR128:$src2)),
 642             (VMOVSDrr (v2f64 VR128:$src1),
 643                      (EXTRACT_SUBREG (v2f64 VR128:$src2), sub_sd))>;
 644   def : Pat<(v4f32 (X86Movsd VR128:$src1, VR128:$src2)),
 645             (VMOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4f32 VR128:$src2),
 646                                                    sub_sd))>;
 647   def : Pat<(v4i32 (X86Movsd VR128:$src1, VR128:$src2)),
 648             (VMOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4i32 VR128:$src2),
 649                                                    sub_sd))>;
 650
 651   // FIXME: Instead of a X86Movlps there should be a X86Movsd here, the problem
 652   // is during lowering, where it's not possible to recognize the fold cause
 653   // it has two uses through a bitcast. One use disappears at isel time and the
 654   // fold opportunity reappears.
 655   def : Pat<(v4f32 (X86Movlps VR128:$src1, VR128:$src2)),
 656             (VMOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4f32 VR128:$src2),
 657                                                    sub_sd))>;
 658   def : Pat<(v4i32 (X86Movlps VR128:$src1, VR128:$src2)),
 659             (VMOVSDrr VR128:$src1, (EXTRACT_SUBREG (v4i32 VR128:$src2),
 660                                                    sub_sd))>;
 661 }
 662
 663 //===----------------------------------------------------------------------===//
 664 // SSE 1 & 2 - Move Aligned/Unaligned FP Instructions
 665 //===----------------------------------------------------------------------===//
 666
 667 multiclass sse12_mov_packed<bits<8> opc, RegisterClass RC,
 668                             X86MemOperand x86memop, PatFrag ld_frag,
 669                             string asm, Domain d,
 670                             bit IsReMaterializable = 1> {
 671 let neverHasSideEffects = 1 in
 672   def rr : PI<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src),
 673               !strconcat(asm, "\t{$src, $dst|$dst, $src}"), [], d>;
 674 let canFoldAsLoad = 1, isReMaterializable = IsReMaterializable in
 675   def rm : PI<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
 676               !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
 677                    [(set RC:$dst, (ld_frag addr:$src))], d>;
 678 }
 679
 680 defm VMOVAPS : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv4f32,
 681                               "movaps", SSEPackedSingle>, TB, VEX;
 682 defm VMOVAPD : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv2f64,
 683                               "movapd", SSEPackedDouble>, TB, OpSize, VEX;
 684 defm VMOVUPS : sse12_mov_packed<0x10, VR128, f128mem, loadv4f32,
 685                               "movups", SSEPackedSingle>, TB, VEX;
 686 defm VMOVUPD : sse12_mov_packed<0x10, VR128, f128mem, loadv2f64,
 687                               "movupd", SSEPackedDouble, 0>, TB, OpSize, VEX;
 688
 689 defm VMOVAPSY : sse12_mov_packed<0x28, VR256, f256mem, alignedloadv8f32,
 690                               "movaps", SSEPackedSingle>, TB, VEX;
 691 defm VMOVAPDY : sse12_mov_packed<0x28, VR256, f256mem, alignedloadv4f64,
 692                               "movapd", SSEPackedDouble>, TB, OpSize, VEX;
 693 defm VMOVUPSY : sse12_mov_packed<0x10, VR256, f256mem, loadv8f32,
 694                               "movups", SSEPackedSingle>, TB, VEX;
 695 defm VMOVUPDY : sse12_mov_packed<0x10, VR256, f256mem, loadv4f64,
 696                               "movupd", SSEPackedDouble, 0>, TB, OpSize, VEX;
 697 defm MOVAPS : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv4f32,
 698                               "movaps", SSEPackedSingle>, TB;
 699 defm MOVAPD : sse12_mov_packed<0x28, VR128, f128mem, alignedloadv2f64,
 700                               "movapd", SSEPackedDouble>, TB, OpSize;
 701 defm MOVUPS : sse12_mov_packed<0x10, VR128, f128mem, loadv4f32,
 702                               "movups", SSEPackedSingle>, TB;
 703 defm MOVUPD : sse12_mov_packed<0x10, VR128, f128mem, loadv2f64,
 704                               "movupd", SSEPackedDouble, 0>, TB, OpSize;
 705
 706 def VMOVAPSmr : VPSI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 707                    "movaps\t{$src, $dst|$dst, $src}",
 708                    [(alignedstore (v4f32 VR128:$src), addr:$dst)]>, VEX;
 709 def VMOVAPDmr : VPDI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 710                    "movapd\t{$src, $dst|$dst, $src}",
 711                    [(alignedstore (v2f64 VR128:$src), addr:$dst)]>, VEX;
 712 def VMOVUPSmr : VPSI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 713                    "movups\t{$src, $dst|$dst, $src}",
 714                    [(store (v4f32 VR128:$src), addr:$dst)]>, VEX;
 715 def VMOVUPDmr : VPDI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 716                    "movupd\t{$src, $dst|$dst, $src}",
 717                    [(store (v2f64 VR128:$src), addr:$dst)]>, VEX;
 718 def VMOVAPSYmr : VPSI<0x29, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 719                    "movaps\t{$src, $dst|$dst, $src}",
 720                    [(alignedstore256 (v8f32 VR256:$src), addr:$dst)]>, VEX;
 721 def VMOVAPDYmr : VPDI<0x29, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 722                    "movapd\t{$src, $dst|$dst, $src}",
 723                    [(alignedstore256 (v4f64 VR256:$src), addr:$dst)]>, VEX;
 724 def VMOVUPSYmr : VPSI<0x11, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 725                    "movups\t{$src, $dst|$dst, $src}",
 726                    [(store (v8f32 VR256:$src), addr:$dst)]>, VEX;
 727 def VMOVUPDYmr : VPDI<0x11, MRMDestMem, (outs), (ins f256mem:$dst, VR256:$src),
 728                    "movupd\t{$src, $dst|$dst, $src}",
 729                    [(store (v4f64 VR256:$src), addr:$dst)]>, VEX;
 730
 731 // For disassembler
 732 let isCodeGenOnly = 1 in {
 733   def VMOVAPSrr_REV : VPSI<0x29, MRMDestReg, (outs VR128:$dst),
 734                           (ins VR128:$src),
 735                           "movaps\t{$src, $dst|$dst, $src}", []>, VEX;
 736   def VMOVAPDrr_REV : VPDI<0x29, MRMDestReg, (outs VR128:$dst),
 737                            (ins VR128:$src),
 738                            "movapd\t{$src, $dst|$dst, $src}", []>, VEX;
 739   def VMOVUPSrr_REV : VPSI<0x11, MRMDestReg, (outs VR128:$dst),
 740                            (ins VR128:$src),
 741                            "movups\t{$src, $dst|$dst, $src}", []>, VEX;
 742   def VMOVUPDrr_REV : VPDI<0x11, MRMDestReg, (outs VR128:$dst),
 743                            (ins VR128:$src),
 744                            "movupd\t{$src, $dst|$dst, $src}", []>, VEX;
 745   def VMOVAPSYrr_REV : VPSI<0x29, MRMDestReg, (outs VR256:$dst),
 746                             (ins VR256:$src),
 747                             "movaps\t{$src, $dst|$dst, $src}", []>, VEX;
 748   def VMOVAPDYrr_REV : VPDI<0x29, MRMDestReg, (outs VR256:$dst),
 749                             (ins VR256:$src),
 750                             "movapd\t{$src, $dst|$dst, $src}", []>, VEX;
 751   def VMOVUPSYrr_REV : VPSI<0x11, MRMDestReg, (outs VR256:$dst),
 752                             (ins VR256:$src),
 753                             "movups\t{$src, $dst|$dst, $src}", []>, VEX;
 754   def VMOVUPDYrr_REV : VPDI<0x11, MRMDestReg, (outs VR256:$dst),
 755                             (ins VR256:$src),
 756                             "movupd\t{$src, $dst|$dst, $src}", []>, VEX;
 757 }
 758
 759 def : Pat<(int_x86_avx_loadu_ps_256 addr:$src), (VMOVUPSYrm addr:$src)>;
 760 def : Pat<(int_x86_avx_storeu_ps_256 addr:$dst, VR256:$src),
 761           (VMOVUPSYmr addr:$dst, VR256:$src)>;
 762
 763 def : Pat<(int_x86_avx_loadu_pd_256 addr:$src), (VMOVUPDYrm addr:$src)>;
 764 def : Pat<(int_x86_avx_storeu_pd_256 addr:$dst, VR256:$src),
 765           (VMOVUPDYmr addr:$dst, VR256:$src)>;
 766
 767 def MOVAPSmr : PSI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 768                    "movaps\t{$src, $dst|$dst, $src}",
 769                    [(alignedstore (v4f32 VR128:$src), addr:$dst)]>;
 770 def MOVAPDmr : PDI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 771                    "movapd\t{$src, $dst|$dst, $src}",
 772                    [(alignedstore (v2f64 VR128:$src), addr:$dst)]>;
 773 def MOVUPSmr : PSI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 774                    "movups\t{$src, $dst|$dst, $src}",
 775                    [(store (v4f32 VR128:$src), addr:$dst)]>;
 776 def MOVUPDmr : PDI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 777                    "movupd\t{$src, $dst|$dst, $src}",
 778                    [(store (v2f64 VR128:$src), addr:$dst)]>;
 779
 780 // For disassembler
 781 let isCodeGenOnly = 1 in {
 782   def MOVAPSrr_REV : PSI<0x29, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 783                          "movaps\t{$src, $dst|$dst, $src}", []>;
 784   def MOVAPDrr_REV : PDI<0x29, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 785                          "movapd\t{$src, $dst|$dst, $src}", []>;
 786   def MOVUPSrr_REV : PSI<0x11, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 787                          "movups\t{$src, $dst|$dst, $src}", []>;
 788   def MOVUPDrr_REV : PDI<0x11, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
 789                          "movupd\t{$src, $dst|$dst, $src}", []>;
 790 }
 791
 792 let Predicates = [HasAVX] in {
 793   def : Pat<(int_x86_sse_storeu_ps addr:$dst, VR128:$src),
 794             (VMOVUPSmr addr:$dst, VR128:$src)>;
 795   def : Pat<(int_x86_sse2_storeu_pd addr:$dst, VR128:$src),
 796             (VMOVUPDmr addr:$dst, VR128:$src)>;
 797 }
 798
 799 let Predicates = [HasSSE1] in
 800   def : Pat<(int_x86_sse_storeu_ps addr:$dst, VR128:$src),
 801             (MOVUPSmr addr:$dst, VR128:$src)>;
 802 let Predicates = [HasSSE2] in
 803   def : Pat<(int_x86_sse2_storeu_pd addr:$dst, VR128:$src),
 804             (MOVUPDmr addr:$dst, VR128:$src)>;
 805
 806 // Use movaps / movups for SSE integer load / store (one byte shorter).
 807 // The instructions selected below are then converted to MOVDQA/MOVDQU
 808 // during the SSE domain pass.
 809 let Predicates = [HasSSE1] in {
 810   def : Pat<(alignedloadv4i32 addr:$src),
 811             (MOVAPSrm addr:$src)>;
 812   def : Pat<(loadv4i32 addr:$src),
 813             (MOVUPSrm addr:$src)>;
 814   def : Pat<(alignedloadv2i64 addr:$src),
 815             (MOVAPSrm addr:$src)>;
 816   def : Pat<(loadv2i64 addr:$src),
 817             (MOVUPSrm addr:$src)>;
 818
 819   def : Pat<(alignedstore (v2i64 VR128:$src), addr:$dst),
 820             (MOVAPSmr addr:$dst, VR128:$src)>;
 821   def : Pat<(alignedstore (v4i32 VR128:$src), addr:$dst),
 822             (MOVAPSmr addr:$dst, VR128:$src)>;
 823   def : Pat<(alignedstore (v8i16 VR128:$src), addr:$dst),
 824             (MOVAPSmr addr:$dst, VR128:$src)>;
 825   def : Pat<(alignedstore (v16i8 VR128:$src), addr:$dst),
 826             (MOVAPSmr addr:$dst, VR128:$src)>;
 827   def : Pat<(store (v2i64 VR128:$src), addr:$dst),
 828             (MOVUPSmr addr:$dst, VR128:$src)>;
 829   def : Pat<(store (v4i32 VR128:$src), addr:$dst),
 830             (MOVUPSmr addr:$dst, VR128:$src)>;
 831   def : Pat<(store (v8i16 VR128:$src), addr:$dst),
 832             (MOVUPSmr addr:$dst, VR128:$src)>;
 833   def : Pat<(store (v16i8 VR128:$src), addr:$dst),
 834             (MOVUPSmr addr:$dst, VR128:$src)>;
 835 }
 836
 837 // Use vmovaps/vmovups for AVX integer load/store.
 838 let Predicates = [HasAVX] in {
 839   // 128-bit load/store
 840   def : Pat<(alignedloadv4i32 addr:$src),
 841             (VMOVAPSrm addr:$src)>;
 842   def : Pat<(loadv4i32 addr:$src),
 843             (VMOVUPSrm addr:$src)>;
 844   def : Pat<(alignedloadv2i64 addr:$src),
 845             (VMOVAPSrm addr:$src)>;
 846   def : Pat<(loadv2i64 addr:$src),
 847             (VMOVUPSrm addr:$src)>;
 848
 849   def : Pat<(alignedstore (v2i64 VR128:$src), addr:$dst),
 850             (VMOVAPSmr addr:$dst, VR128:$src)>;
 851   def : Pat<(alignedstore (v4i32 VR128:$src), addr:$dst),
 852             (VMOVAPSmr addr:$dst, VR128:$src)>;
 853   def : Pat<(alignedstore (v8i16 VR128:$src), addr:$dst),
 854             (VMOVAPSmr addr:$dst, VR128:$src)>;
 855   def : Pat<(alignedstore (v16i8 VR128:$src), addr:$dst),
 856             (VMOVAPSmr addr:$dst, VR128:$src)>;
 857   def : Pat<(store (v2i64 VR128:$src), addr:$dst),
 858             (VMOVUPSmr addr:$dst, VR128:$src)>;
 859   def : Pat<(store (v4i32 VR128:$src), addr:$dst),
 860             (VMOVUPSmr addr:$dst, VR128:$src)>;
 861   def : Pat<(store (v8i16 VR128:$src), addr:$dst),
 862             (VMOVUPSmr addr:$dst, VR128:$src)>;
 863   def : Pat<(store (v16i8 VR128:$src), addr:$dst),
 864             (VMOVUPSmr addr:$dst, VR128:$src)>;
 865
 866   // 256-bit load/store
 867   def : Pat<(alignedloadv4i64 addr:$src),
 868             (VMOVAPSYrm addr:$src)>;
 869   def : Pat<(loadv4i64 addr:$src),
 870             (VMOVUPSYrm addr:$src)>;
 871   def : Pat<(alignedloadv8i32 addr:$src),
 872             (VMOVAPSYrm addr:$src)>;
 873   def : Pat<(loadv8i32 addr:$src),
 874             (VMOVUPSYrm addr:$src)>;
 875   def : Pat<(alignedstore256 (v4i64 VR256:$src), addr:$dst),
 876             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 877   def : Pat<(alignedstore256 (v8i32 VR256:$src), addr:$dst),
 878             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 879   def : Pat<(alignedstore256 (v16i16 VR256:$src), addr:$dst),
 880             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 881   def : Pat<(alignedstore256 (v32i8 VR256:$src), addr:$dst),
 882             (VMOVAPSYmr addr:$dst, VR256:$src)>;
 883   def : Pat<(store (v4i64 VR256:$src), addr:$dst),
 884             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 885   def : Pat<(store (v8i32 VR256:$src), addr:$dst),
 886             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 887   def : Pat<(store (v16i16 VR256:$src), addr:$dst),
 888             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 889   def : Pat<(store (v32i8 VR256:$src), addr:$dst),
 890             (VMOVUPSYmr addr:$dst, VR256:$src)>;
 891 }
 892
 893 // Alias instruction to do FR32 or FR64 reg-to-reg copy using movaps. Upper
 894 // bits are disregarded. FIXME: Set encoding to pseudo!
 895 let neverHasSideEffects = 1 in {
 896 def FsMOVAPSrr : PSI<0x28, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src),
 897                      "movaps\t{$src, $dst|$dst, $src}", []>;
 898 def FsMOVAPDrr : PDI<0x28, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src),
 899                      "movapd\t{$src, $dst|$dst, $src}", []>;
 900 def FsVMOVAPSrr : VPSI<0x28, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src),
 901                        "movaps\t{$src, $dst|$dst, $src}", []>, VEX;
 902 def FsVMOVAPDrr : VPDI<0x28, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src),
 903                        "movapd\t{$src, $dst|$dst, $src}", []>, VEX;
 904 }
 905
 906 // Alias instruction to load FR32 or FR64 from f128mem using movaps. Upper
 907 // bits are disregarded. FIXME: Set encoding to pseudo!
 908 let canFoldAsLoad = 1, isReMaterializable = 1 in {
 909 def FsMOVAPSrm : PSI<0x28, MRMSrcMem, (outs FR32:$dst), (ins f128mem:$src),
 910                      "movaps\t{$src, $dst|$dst, $src}",
 911                      [(set FR32:$dst, (alignedloadfsf32 addr:$src))]>;
 912 def FsMOVAPDrm : PDI<0x28, MRMSrcMem, (outs FR64:$dst), (ins f128mem:$src),
 913                      "movapd\t{$src, $dst|$dst, $src}",
 914                      [(set FR64:$dst, (alignedloadfsf64 addr:$src))]>;
 915 let isCodeGenOnly = 1 in {
 916   def FsVMOVAPSrm : VPSI<0x28, MRMSrcMem, (outs FR32:$dst), (ins f128mem:$src),
 917                          "movaps\t{$src, $dst|$dst, $src}",
 918                          [(set FR32:$dst, (alignedloadfsf32 addr:$src))]>, VEX;
 919   def FsVMOVAPDrm : VPDI<0x28, MRMSrcMem, (outs FR64:$dst), (ins f128mem:$src),
 920                          "movapd\t{$src, $dst|$dst, $src}",
 921                          [(set FR64:$dst, (alignedloadfsf64 addr:$src))]>, VEX;
 922 }
 923 }
 924
 925 //===----------------------------------------------------------------------===//
 926 // SSE 1 & 2 - Move Low packed FP Instructions
 927 //===----------------------------------------------------------------------===//
 928
 929 multiclass sse12_mov_hilo_packed<bits<8>opc, RegisterClass RC,
 930                                  PatFrag mov_frag, string base_opc,
 931                                  string asm_opr> {
 932   def PSrm : PI<opc, MRMSrcMem,
 933          (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
 934          !strconcat(base_opc, "s", asm_opr),
 935      [(set RC:$dst,
 936        (mov_frag RC:$src1,
 937               (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))))],
 938               SSEPackedSingle>, TB;
 939
 940   def PDrm : PI<opc, MRMSrcMem,
 941          (outs RC:$dst), (ins RC:$src1, f64mem:$src2),
 942          !strconcat(base_opc, "d", asm_opr),
 943      [(set RC:$dst, (v2f64 (mov_frag RC:$src1,
 944                               (scalar_to_vector (loadf64 addr:$src2)))))],
 945               SSEPackedDouble>, TB, OpSize;
 946 }
 947
 948 let AddedComplexity = 20 in {
 949   defm VMOVL : sse12_mov_hilo_packed<0x12, VR128, movlp, "movlp",
 950                      "\t{$src2, $src1, $dst|$dst, $src1, $src2}">, VEX_4V;
 951 }
 952 let Constraints = "$src1 = $dst", AddedComplexity = 20 in {
 953   defm MOVL : sse12_mov_hilo_packed<0x12, VR128, movlp, "movlp",
 954                                    "\t{$src2, $dst|$dst, $src2}">;
 955 }
 956
 957 def VMOVLPSmr : VPSI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
 958                    "movlps\t{$src, $dst|$dst, $src}",
 959                    [(store (f64 (vector_extract (bc_v2f64 (v4f32 VR128:$src)),
 960                                  (iPTR 0))), addr:$dst)]>, VEX;
 961 def VMOVLPDmr : VPDI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
 962                    "movlpd\t{$src, $dst|$dst, $src}",
 963                    [(store (f64 (vector_extract (v2f64 VR128:$src),
 964                                  (iPTR 0))), addr:$dst)]>, VEX;
 965 def MOVLPSmr : PSI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
 966                    "movlps\t{$src, $dst|$dst, $src}",
 967                    [(store (f64 (vector_extract (bc_v2f64 (v4f32 VR128:$src)),
 968                                  (iPTR 0))), addr:$dst)]>;
 969 def MOVLPDmr : PDI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
 970                    "movlpd\t{$src, $dst|$dst, $src}",
 971                    [(store (f64 (vector_extract (v2f64 VR128:$src),
 972                                  (iPTR 0))), addr:$dst)]>;
 973
 974 let Predicates = [HasAVX] in {
 975   let AddedComplexity = 20 in {
 976     // vector_shuffle v1, (load v2) <4, 5, 2, 3> using MOVLPS
 977     def : Pat<(v4f32 (movlp VR128:$src1, (load addr:$src2))),
 978               (VMOVLPSrm VR128:$src1, addr:$src2)>;
 979     def : Pat<(v4i32 (movlp VR128:$src1, (load addr:$src2))),
 980               (VMOVLPSrm VR128:$src1, addr:$src2)>;
 981     // vector_shuffle v1, (load v2) <2, 1> using MOVLPS
 982     def : Pat<(v2f64 (movlp VR128:$src1, (load addr:$src2))),
 983               (VMOVLPDrm VR128:$src1, addr:$src2)>;
 984     def : Pat<(v2i64 (movlp VR128:$src1, (load addr:$src2))),
 985               (VMOVLPDrm VR128:$src1, addr:$src2)>;
 986   }
 987
 988   // (store (vector_shuffle (load addr), v2, <4, 5, 2, 3>), addr) using MOVLPS
 989   def : Pat<(store (v4f32 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
 990             (VMOVLPSmr addr:$src1, VR128:$src2)>;
 991   def : Pat<(store (v4i32 (movlp (bc_v4i32 (loadv2i64 addr:$src1)),
 992                                  VR128:$src2)), addr:$src1),
 993             (VMOVLPSmr addr:$src1, VR128:$src2)>;
 994
 995   // (store (vector_shuffle (load addr), v2, <2, 1>), addr) using MOVLPS
 996   def : Pat<(store (v2f64 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
 997             (VMOVLPDmr addr:$src1, VR128:$src2)>;
 998   def : Pat<(store (v2i64 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
 999             (VMOVLPDmr addr:$src1, VR128:$src2)>;
1000
1001   // Shuffle with VMOVLPS
1002   def : Pat<(v4f32 (X86Movlps VR128:$src1, (load addr:$src2))),
1003             (VMOVLPSrm VR128:$src1, addr:$src2)>;
1004   def : Pat<(v4i32 (X86Movlps VR128:$src1, (load addr:$src2))),
1005             (VMOVLPSrm VR128:$src1, addr:$src2)>;
1006   def : Pat<(X86Movlps VR128:$src1,
1007                       (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))),
1008             (VMOVLPSrm VR128:$src1, addr:$src2)>;
1009
1010   // Shuffle with VMOVLPD
1011   def : Pat<(v2f64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1012             (VMOVLPDrm VR128:$src1, addr:$src2)>;
1013   def : Pat<(v2i64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1014             (VMOVLPDrm VR128:$src1, addr:$src2)>;
1015   def : Pat<(v2f64 (X86Movlpd VR128:$src1,
1016                               (scalar_to_vector (loadf64 addr:$src2)))),
1017             (VMOVLPDrm VR128:$src1, addr:$src2)>;
1018
1019   // Store patterns
1020   def : Pat<(store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)),
1021                    addr:$src1),
1022             (VMOVLPSmr addr:$src1, VR128:$src2)>;
1023   def : Pat<(store (v4i32 (X86Movlps
1024                    (bc_v4i32 (loadv2i64 addr:$src1)), VR128:$src2)), addr:$src1),
1025             (VMOVLPSmr addr:$src1, VR128:$src2)>;
1026   def : Pat<(store (v2f64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1027                    addr:$src1),
1028             (VMOVLPDmr addr:$src1, VR128:$src2)>;
1029   def : Pat<(store (v2i64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1030                    addr:$src1),
1031             (VMOVLPDmr addr:$src1, VR128:$src2)>;
1032 }
1033
1034 let Predicates = [HasSSE1] in {
1035   let AddedComplexity = 20 in {
1036     // vector_shuffle v1, (load v2) <4, 5, 2, 3> using MOVLPS
1037     def : Pat<(v4f32 (movlp VR128:$src1, (load addr:$src2))),
1038               (MOVLPSrm VR128:$src1, addr:$src2)>;
1039     def : Pat<(v4i32 (movlp VR128:$src1, (load addr:$src2))),
1040               (MOVLPSrm VR128:$src1, addr:$src2)>;
1041   }
1042
1043   // (store (vector_shuffle (load addr), v2, <4, 5, 2, 3>), addr) using MOVLPS
1044   def : Pat<(store (v4f32 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
1045             (MOVLPSmr addr:$src1, VR128:$src2)>;
1046   def : Pat<(store (v4i32 (movlp (bc_v4i32 (loadv2i64 addr:$src1)),
1047                                  VR128:$src2)), addr:$src1),
1048             (MOVLPSmr addr:$src1, VR128:$src2)>;
1049
1050   // Shuffle with MOVLPS
1051   def : Pat<(v4f32 (X86Movlps VR128:$src1, (load addr:$src2))),
1052             (MOVLPSrm VR128:$src1, addr:$src2)>;
1053   def : Pat<(v4i32 (X86Movlps VR128:$src1, (load addr:$src2))),
1054             (MOVLPSrm VR128:$src1, addr:$src2)>;
1055   def : Pat<(X86Movlps VR128:$src1,
1056                       (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))),
1057             (MOVLPSrm VR128:$src1, addr:$src2)>;
1058
1059   // Store patterns
1060   def : Pat<(store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)),
1061                                       addr:$src1),
1062             (MOVLPSmr addr:$src1, VR128:$src2)>;
1063   def : Pat<(store (v4i32 (X86Movlps
1064                    (bc_v4i32 (loadv2i64 addr:$src1)), VR128:$src2)),
1065                               addr:$src1),
1066             (MOVLPSmr addr:$src1, VR128:$src2)>;
1067 }
1068
1069 let Predicates = [HasSSE2] in {
1070   let AddedComplexity = 20 in {
1071     // vector_shuffle v1, (load v2) <2, 1> using MOVLPS
1072     def : Pat<(v2f64 (movlp VR128:$src1, (load addr:$src2))),
1073               (MOVLPDrm VR128:$src1, addr:$src2)>;
1074     def : Pat<(v2i64 (movlp VR128:$src1, (load addr:$src2))),
1075               (MOVLPDrm VR128:$src1, addr:$src2)>;
1076   }
1077
1078   // (store (vector_shuffle (load addr), v2, <2, 1>), addr) using MOVLPS
1079   def : Pat<(store (v2f64 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
1080             (MOVLPDmr addr:$src1, VR128:$src2)>;
1081   def : Pat<(store (v2i64 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
1082             (MOVLPDmr addr:$src1, VR128:$src2)>;
1083
1084   // Shuffle with MOVLPD
1085   def : Pat<(v2f64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1086             (MOVLPDrm VR128:$src1, addr:$src2)>;
1087   def : Pat<(v2i64 (X86Movlpd VR128:$src1, (load addr:$src2))),
1088             (MOVLPDrm VR128:$src1, addr:$src2)>;
1089   def : Pat<(v2f64 (X86Movlpd VR128:$src1,
1090                               (scalar_to_vector (loadf64 addr:$src2)))),
1091             (MOVLPDrm VR128:$src1, addr:$src2)>;
1092
1093   // Store patterns
1094   def : Pat<(store (v2f64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1095                            addr:$src1),
1096             (MOVLPDmr addr:$src1, VR128:$src2)>;
1097   def : Pat<(store (v2i64 (X86Movlpd (load addr:$src1), VR128:$src2)),
1098                            addr:$src1),
1099             (MOVLPDmr addr:$src1, VR128:$src2)>;
1100 }
1101
1102 //===----------------------------------------------------------------------===//
1103 // SSE 1 & 2 - Move Hi packed FP Instructions
1104 //===----------------------------------------------------------------------===//
1105
1106 let AddedComplexity = 20 in {
1107   defm VMOVH : sse12_mov_hilo_packed<0x16, VR128, movlhps, "movhp",
1108                      "\t{$src2, $src1, $dst|$dst, $src1, $src2}">, VEX_4V;
1109 }
1110 let Constraints = "$src1 = $dst", AddedComplexity = 20 in {
1111   defm MOVH : sse12_mov_hilo_packed<0x16, VR128, movlhps, "movhp",
1112                                    "\t{$src2, $dst|$dst, $src2}">;
1113 }
1114
1115 // v2f64 extract element 1 is always custom lowered to unpack high to low
1116 // and extract element 0 so the non-store version isn't too horrible.
1117 def VMOVHPSmr : VPSI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1118                    "movhps\t{$src, $dst|$dst, $src}",
1119                    [(store (f64 (vector_extract
1120                                  (unpckh (bc_v2f64 (v4f32 VR128:$src)),
1121                                          (undef)), (iPTR 0))), addr:$dst)]>,
1122                    VEX;
1123 def VMOVHPDmr : VPDI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1124                    "movhpd\t{$src, $dst|$dst, $src}",
1125                    [(store (f64 (vector_extract
1126                                  (v2f64 (unpckh VR128:$src, (undef))),
1127                                  (iPTR 0))), addr:$dst)]>,
1128                    VEX;
1129 def MOVHPSmr : PSI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1130                    "movhps\t{$src, $dst|$dst, $src}",
1131                    [(store (f64 (vector_extract
1132                                  (unpckh (bc_v2f64 (v4f32 VR128:$src)),
1133                                          (undef)), (iPTR 0))), addr:$dst)]>;
1134 def MOVHPDmr : PDI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1135                    "movhpd\t{$src, $dst|$dst, $src}",
1136                    [(store (f64 (vector_extract
1137                                  (v2f64 (unpckh VR128:$src, (undef))),
1138                                  (iPTR 0))), addr:$dst)]>;
1139
1140 let Predicates = [HasAVX] in {
1141   // VMOVHPS patterns
1142   def : Pat<(movlhps VR128:$src1, (bc_v4i32 (v2i64 (X86vzload addr:$src2)))),
1143             (VMOVHPSrm (v4i32 VR128:$src1), addr:$src2)>;
1144   def : Pat<(X86Movlhps VR128:$src1,
1145                  (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))),
1146             (VMOVHPSrm VR128:$src1, addr:$src2)>;
1147   def : Pat<(X86Movlhps VR128:$src1,
1148                  (bc_v4i32 (v2i64 (X86vzload addr:$src2)))),
1149             (VMOVHPSrm VR128:$src1, addr:$src2)>;
1150
1151   // FIXME: Instead of X86Unpcklpd, there should be a X86Movlhpd here, the problem
1152   // is during lowering, where it's not possible to recognize the load fold cause
1153   // it has two uses through a bitcast. One use disappears at isel time and the
1154   // fold opportunity reappears.
1155   def : Pat<(v2f64 (X86Unpcklpd VR128:$src1,
1156                       (scalar_to_vector (loadf64 addr:$src2)))),
1157             (VMOVHPDrm VR128:$src1, addr:$src2)>;
1158
1159   // FIXME: This should be matched by a X86Movhpd instead. Same as above
1160   def : Pat<(v2f64 (X86Movlhpd VR128:$src1,
1161                       (scalar_to_vector (loadf64 addr:$src2)))),
1162             (VMOVHPDrm VR128:$src1, addr:$src2)>;
1163
1164   // Store patterns
1165   def : Pat<(store (f64 (vector_extract
1166             (v2f64 (X86Unpckhps VR128:$src, (undef))), (iPTR 0))), addr:$dst),
1167             (VMOVHPSmr addr:$dst, VR128:$src)>;
1168   def : Pat<(store (f64 (vector_extract
1169             (v2f64 (X86Unpckhpd VR128:$src, (undef))), (iPTR 0))), addr:$dst),
1170             (VMOVHPDmr addr:$dst, VR128:$src)>;
1171 }
1172
1173 let Predicates = [HasSSE1] in {
1174   // MOVHPS patterns
1175   def : Pat<(movlhps VR128:$src1, (bc_v4i32 (v2i64 (X86vzload addr:$src2)))),
1176             (MOVHPSrm (v4i32 VR128:$src1), addr:$src2)>;
1177   def : Pat<(X86Movlhps VR128:$src1,
1178                  (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))),
1179             (MOVHPSrm VR128:$src1, addr:$src2)>;
1180   def : Pat<(X86Movlhps VR128:$src1,
1181                  (bc_v4f32 (v2i64 (X86vzload addr:$src2)))),
1182             (MOVHPSrm VR128:$src1, addr:$src2)>;
1183
1184   // Store patterns
1185   def : Pat<(store (f64 (vector_extract
1186             (v2f64 (X86Unpckhps VR128:$src, (undef))), (iPTR 0))), addr:$dst),
1187             (MOVHPSmr addr:$dst, VR128:$src)>;
1188 }
1189
1190 let Predicates = [HasSSE2] in {
1191   // FIXME: Instead of X86Unpcklpd, there should be a X86Movlhpd here, the problem
1192   // is during lowering, where it's not possible to recognize the load fold cause
1193   // it has two uses through a bitcast. One use disappears at isel time and the
1194   // fold opportunity reappears.
1195   def : Pat<(v2f64 (X86Unpcklpd VR128:$src1,
1196                       (scalar_to_vector (loadf64 addr:$src2)))),
1197             (MOVHPDrm VR128:$src1, addr:$src2)>;
1198
1199   // FIXME: This should be matched by a X86Movhpd instead. Same as above
1200   def : Pat<(v2f64 (X86Movlhpd VR128:$src1,
1201                       (scalar_to_vector (loadf64 addr:$src2)))),
1202             (MOVHPDrm VR128:$src1, addr:$src2)>;
1203
1204   // Store patterns
1205   def : Pat<(store (f64 (vector_extract
1206             (v2f64 (X86Unpckhpd VR128:$src, (undef))), (iPTR 0))),addr:$dst),
1207             (MOVHPDmr addr:$dst, VR128:$src)>;
1208 }
1209
1210 //===----------------------------------------------------------------------===//
1211 // SSE 1 & 2 - Move Low to High and High to Low packed FP Instructions
1212 //===----------------------------------------------------------------------===//
1213
1214 let AddedComplexity = 20 in {
1215   def VMOVLHPSrr : VPSI<0x16, MRMSrcReg, (outs VR128:$dst),
1216                                        (ins VR128:$src1, VR128:$src2),
1217                       "movlhps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1218                       [(set VR128:$dst,
1219                         (v4f32 (movlhps VR128:$src1, VR128:$src2)))]>,
1220                       VEX_4V;
1221   def VMOVHLPSrr : VPSI<0x12, MRMSrcReg, (outs VR128:$dst),
1222                                        (ins VR128:$src1, VR128:$src2),
1223                       "movhlps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1224                       [(set VR128:$dst,
1225                         (v4f32 (movhlps VR128:$src1, VR128:$src2)))]>,
1226                       VEX_4V;
1227 }
1228 let Constraints = "$src1 = $dst", AddedComplexity = 20 in {
1229   def MOVLHPSrr : PSI<0x16, MRMSrcReg, (outs VR128:$dst),
1230                                        (ins VR128:$src1, VR128:$src2),
1231                       "movlhps\t{$src2, $dst|$dst, $src2}",
1232                       [(set VR128:$dst,
1233                         (v4f32 (movlhps VR128:$src1, VR128:$src2)))]>;
1234   def MOVHLPSrr : PSI<0x12, MRMSrcReg, (outs VR128:$dst),
1235                                        (ins VR128:$src1, VR128:$src2),
1236                       "movhlps\t{$src2, $dst|$dst, $src2}",
1237                       [(set VR128:$dst,
1238                         (v4f32 (movhlps VR128:$src1, VR128:$src2)))]>;
1239 }
1240
1241 let Predicates = [HasAVX] in {
1242   // MOVLHPS patterns
1243   let AddedComplexity = 20 in {
1244     def : Pat<(v4f32 (movddup VR128:$src, (undef))),
1245               (VMOVLHPSrr (v4f32 VR128:$src), (v4f32 VR128:$src))>;
1246     def : Pat<(v2i64 (movddup VR128:$src, (undef))),
1247               (VMOVLHPSrr (v2i64 VR128:$src), (v2i64 VR128:$src))>;
1248
1249     // vector_shuffle v1, v2 <0, 1, 4, 5> using MOVLHPS
1250     def : Pat<(v4i32 (movlhps VR128:$src1, VR128:$src2)),
1251               (VMOVLHPSrr VR128:$src1, VR128:$src2)>;
1252   }
1253   def : Pat<(v4f32 (X86Movlhps VR128:$src1, VR128:$src2)),
1254             (VMOVLHPSrr VR128:$src1, VR128:$src2)>;
1255   def : Pat<(v4i32 (X86Movlhps VR128:$src1, VR128:$src2)),
1256             (VMOVLHPSrr VR128:$src1, VR128:$src2)>;
1257   def : Pat<(v2i64 (X86Movlhps VR128:$src1, VR128:$src2)),
1258             (VMOVLHPSrr (v2i64 VR128:$src1), VR128:$src2)>;
1259
1260   // MOVHLPS patterns
1261   let AddedComplexity = 20 in {
1262     // vector_shuffle v1, v2 <6, 7, 2, 3> using MOVHLPS
1263     def : Pat<(v4i32 (movhlps VR128:$src1, VR128:$src2)),
1264               (VMOVHLPSrr VR128:$src1, VR128:$src2)>;
1265
1266     // vector_shuffle v1, undef <2, ?, ?, ?> using MOVHLPS
1267     def : Pat<(v4f32 (movhlps_undef VR128:$src1, (undef))),
1268               (VMOVHLPSrr VR128:$src1, VR128:$src1)>;
1269     def : Pat<(v4i32 (movhlps_undef VR128:$src1, (undef))),
1270               (VMOVHLPSrr VR128:$src1, VR128:$src1)>;
1271   }
1272
1273   def : Pat<(v4f32 (X86Movhlps VR128:$src1, VR128:$src2)),
1274             (VMOVHLPSrr VR128:$src1, VR128:$src2)>;
1275   def : Pat<(v4i32 (X86Movhlps VR128:$src1, VR128:$src2)),
1276             (VMOVHLPSrr VR128:$src1, VR128:$src2)>;
1277 }
1278
1279 let Predicates = [HasSSE1] in {
1280   // MOVLHPS patterns
1281   let AddedComplexity = 20 in {
1282     def : Pat<(v4f32 (movddup VR128:$src, (undef))),
1283               (MOVLHPSrr (v4f32 VR128:$src), (v4f32 VR128:$src))>;
1284     def : Pat<(v2i64 (movddup VR128:$src, (undef))),
1285               (MOVLHPSrr (v2i64 VR128:$src), (v2i64 VR128:$src))>;
1286
1287     // vector_shuffle v1, v2 <0, 1, 4, 5> using MOVLHPS
1288     def : Pat<(v4i32 (movlhps VR128:$src1, VR128:$src2)),
1289               (MOVLHPSrr VR128:$src1, VR128:$src2)>;
1290   }
1291   def : Pat<(v4f32 (X86Movlhps VR128:$src1, VR128:$src2)),
1292             (MOVLHPSrr VR128:$src1, VR128:$src2)>;
1293   def : Pat<(v4i32 (X86Movlhps VR128:$src1, VR128:$src2)),
1294             (MOVLHPSrr VR128:$src1, VR128:$src2)>;
1295   def : Pat<(v2i64 (X86Movlhps VR128:$src1, VR128:$src2)),
1296             (MOVLHPSrr (v2i64 VR128:$src1), VR128:$src2)>;
1297
1298   // MOVHLPS patterns
1299   let AddedComplexity = 20 in {
1300     // vector_shuffle v1, v2 <6, 7, 2, 3> using MOVHLPS
1301     def : Pat<(v4i32 (movhlps VR128:$src1, VR128:$src2)),
1302               (MOVHLPSrr VR128:$src1, VR128:$src2)>;
1303
1304     // vector_shuffle v1, undef <2, ?, ?, ?> using MOVHLPS
1305     def : Pat<(v4f32 (movhlps_undef VR128:$src1, (undef))),
1306               (MOVHLPSrr VR128:$src1, VR128:$src1)>;
1307     def : Pat<(v4i32 (movhlps_undef VR128:$src1, (undef))),
1308               (MOVHLPSrr VR128:$src1, VR128:$src1)>;
1309   }
1310
1311   def : Pat<(v4f32 (X86Movhlps VR128:$src1, VR128:$src2)),
1312             (MOVHLPSrr VR128:$src1, VR128:$src2)>;
1313   def : Pat<(v4i32 (X86Movhlps VR128:$src1, VR128:$src2)),
1314             (MOVHLPSrr VR128:$src1, VR128:$src2)>;
1315 }
1316
1317 //===----------------------------------------------------------------------===//
1318 // SSE 1 & 2 - Conversion Instructions
1319 //===----------------------------------------------------------------------===//
1320
1321 multiclass sse12_cvt_s<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1322                      SDNode OpNode, X86MemOperand x86memop, PatFrag ld_frag,
1323                      string asm> {
1324   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins SrcRC:$src), asm,
1325                         [(set DstRC:$dst, (OpNode SrcRC:$src))]>;
1326   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst), (ins x86memop:$src), asm,
1327                         [(set DstRC:$dst, (OpNode (ld_frag addr:$src)))]>;
1328 }
1329
1330 multiclass sse12_cvt_s_np<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1331                           X86MemOperand x86memop, string asm> {
1332   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins SrcRC:$src), asm, []>;
1333   let mayLoad = 1 in
1334   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst), (ins x86memop:$src), asm, []>;
1335 }
1336
1337 multiclass sse12_cvt_p<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1338                          SDNode OpNode, X86MemOperand x86memop, PatFrag ld_frag,
1339                          string asm, Domain d> {
1340   def rr : PI<opc, MRMSrcReg, (outs DstRC:$dst), (ins SrcRC:$src), asm,
1341                         [(set DstRC:$dst, (OpNode SrcRC:$src))], d>;
1342   def rm : PI<opc, MRMSrcMem, (outs DstRC:$dst), (ins x86memop:$src), asm,
1343                         [(set DstRC:$dst, (OpNode (ld_frag addr:$src)))], d>;
1344 }
1345
1346 multiclass sse12_vcvt_avx<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1347                           X86MemOperand x86memop, string asm> {
1348   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins DstRC:$src1, SrcRC:$src),
1349               !strconcat(asm,"\t{$src, $src1, $dst|$dst, $src1, $src}"), []>;
1350   let mayLoad = 1 in
1351   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst),
1352               (ins DstRC:$src1, x86memop:$src),
1353               !strconcat(asm,"\t{$src, $src1, $dst|$dst, $src1, $src}"), []>;
1354 }
1355
1356 defm VCVTTSS2SI   : sse12_cvt_s<0x2C, FR32, GR32, fp_to_sint, f32mem, loadf32,
1357                                 "cvttss2si\t{$src, $dst|$dst, $src}">, XS, VEX;
1358 defm VCVTTSS2SI64 : sse12_cvt_s<0x2C, FR32, GR64, fp_to_sint, f32mem, loadf32,
1359                                 "cvttss2si\t{$src, $dst|$dst, $src}">, XS, VEX,
1360                                 VEX_W;
1361 defm VCVTTSD2SI   : sse12_cvt_s<0x2C, FR64, GR32, fp_to_sint, f64mem, loadf64,
1362                                 "cvttsd2si\t{$src, $dst|$dst, $src}">, XD, VEX;
1363 defm VCVTTSD2SI64 : sse12_cvt_s<0x2C, FR64, GR64, fp_to_sint, f64mem, loadf64,
1364                                 "cvttsd2si\t{$src, $dst|$dst, $src}">, XD,
1365                                 VEX, VEX_W;
1366
1367 // The assembler can recognize rr 64-bit instructions by seeing a rxx
1368 // register, but the same isn't true when only using memory operands,
1369 // provide other assembly "l" and "q" forms to address this explicitly
1370 // where appropriate to do so.
1371 defm VCVTSI2SS   : sse12_vcvt_avx<0x2A, GR32, FR32, i32mem, "cvtsi2ss">, XS,
1372                                   VEX_4V;
1373 defm VCVTSI2SS64 : sse12_vcvt_avx<0x2A, GR64, FR32, i64mem, "cvtsi2ss{q}">, XS,
1374                                   VEX_4V, VEX_W;
1375 defm VCVTSI2SD   : sse12_vcvt_avx<0x2A, GR32, FR64, i32mem, "cvtsi2sd">, XD,
1376                                   VEX_4V;
1377 defm VCVTSI2SDL  : sse12_vcvt_avx<0x2A, GR32, FR64, i32mem, "cvtsi2sd{l}">, XD,
1378                                   VEX_4V;
1379 defm VCVTSI2SD64 : sse12_vcvt_avx<0x2A, GR64, FR64, i64mem, "cvtsi2sd{q}">, XD,
1380                                   VEX_4V, VEX_W;
1381
1382 let Predicates = [HasAVX] in {
1383   def : Pat<(f32 (sint_to_fp (loadi32 addr:$src))),
1384             (VCVTSI2SSrm (f32 (IMPLICIT_DEF)), addr:$src)>;
1385   def : Pat<(f32 (sint_to_fp (loadi64 addr:$src))),
1386             (VCVTSI2SS64rm (f32 (IMPLICIT_DEF)), addr:$src)>;
1387   def : Pat<(f64 (sint_to_fp (loadi32 addr:$src))),
1388             (VCVTSI2SDrm (f64 (IMPLICIT_DEF)), addr:$src)>;
1389   def : Pat<(f64 (sint_to_fp (loadi64 addr:$src))),
1390             (VCVTSI2SD64rm (f64 (IMPLICIT_DEF)), addr:$src)>;
1391
1392   def : Pat<(f32 (sint_to_fp GR32:$src)),
1393             (VCVTSI2SSrr (f32 (IMPLICIT_DEF)), GR32:$src)>;
1394   def : Pat<(f32 (sint_to_fp GR64:$src)),
1395             (VCVTSI2SS64rr (f32 (IMPLICIT_DEF)), GR64:$src)>;
1396   def : Pat<(f64 (sint_to_fp GR32:$src)),
1397             (VCVTSI2SDrr (f64 (IMPLICIT_DEF)), GR32:$src)>;
1398   def : Pat<(f64 (sint_to_fp GR64:$src)),
1399             (VCVTSI2SD64rr (f64 (IMPLICIT_DEF)), GR64:$src)>;
1400 }
1401
1402 defm CVTTSS2SI : sse12_cvt_s<0x2C, FR32, GR32, fp_to_sint, f32mem, loadf32,
1403                       "cvttss2si\t{$src, $dst|$dst, $src}">, XS;
1404 defm CVTTSS2SI64 : sse12_cvt_s<0x2C, FR32, GR64, fp_to_sint, f32mem, loadf32,
1405                       "cvttss2si{q}\t{$src, $dst|$dst, $src}">, XS, REX_W;
1406 defm CVTTSD2SI : sse12_cvt_s<0x2C, FR64, GR32, fp_to_sint, f64mem, loadf64,
1407                       "cvttsd2si\t{$src, $dst|$dst, $src}">, XD;
1408 defm CVTTSD2SI64 : sse12_cvt_s<0x2C, FR64, GR64, fp_to_sint, f64mem, loadf64,
1409                       "cvttsd2si{q}\t{$src, $dst|$dst, $src}">, XD, REX_W;
1410 defm CVTSI2SS  : sse12_cvt_s<0x2A, GR32, FR32, sint_to_fp, i32mem, loadi32,
1411                       "cvtsi2ss\t{$src, $dst|$dst, $src}">, XS;
1412 defm CVTSI2SS64 : sse12_cvt_s<0x2A, GR64, FR32, sint_to_fp, i64mem, loadi64,
1413                       "cvtsi2ss{q}\t{$src, $dst|$dst, $src}">, XS, REX_W;
1414 defm CVTSI2SD  : sse12_cvt_s<0x2A, GR32, FR64, sint_to_fp, i32mem, loadi32,
1415                       "cvtsi2sd\t{$src, $dst|$dst, $src}">, XD;
1416 defm CVTSI2SD64 : sse12_cvt_s<0x2A, GR64, FR64, sint_to_fp, i64mem, loadi64,
1417                       "cvtsi2sd{q}\t{$src, $dst|$dst, $src}">, XD, REX_W;
1418
1419 // Conversion Instructions Intrinsics - Match intrinsics which expect MM
1420 // and/or XMM operand(s).
1421
1422 multiclass sse12_cvt_sint<bits<8> opc, RegisterClass SrcRC, RegisterClass DstRC,
1423                          Intrinsic Int, X86MemOperand x86memop, PatFrag ld_frag,
1424                          string asm> {
1425   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins SrcRC:$src),
1426               !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
1427               [(set DstRC:$dst, (Int SrcRC:$src))]>;
1428   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst), (ins x86memop:$src),
1429               !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
1430               [(set DstRC:$dst, (Int (ld_frag addr:$src)))]>;
1431 }
1432
1433 multiclass sse12_cvt_sint_3addr<bits<8> opc, RegisterClass SrcRC,
1434                     RegisterClass DstRC, Intrinsic Int, X86MemOperand x86memop,
1435                     PatFrag ld_frag, string asm, bit Is2Addr = 1> {
1436   def rr : SI<opc, MRMSrcReg, (outs DstRC:$dst), (ins DstRC:$src1, SrcRC:$src2),
1437               !if(Is2Addr,
1438                   !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
1439                   !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1440               [(set DstRC:$dst, (Int DstRC:$src1, SrcRC:$src2))]>;
1441   def rm : SI<opc, MRMSrcMem, (outs DstRC:$dst),
1442               (ins DstRC:$src1, x86memop:$src2),
1443               !if(Is2Addr,
1444                   !strconcat(asm, "\t{$src2, $dst|$dst, $src2}"),
1445                   !strconcat(asm, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1446               [(set DstRC:$dst, (Int DstRC:$src1, (ld_frag addr:$src2)))]>;
1447 }
1448
1449 defm Int_VCVTSD2SI : sse12_cvt_sint<0x2D, VR128, GR32, int_x86_sse2_cvtsd2si,
1450                       f128mem, load, "cvtsd2si">, XD, VEX;
1451 defm Int_VCVTSD2SI64 : sse12_cvt_sint<0x2D, VR128, GR64,
1452                       int_x86_sse2_cvtsd2si64, f128mem, load, "cvtsd2si">,
1453                       XD, VEX, VEX_W;
1454
1455 // FIXME: The asm matcher has a hack to ignore instructions with _Int and Int_
1456 // Get rid of this hack or rename the intrinsics, there are several
1457 // intructions that only match with the intrinsic form, why create duplicates
1458 // to let them be recognized by the assembler?
1459 defm VCVTSD2SI     : sse12_cvt_s_np<0x2D, FR64, GR32, f64mem,
1460                       "cvtsd2si\t{$src, $dst|$dst, $src}">, XD, VEX;
1461 defm VCVTSD2SI64   : sse12_cvt_s_np<0x2D, FR64, GR64, f64mem,
1462                       "cvtsd2si\t{$src, $dst|$dst, $src}">, XD, VEX, VEX_W;
1463
1464 defm CVTSD2SI : sse12_cvt_sint<0x2D, VR128, GR32, int_x86_sse2_cvtsd2si,
1465                 f128mem, load, "cvtsd2si{l}">, XD;
1466 defm CVTSD2SI64 : sse12_cvt_sint<0x2D, VR128, GR64, int_x86_sse2_cvtsd2si64,
1467                   f128mem, load, "cvtsd2si{q}">, XD, REX_W;
1468
1469
1470 defm Int_VCVTSI2SS : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1471           int_x86_sse_cvtsi2ss, i32mem, loadi32, "cvtsi2ss", 0>, XS, VEX_4V;
1472 defm Int_VCVTSI2SS64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1473           int_x86_sse_cvtsi642ss, i64mem, loadi64, "cvtsi2ss", 0>, XS, VEX_4V,
1474           VEX_W;
1475 defm Int_VCVTSI2SD : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1476           int_x86_sse2_cvtsi2sd, i32mem, loadi32, "cvtsi2sd", 0>, XD, VEX_4V;
1477 defm Int_VCVTSI2SD64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1478           int_x86_sse2_cvtsi642sd, i64mem, loadi64, "cvtsi2sd", 0>, XD,
1479           VEX_4V, VEX_W;
1480
1481 let Constraints = "$src1 = $dst" in {
1482   defm Int_CVTSI2SS : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1483                         int_x86_sse_cvtsi2ss, i32mem, loadi32,
1484                         "cvtsi2ss">, XS;
1485   defm Int_CVTSI2SS64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1486                         int_x86_sse_cvtsi642ss, i64mem, loadi64,
1487                         "cvtsi2ss{q}">, XS, REX_W;
1488   defm Int_CVTSI2SD : sse12_cvt_sint_3addr<0x2A, GR32, VR128,
1489                         int_x86_sse2_cvtsi2sd, i32mem, loadi32,
1490                         "cvtsi2sd">, XD;
1491   defm Int_CVTSI2SD64 : sse12_cvt_sint_3addr<0x2A, GR64, VR128,
1492                         int_x86_sse2_cvtsi642sd, i64mem, loadi64,
1493                         "cvtsi2sd">, XD, REX_W;
1494 }
1495
1496 /// SSE 1 Only
1497
1498 // Aliases for intrinsics
1499 defm Int_VCVTTSS2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse_cvttss2si,
1500                                     f32mem, load, "cvttss2si">, XS, VEX;
1501 defm Int_VCVTTSS2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1502                                     int_x86_sse_cvttss2si64, f32mem, load,
1503                                     "cvttss2si">, XS, VEX, VEX_W;
1504 defm Int_VCVTTSD2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse2_cvttsd2si,
1505                                     f128mem, load, "cvttsd2si">, XD, VEX;
1506 defm Int_VCVTTSD2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1507                                     int_x86_sse2_cvttsd2si64, f128mem, load,
1508                                     "cvttsd2si">, XD, VEX, VEX_W;
1509 defm Int_CVTTSS2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse_cvttss2si,
1510                                     f32mem, load, "cvttss2si">, XS;
1511 defm Int_CVTTSS2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1512                                     int_x86_sse_cvttss2si64, f32mem, load,
1513                                     "cvttss2si{q}">, XS, REX_W;
1514 defm Int_CVTTSD2SI : sse12_cvt_sint<0x2C, VR128, GR32, int_x86_sse2_cvttsd2si,
1515                                     f128mem, load, "cvttsd2si">, XD;
1516 defm Int_CVTTSD2SI64 : sse12_cvt_sint<0x2C, VR128, GR64,
1517                                     int_x86_sse2_cvttsd2si64, f128mem, load,
1518                                     "cvttsd2si{q}">, XD, REX_W;
1519
1520 let Pattern = []<dag> in {
1521 defm VCVTSS2SI   : sse12_cvt_s<0x2D, FR32, GR32, undef, f32mem, load,
1522                                "cvtss2si{l}\t{$src, $dst|$dst, $src}">, XS, VEX;
1523 defm VCVTSS2SI64 : sse12_cvt_s<0x2D, FR32, GR64, undef, f32mem, load,
1524                                "cvtss2si\t{$src, $dst|$dst, $src}">, XS, VEX,
1525                                VEX_W;
1526 defm VCVTDQ2PS   : sse12_cvt_p<0x5B, VR128, VR128, undef, i128mem, load,
1527                                "cvtdq2ps\t{$src, $dst|$dst, $src}",
1528                                SSEPackedSingle>, TB, VEX;
1529 defm VCVTDQ2PSY  : sse12_cvt_p<0x5B, VR256, VR256, undef, i256mem, load,
1530                                "cvtdq2ps\t{$src, $dst|$dst, $src}",
1531                                SSEPackedSingle>, TB, VEX;
1532 }
1533
1534 let Pattern = []<dag> in {
1535 defm CVTSS2SI : sse12_cvt_s<0x2D, FR32, GR32, undef, f32mem, load /*dummy*/,
1536                           "cvtss2si{l}\t{$src, $dst|$dst, $src}">, XS;
1537 defm CVTSS2SI64 : sse12_cvt_s<0x2D, FR32, GR64, undef, f32mem, load /*dummy*/,
1538                           "cvtss2si{q}\t{$src, $dst|$dst, $src}">, XS, REX_W;
1539 defm CVTDQ2PS : sse12_cvt_p<0x5B, VR128, VR128, undef, i128mem, load /*dummy*/,
1540                             "cvtdq2ps\t{$src, $dst|$dst, $src}",
1541                             SSEPackedSingle>, TB; /* PD SSE3 form is avaiable */
1542 }
1543
1544 let Predicates = [HasSSE1] in {
1545   def : Pat<(int_x86_sse_cvtss2si VR128:$src),
1546             (CVTSS2SIrr (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss))>;
1547   def : Pat<(int_x86_sse_cvtss2si (load addr:$src)),
1548             (CVTSS2SIrm addr:$src)>;
1549   def : Pat<(int_x86_sse_cvtss2si64 VR128:$src),
1550             (CVTSS2SI64rr (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss))>;
1551   def : Pat<(int_x86_sse_cvtss2si64 (load addr:$src)),
1552             (CVTSS2SI64rm addr:$src)>;
1553 }
1554
1555 let Predicates = [HasAVX] in {
1556   def : Pat<(int_x86_sse_cvtss2si VR128:$src),
1557             (VCVTSS2SIrr (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss))>;
1558   def : Pat<(int_x86_sse_cvtss2si (load addr:$src)),
1559             (VCVTSS2SIrm addr:$src)>;
1560   def : Pat<(int_x86_sse_cvtss2si64 VR128:$src),
1561             (VCVTSS2SI64rr (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss))>;
1562   def : Pat<(int_x86_sse_cvtss2si64 (load addr:$src)),
1563             (VCVTSS2SI64rm addr:$src)>;
1564 }
1565
1566 /// SSE 2 Only
1567
1568 // Convert scalar double to scalar single
1569 def VCVTSD2SSrr  : VSDI<0x5A, MRMSrcReg, (outs FR32:$dst),
1570                        (ins FR64:$src1, FR64:$src2),
1571                       "cvtsd2ss\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
1572                       VEX_4V;
1573 let mayLoad = 1 in
1574 def VCVTSD2SSrm  : I<0x5A, MRMSrcMem, (outs FR32:$dst),
1575                        (ins FR64:$src1, f64mem:$src2),
1576                       "vcvtsd2ss\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1577                       []>, XD, Requires<[HasAVX, OptForSize]>, VEX_4V;
1578
1579 def : Pat<(f32 (fround FR64:$src)), (VCVTSD2SSrr FR64:$src, FR64:$src)>,
1580           Requires<[HasAVX]>;
1581
1582 def CVTSD2SSrr  : SDI<0x5A, MRMSrcReg, (outs FR32:$dst), (ins FR64:$src),
1583                       "cvtsd2ss\t{$src, $dst|$dst, $src}",
1584                       [(set FR32:$dst, (fround FR64:$src))]>;
1585 def CVTSD2SSrm  : I<0x5A, MRMSrcMem, (outs FR32:$dst), (ins f64mem:$src),
1586                       "cvtsd2ss\t{$src, $dst|$dst, $src}",
1587                       [(set FR32:$dst, (fround (loadf64 addr:$src)))]>, XD,
1588                   Requires<[HasSSE2, OptForSize]>;
1589
1590 defm Int_VCVTSD2SS: sse12_cvt_sint_3addr<0x5A, VR128, VR128,
1591                       int_x86_sse2_cvtsd2ss, f64mem, load, "cvtsd2ss", 0>,
1592                       XS, VEX_4V;
1593 let Constraints = "$src1 = $dst" in
1594 defm Int_CVTSD2SS: sse12_cvt_sint_3addr<0x5A, VR128, VR128,
1595                       int_x86_sse2_cvtsd2ss, f64mem, load, "cvtsd2ss">, XS;
1596
1597 // Convert scalar single to scalar double
1598 // SSE2 instructions with XS prefix
1599 def VCVTSS2SDrr : I<0x5A, MRMSrcReg, (outs FR64:$dst),
1600                     (ins FR32:$src1, FR32:$src2),
1601                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1602                     []>, XS, Requires<[HasAVX]>, VEX_4V;
1603 let mayLoad = 1 in
1604 def VCVTSS2SDrm : I<0x5A, MRMSrcMem, (outs FR64:$dst),
1605                     (ins FR32:$src1, f32mem:$src2),
1606                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1607                     []>, XS, VEX_4V, Requires<[HasAVX, OptForSize]>;
1608
1609 let Predicates = [HasAVX] in {
1610   def : Pat<(f64 (fextend FR32:$src)),
1611             (VCVTSS2SDrr FR32:$src, FR32:$src)>;
1612   def : Pat<(fextend (loadf32 addr:$src)),
1613             (VCVTSS2SDrm (f32 (IMPLICIT_DEF)), addr:$src)>;
1614   def : Pat<(extloadf32 addr:$src),
1615             (VCVTSS2SDrm (f32 (IMPLICIT_DEF)), addr:$src)>;
1616 }
1617
1618 def : Pat<(extloadf32 addr:$src),
1619           (VCVTSS2SDrr (f32 (IMPLICIT_DEF)), (MOVSSrm addr:$src))>,
1620           Requires<[HasAVX, OptForSpeed]>;
1621
1622 def CVTSS2SDrr : I<0x5A, MRMSrcReg, (outs FR64:$dst), (ins FR32:$src),
1623                    "cvtss2sd\t{$src, $dst|$dst, $src}",
1624                    [(set FR64:$dst, (fextend FR32:$src))]>, XS,
1625                  Requires<[HasSSE2]>;
1626 def CVTSS2SDrm : I<0x5A, MRMSrcMem, (outs FR64:$dst), (ins f32mem:$src),
1627                    "cvtss2sd\t{$src, $dst|$dst, $src}",
1628                    [(set FR64:$dst, (extloadf32 addr:$src))]>, XS,
1629                  Requires<[HasSSE2, OptForSize]>;
1630
1631 // extload f32 -> f64.  This matches load+fextend because we have a hack in
1632 // the isel (PreprocessForFPConvert) that can introduce loads after dag
1633 // combine.
1634 // Since these loads aren't folded into the fextend, we have to match it
1635 // explicitly here.
1636 def : Pat<(fextend (loadf32 addr:$src)),
1637           (CVTSS2SDrm addr:$src)>, Requires<[HasSSE2]>;
1638 def : Pat<(extloadf32 addr:$src),
1639           (CVTSS2SDrr (MOVSSrm addr:$src))>, Requires<[HasSSE2, OptForSpeed]>;
1640
1641 def Int_VCVTSS2SDrr: I<0x5A, MRMSrcReg,
1642                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1643                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1644                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1645                                        VR128:$src2))]>, XS, VEX_4V,
1646                     Requires<[HasAVX]>;
1647 def Int_VCVTSS2SDrm: I<0x5A, MRMSrcMem,
1648                       (outs VR128:$dst), (ins VR128:$src1, f32mem:$src2),
1649                     "vcvtss2sd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1650                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1651                                        (load addr:$src2)))]>, XS, VEX_4V,
1652                     Requires<[HasAVX]>;
1653 let Constraints = "$src1 = $dst" in { // SSE2 instructions with XS prefix
1654 def Int_CVTSS2SDrr: I<0x5A, MRMSrcReg,
1655                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1656                     "cvtss2sd\t{$src2, $dst|$dst, $src2}",
1657                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1658                                        VR128:$src2))]>, XS,
1659                     Requires<[HasSSE2]>;
1660 def Int_CVTSS2SDrm: I<0x5A, MRMSrcMem,
1661                       (outs VR128:$dst), (ins VR128:$src1, f32mem:$src2),
1662                     "cvtss2sd\t{$src2, $dst|$dst, $src2}",
1663                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1664                                        (load addr:$src2)))]>, XS,
1665                     Requires<[HasSSE2]>;
1666 }
1667
1668 // Convert doubleword to packed single/double fp
1669 // SSE2 instructions without OpSize prefix
1670 def Int_VCVTDQ2PSrr : I<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1671                        "vcvtdq2ps\t{$src, $dst|$dst, $src}",
1672                        [(set VR128:$dst, (int_x86_sse2_cvtdq2ps VR128:$src))]>,
1673                      TB, VEX, Requires<[HasAVX]>;
1674 def Int_VCVTDQ2PSrm : I<0x5B, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
1675                       "vcvtdq2ps\t{$src, $dst|$dst, $src}",
1676                       [(set VR128:$dst, (int_x86_sse2_cvtdq2ps
1677                                         (bitconvert (memopv2i64 addr:$src))))]>,
1678                      TB, VEX, Requires<[HasAVX]>;
1679 def Int_CVTDQ2PSrr : I<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1680                        "cvtdq2ps\t{$src, $dst|$dst, $src}",
1681                        [(set VR128:$dst, (int_x86_sse2_cvtdq2ps VR128:$src))]>,
1682                      TB, Requires<[HasSSE2]>;
1683 def Int_CVTDQ2PSrm : I<0x5B, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
1684                       "cvtdq2ps\t{$src, $dst|$dst, $src}",
1685                       [(set VR128:$dst, (int_x86_sse2_cvtdq2ps
1686                                         (bitconvert (memopv2i64 addr:$src))))]>,
1687                      TB, Requires<[HasSSE2]>;
1688
1689 // FIXME: why the non-intrinsic version is described as SSE3?
1690 // SSE2 instructions with XS prefix
1691 def Int_VCVTDQ2PDrr : I<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1692                        "vcvtdq2pd\t{$src, $dst|$dst, $src}",
1693                        [(set VR128:$dst, (int_x86_sse2_cvtdq2pd VR128:$src))]>,
1694                      XS, VEX, Requires<[HasAVX]>;
1695 def Int_VCVTDQ2PDrm : I<0xE6, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
1696                        "vcvtdq2pd\t{$src, $dst|$dst, $src}",
1697                        [(set VR128:$dst, (int_x86_sse2_cvtdq2pd
1698                                         (bitconvert (memopv2i64 addr:$src))))]>,
1699                      XS, VEX, Requires<[HasAVX]>;
1700 def Int_CVTDQ2PDrr : I<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1701                        "cvtdq2pd\t{$src, $dst|$dst, $src}",
1702                        [(set VR128:$dst, (int_x86_sse2_cvtdq2pd VR128:$src))]>,
1703                      XS, Requires<[HasSSE2]>;
1704 def Int_CVTDQ2PDrm : I<0xE6, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
1705                      "cvtdq2pd\t{$src, $dst|$dst, $src}",
1706                      [(set VR128:$dst, (int_x86_sse2_cvtdq2pd
1707                                         (bitconvert (memopv2i64 addr:$src))))]>,
1708                      XS, Requires<[HasSSE2]>;
1709
1710
1711 // Convert packed single/double fp to doubleword
1712 def VCVTPS2DQrr : VPDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1713                        "cvtps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1714 def VCVTPS2DQrm : VPDI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1715                        "cvtps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1716 def VCVTPS2DQYrr : VPDI<0x5B, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
1717                         "cvtps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1718 def VCVTPS2DQYrm : VPDI<0x5B, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
1719                         "cvtps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1720 def CVTPS2DQrr : PDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1721                      "cvtps2dq\t{$src, $dst|$dst, $src}", []>;
1722 def CVTPS2DQrm : PDI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1723                      "cvtps2dq\t{$src, $dst|$dst, $src}", []>;
1724
1725 def Int_VCVTPS2DQrr : VPDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1726                         "cvtps2dq\t{$src, $dst|$dst, $src}",
1727                         [(set VR128:$dst, (int_x86_sse2_cvtps2dq VR128:$src))]>,
1728                         VEX;
1729 def Int_VCVTPS2DQrm : VPDI<0x5B, MRMSrcMem, (outs VR128:$dst),
1730                          (ins f128mem:$src),
1731                          "cvtps2dq\t{$src, $dst|$dst, $src}",
1732                          [(set VR128:$dst, (int_x86_sse2_cvtps2dq
1733                                             (memop addr:$src)))]>, VEX;
1734 def Int_CVTPS2DQrr : PDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1735                         "cvtps2dq\t{$src, $dst|$dst, $src}",
1736                         [(set VR128:$dst, (int_x86_sse2_cvtps2dq VR128:$src))]>;
1737 def Int_CVTPS2DQrm : PDI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1738                          "cvtps2dq\t{$src, $dst|$dst, $src}",
1739                          [(set VR128:$dst, (int_x86_sse2_cvtps2dq
1740                                             (memop addr:$src)))]>;
1741
1742 // SSE2 packed instructions with XD prefix
1743 def Int_VCVTPD2DQrr : I<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1744                        "vcvtpd2dq\t{$src, $dst|$dst, $src}",
1745                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq VR128:$src))]>,
1746                      XD, VEX, Requires<[HasAVX]>;
1747 def Int_VCVTPD2DQrm : I<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1748                        "vcvtpd2dq\t{$src, $dst|$dst, $src}",
1749                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq
1750                                           (memop addr:$src)))]>,
1751                      XD, VEX, Requires<[HasAVX]>;
1752 def Int_CVTPD2DQrr : I<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1753                        "cvtpd2dq\t{$src, $dst|$dst, $src}",
1754                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq VR128:$src))]>,
1755                      XD, Requires<[HasSSE2]>;
1756 def Int_CVTPD2DQrm : I<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1757                        "cvtpd2dq\t{$src, $dst|$dst, $src}",
1758                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq
1759                                           (memop addr:$src)))]>,
1760                      XD, Requires<[HasSSE2]>;
1761
1762
1763 // Convert with truncation packed single/double fp to doubleword
1764 // SSE2 packed instructions with XS prefix
1765 def VCVTTPS2DQrr : VSSI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1766                       "cvttps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1767 let mayLoad = 1 in
1768 def VCVTTPS2DQrm : VSSI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1769                       "cvttps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1770 def VCVTTPS2DQYrr : VSSI<0x5B, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
1771                       "cvttps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1772 let mayLoad = 1 in
1773 def VCVTTPS2DQYrm : VSSI<0x5B, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
1774                       "cvttps2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1775 def CVTTPS2DQrr : SSI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1776                       "cvttps2dq\t{$src, $dst|$dst, $src}",
1777                       [(set VR128:$dst,
1778                             (int_x86_sse2_cvttps2dq VR128:$src))]>;
1779 def CVTTPS2DQrm : SSI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1780                       "cvttps2dq\t{$src, $dst|$dst, $src}",
1781                       [(set VR128:$dst,
1782                             (int_x86_sse2_cvttps2dq (memop addr:$src)))]>;
1783
1784 def Int_VCVTTPS2DQrr : I<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1785                         "vcvttps2dq\t{$src, $dst|$dst, $src}",
1786                         [(set VR128:$dst,
1787                               (int_x86_sse2_cvttps2dq VR128:$src))]>,
1788                       XS, VEX, Requires<[HasAVX]>;
1789 def Int_VCVTTPS2DQrm : I<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1790                         "vcvttps2dq\t{$src, $dst|$dst, $src}",
1791                         [(set VR128:$dst, (int_x86_sse2_cvttps2dq
1792                                            (memop addr:$src)))]>,
1793                       XS, VEX, Requires<[HasAVX]>;
1794
1795 let Predicates = [HasSSE2] in {
1796   def : Pat<(v4f32 (sint_to_fp (v4i32 VR128:$src))),
1797             (Int_CVTDQ2PSrr VR128:$src)>;
1798   def : Pat<(v4i32 (fp_to_sint (v4f32 VR128:$src))),
1799             (CVTTPS2DQrr VR128:$src)>;
1800 }
1801
1802 let Predicates = [HasAVX] in {
1803   def : Pat<(v4f32 (sint_to_fp (v4i32 VR128:$src))),
1804             (Int_VCVTDQ2PSrr VR128:$src)>;
1805   def : Pat<(v4i32 (fp_to_sint (v4f32 VR128:$src))),
1806             (VCVTTPS2DQrr VR128:$src)>;
1807   def : Pat<(v8f32 (sint_to_fp (v8i32 VR256:$src))),
1808             (VCVTDQ2PSYrr VR256:$src)>;
1809   def : Pat<(v8i32 (fp_to_sint (v8f32 VR256:$src))),
1810             (VCVTTPS2DQYrr VR256:$src)>;
1811 }
1812
1813 def VCVTTPD2DQrr : VPDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1814                         "cvttpd2dq\t{$src, $dst|$dst, $src}",
1815                         [(set VR128:$dst,
1816                               (int_x86_sse2_cvttpd2dq VR128:$src))]>, VEX;
1817 let isCodeGenOnly = 1 in
1818 def VCVTTPD2DQrm : VPDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1819                         "cvttpd2dq\t{$src, $dst|$dst, $src}",
1820                         [(set VR128:$dst, (int_x86_sse2_cvttpd2dq
1821                                                (memop addr:$src)))]>, VEX;
1822 def CVTTPD2DQrr : PDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1823                       "cvttpd2dq\t{$src, $dst|$dst, $src}",
1824                       [(set VR128:$dst, (int_x86_sse2_cvttpd2dq VR128:$src))]>;
1825 def CVTTPD2DQrm : PDI<0xE6, MRMSrcMem, (outs VR128:$dst),(ins f128mem:$src),
1826                       "cvttpd2dq\t{$src, $dst|$dst, $src}",
1827                       [(set VR128:$dst, (int_x86_sse2_cvttpd2dq
1828                                         (memop addr:$src)))]>;
1829
1830 // The assembler can recognize rr 256-bit instructions by seeing a ymm
1831 // register, but the same isn't true when using memory operands instead.
1832 // Provide other assembly rr and rm forms to address this explicitly.
1833 def VCVTTPD2DQXrYr : VPDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
1834                           "cvttpd2dq\t{$src, $dst|$dst, $src}", []>, VEX;
1835
1836 // XMM only
1837 def VCVTTPD2DQXrr : VPDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1838                          "cvttpd2dqx\t{$src, $dst|$dst, $src}", []>, VEX;
1839 def VCVTTPD2DQXrm : VPDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1840                          "cvttpd2dqx\t{$src, $dst|$dst, $src}", []>, VEX;
1841
1842 // YMM only
1843 def VCVTTPD2DQYrr : VPDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
1844                          "cvttpd2dqy\t{$src, $dst|$dst, $src}", []>, VEX;
1845 def VCVTTPD2DQYrm : VPDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
1846                          "cvttpd2dqy\t{$src, $dst|$dst, $src}", []>, VEX, VEX_L;
1847
1848 // Convert packed single to packed double
1849 let Predicates = [HasAVX] in {
1850                   // SSE2 instructions without OpSize prefix
1851 def VCVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1852                      "vcvtps2pd\t{$src, $dst|$dst, $src}", []>, TB, VEX;
1853 def VCVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
1854                      "vcvtps2pd\t{$src, $dst|$dst, $src}", []>, TB, VEX;
1855 def VCVTPS2PDYrr : I<0x5A, MRMSrcReg, (outs VR256:$dst), (ins VR128:$src),
1856                      "vcvtps2pd\t{$src, $dst|$dst, $src}", []>, TB, VEX;
1857 def VCVTPS2PDYrm : I<0x5A, MRMSrcMem, (outs VR256:$dst), (ins f128mem:$src),
1858                      "vcvtps2pd\t{$src, $dst|$dst, $src}", []>, TB, VEX;
1859 }
1860 def CVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1861                        "cvtps2pd\t{$src, $dst|$dst, $src}", []>, TB;
1862 def CVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
1863                        "cvtps2pd\t{$src, $dst|$dst, $src}", []>, TB;
1864
1865 def Int_VCVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1866                        "vcvtps2pd\t{$src, $dst|$dst, $src}",
1867                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd VR128:$src))]>,
1868                      TB, VEX, Requires<[HasAVX]>;
1869 def Int_VCVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
1870                        "vcvtps2pd\t{$src, $dst|$dst, $src}",
1871                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd
1872                                           (load addr:$src)))]>,
1873                      TB, VEX, Requires<[HasAVX]>;
1874 def Int_CVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1875                        "cvtps2pd\t{$src, $dst|$dst, $src}",
1876                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd VR128:$src))]>,
1877                      TB, Requires<[HasSSE2]>;
1878 def Int_CVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
1879                        "cvtps2pd\t{$src, $dst|$dst, $src}",
1880                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd
1881                                           (load addr:$src)))]>,
1882                      TB, Requires<[HasSSE2]>;
1883
1884 // Convert packed double to packed single
1885 // The assembler can recognize rr 256-bit instructions by seeing a ymm
1886 // register, but the same isn't true when using memory operands instead.
1887 // Provide other assembly rr and rm forms to address this explicitly.
1888 def VCVTPD2PSrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1889                        "cvtpd2ps\t{$src, $dst|$dst, $src}", []>, VEX;
1890 def VCVTPD2PSXrYr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
1891                          "cvtpd2ps\t{$src, $dst|$dst, $src}", []>, VEX;
1892
1893 // XMM only
1894 def VCVTPD2PSXrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1895                         "cvtpd2psx\t{$src, $dst|$dst, $src}", []>, VEX;
1896 def VCVTPD2PSXrm : VPDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1897                         "cvtpd2psx\t{$src, $dst|$dst, $src}", []>, VEX;
1898
1899 // YMM only
1900 def VCVTPD2PSYrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
1901                         "cvtpd2psy\t{$src, $dst|$dst, $src}", []>, VEX;
1902 def VCVTPD2PSYrm : VPDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
1903                         "cvtpd2psy\t{$src, $dst|$dst, $src}", []>, VEX, VEX_L;
1904 def CVTPD2PSrr : PDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1905                      "cvtpd2ps\t{$src, $dst|$dst, $src}", []>;
1906 def CVTPD2PSrm : PDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1907                      "cvtpd2ps\t{$src, $dst|$dst, $src}", []>;
1908
1909
1910 def Int_VCVTPD2PSrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1911                          "cvtpd2ps\t{$src, $dst|$dst, $src}",
1912                         [(set VR128:$dst, (int_x86_sse2_cvtpd2ps VR128:$src))]>;
1913 def Int_VCVTPD2PSrm : VPDI<0x5A, MRMSrcMem, (outs VR128:$dst),
1914                          (ins f128mem:$src),
1915                          "cvtpd2ps\t{$src, $dst|$dst, $src}",
1916                          [(set VR128:$dst, (int_x86_sse2_cvtpd2ps
1917                                             (memop addr:$src)))]>;
1918 def Int_CVTPD2PSrr : PDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1919                          "cvtpd2ps\t{$src, $dst|$dst, $src}",
1920                         [(set VR128:$dst, (int_x86_sse2_cvtpd2ps VR128:$src))]>;
1921 def Int_CVTPD2PSrm : PDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1922                          "cvtpd2ps\t{$src, $dst|$dst, $src}",
1923                          [(set VR128:$dst, (int_x86_sse2_cvtpd2ps
1924                                             (memop addr:$src)))]>;
1925
1926 // AVX 256-bit register conversion intrinsics
1927 // FIXME: Migrate SSE conversion intrinsics matching to use patterns as below
1928 // whenever possible to avoid declaring two versions of each one.
1929 def : Pat<(int_x86_avx_cvtdq2_ps_256 VR256:$src),
1930           (VCVTDQ2PSYrr VR256:$src)>;
1931 def : Pat<(int_x86_avx_cvtdq2_ps_256 (memopv8i32 addr:$src)),
1932           (VCVTDQ2PSYrm addr:$src)>;
1933
1934 def : Pat<(int_x86_avx_cvt_pd2_ps_256 VR256:$src),
1935           (VCVTPD2PSYrr VR256:$src)>;
1936 def : Pat<(int_x86_avx_cvt_pd2_ps_256 (memopv4f64 addr:$src)),
1937           (VCVTPD2PSYrm addr:$src)>;
1938
1939 def : Pat<(int_x86_avx_cvt_ps2dq_256 VR256:$src),
1940           (VCVTPS2DQYrr VR256:$src)>;
1941 def : Pat<(int_x86_avx_cvt_ps2dq_256 (memopv8f32 addr:$src)),
1942           (VCVTPS2DQYrm addr:$src)>;
1943
1944 def : Pat<(int_x86_avx_cvt_ps2_pd_256 VR128:$src),
1945           (VCVTPS2PDYrr VR128:$src)>;
1946 def : Pat<(int_x86_avx_cvt_ps2_pd_256 (memopv4f32 addr:$src)),
1947           (VCVTPS2PDYrm addr:$src)>;
1948
1949 def : Pat<(int_x86_avx_cvtt_pd2dq_256 VR256:$src),
1950           (VCVTTPD2DQYrr VR256:$src)>;
1951 def : Pat<(int_x86_avx_cvtt_pd2dq_256 (memopv4f64 addr:$src)),
1952           (VCVTTPD2DQYrm addr:$src)>;
1953
1954 def : Pat<(int_x86_avx_cvtt_ps2dq_256 VR256:$src),
1955           (VCVTTPS2DQYrr VR256:$src)>;
1956 def : Pat<(int_x86_avx_cvtt_ps2dq_256 (memopv8f32 addr:$src)),
1957           (VCVTTPS2DQYrm addr:$src)>;
1958
1959 // Match fround and fextend for 128/256-bit conversions
1960 def : Pat<(v4f32 (fround (v4f64 VR256:$src))),
1961           (VCVTPD2PSYrr VR256:$src)>;
1962 def : Pat<(v4f32 (fround (loadv4f64 addr:$src))),
1963           (VCVTPD2PSYrm addr:$src)>;
1964
1965 def : Pat<(v4f64 (fextend (v4f32 VR128:$src))),
1966           (VCVTPS2PDYrr VR128:$src)>;
1967 def : Pat<(v4f64 (fextend (loadv4f32 addr:$src))),
1968           (VCVTPS2PDYrm addr:$src)>;
1969
1970 //===----------------------------------------------------------------------===//
1971 // SSE 1 & 2 - Compare Instructions
1972 //===----------------------------------------------------------------------===//
1973
1974 // sse12_cmp_scalar - sse 1 & 2 compare scalar instructions
1975 multiclass sse12_cmp_scalar<RegisterClass RC, X86MemOperand x86memop,
1976                             string asm, string asm_alt> {
1977   let isAsmParserOnly = 1 in {
1978     def rr : SIi8<0xC2, MRMSrcReg,
1979                   (outs RC:$dst), (ins RC:$src1, RC:$src, SSECC:$cc),
1980                   asm, []>;
1981     let mayLoad = 1 in
1982     def rm : SIi8<0xC2, MRMSrcMem,
1983                   (outs RC:$dst), (ins RC:$src1, x86memop:$src, SSECC:$cc),
1984                   asm, []>;
1985   }
1986
1987   // Accept explicit immediate argument form instead of comparison code.
1988   def rr_alt : SIi8<0xC2, MRMSrcReg,
1989                 (outs RC:$dst), (ins RC:$src1, RC:$src, i8imm:$src2),
1990                 asm_alt, []>;
1991   let mayLoad = 1 in
1992   def rm_alt : SIi8<0xC2, MRMSrcMem,
1993                 (outs RC:$dst), (ins RC:$src1, x86memop:$src, i8imm:$src2),
1994                 asm_alt, []>;
1995 }
1996
1997 let neverHasSideEffects = 1 in {
1998   defm VCMPSS  : sse12_cmp_scalar<FR32, f32mem,
1999                   "cmp${cc}ss\t{$src, $src1, $dst|$dst, $src1, $src}",
2000                   "cmpss\t{$src2, $src, $src1, $dst|$dst, $src1, $src, $src2}">,
2001                   XS, VEX_4V;
2002   defm VCMPSD  : sse12_cmp_scalar<FR64, f64mem,
2003                   "cmp${cc}sd\t{$src, $src1, $dst|$dst, $src1, $src}",
2004                   "cmpsd\t{$src2, $src, $src1, $dst|$dst, $src1, $src, $src2}">,
2005                   XD, VEX_4V;
2006 }
2007
2008 let Constraints = "$src1 = $dst" in {
2009 def CMPSSrr : SIi8<0xC2, MRMSrcReg,
2010               (outs FR32:$dst), (ins FR32:$src1, FR32:$src2, SSECC:$cc),
2011               "cmp${cc}ss\t{$src2, $dst|$dst, $src2}",
2012               [(set FR32:$dst, (X86cmpss (f32 FR32:$src1), FR32:$src2,
2013                                          imm:$cc))]>, XS;
2014 def CMPSSrm : SIi8<0xC2, MRMSrcMem,
2015               (outs FR32:$dst), (ins FR32:$src1, f32mem:$src2, SSECC:$cc),
2016               "cmp${cc}ss\t{$src2, $dst|$dst, $src2}",
2017               [(set FR32:$dst, (X86cmpss (f32 FR32:$src1),
2018                                          (loadf32 addr:$src2), imm:$cc))]>, XS;
2019 def CMPSDrr : SIi8<0xC2, MRMSrcReg,
2020               (outs FR64:$dst), (ins FR64:$src1, FR64:$src2, SSECC:$cc),
2021               "cmp${cc}sd\t{$src2, $dst|$dst, $src2}",
2022               [(set FR64:$dst, (X86cmpsd (f64 FR64:$src1), FR64:$src2,
2023                                          imm:$cc))]>, XD;
2024 def CMPSDrm : SIi8<0xC2, MRMSrcMem,
2025               (outs FR64:$dst), (ins FR64:$src1, f64mem:$src2, SSECC:$cc),
2026               "cmp${cc}sd\t{$src2, $dst|$dst, $src2}",
2027               [(set FR64:$dst, (X86cmpsd (f64 FR64:$src1), (loadf64 addr:$src2),
2028                                          imm:$cc))]>, XD;
2029 }
2030 let Constraints = "$src1 = $dst", neverHasSideEffects = 1 in {
2031 def CMPSSrr_alt : SIi8<0xC2, MRMSrcReg,
2032                   (outs FR32:$dst), (ins FR32:$src1, FR32:$src, i8imm:$src2),
2033                   "cmpss\t{$src2, $src, $dst|$dst, $src, $src2}", []>, XS;
2034 def CMPSSrm_alt : SIi8<0xC2, MRMSrcMem,
2035                   (outs FR32:$dst), (ins FR32:$src1, f32mem:$src, i8imm:$src2),
2036                   "cmpss\t{$src2, $src, $dst|$dst, $src, $src2}", []>, XS;
2037 def CMPSDrr_alt : SIi8<0xC2, MRMSrcReg,
2038                   (outs FR64:$dst), (ins FR64:$src1, FR64:$src, i8imm:$src2),
2039                   "cmpsd\t{$src2, $src, $dst|$dst, $src, $src2}", []>, XD;
2040 def CMPSDrm_alt : SIi8<0xC2, MRMSrcMem,
2041                   (outs FR64:$dst), (ins FR64:$src1, f64mem:$src, i8imm:$src2),
2042                   "cmpsd\t{$src2, $src, $dst|$dst, $src, $src2}", []>, XD;
2043 }
2044
2045 multiclass sse12_cmp_scalar_int<RegisterClass RC, X86MemOperand x86memop,
2046                          Intrinsic Int, string asm> {
2047   def rr : SIi8<0xC2, MRMSrcReg, (outs VR128:$dst),
2048                       (ins VR128:$src1, VR128:$src, SSECC:$cc), asm,
2049                         [(set VR128:$dst, (Int VR128:$src1,
2050                                                VR128:$src, imm:$cc))]>;
2051   def rm : SIi8<0xC2, MRMSrcMem, (outs VR128:$dst),
2052                       (ins VR128:$src1, f32mem:$src, SSECC:$cc), asm,
2053                         [(set VR128:$dst, (Int VR128:$src1,
2054                                                (load addr:$src), imm:$cc))]>;
2055 }
2056
2057 // Aliases to match intrinsics which expect XMM operand(s).
2058 defm Int_VCMPSS  : sse12_cmp_scalar_int<VR128, f32mem, int_x86_sse_cmp_ss,
2059                      "cmp${cc}ss\t{$src, $src1, $dst|$dst, $src1, $src}">,
2060                      XS, VEX_4V;
2061 defm Int_VCMPSD  : sse12_cmp_scalar_int<VR128, f64mem, int_x86_sse2_cmp_sd,
2062                      "cmp${cc}sd\t{$src, $src1, $dst|$dst, $src1, $src}">,
2063                      XD, VEX_4V;
2064 let Constraints = "$src1 = $dst" in {
2065   defm Int_CMPSS  : sse12_cmp_scalar_int<VR128, f32mem, int_x86_sse_cmp_ss,
2066                        "cmp${cc}ss\t{$src, $dst|$dst, $src}">, XS;
2067   defm Int_CMPSD  : sse12_cmp_scalar_int<VR128, f64mem, int_x86_sse2_cmp_sd,
2068                        "cmp${cc}sd\t{$src, $dst|$dst, $src}">, XD;
2069 }
2070
2071
2072 // sse12_ord_cmp - Unordered/Ordered scalar fp compare and set EFLAGS
2073 multiclass sse12_ord_cmp<bits<8> opc, RegisterClass RC, SDNode OpNode,
2074                             ValueType vt, X86MemOperand x86memop,
2075                             PatFrag ld_frag, string OpcodeStr, Domain d> {
2076   def rr: PI<opc, MRMSrcReg, (outs), (ins RC:$src1, RC:$src2),
2077                      !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
2078                      [(set EFLAGS, (OpNode (vt RC:$src1), RC:$src2))], d>;
2079   def rm: PI<opc, MRMSrcMem, (outs), (ins RC:$src1, x86memop:$src2),
2080                      !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
2081                      [(set EFLAGS, (OpNode (vt RC:$src1),
2082                                            (ld_frag addr:$src2)))], d>;
2083 }
2084
2085 let Defs = [EFLAGS] in {
2086   defm VUCOMISS : sse12_ord_cmp<0x2E, FR32, X86cmp, f32, f32mem, loadf32,
2087                                   "ucomiss", SSEPackedSingle>, TB, VEX;
2088   defm VUCOMISD : sse12_ord_cmp<0x2E, FR64, X86cmp, f64, f64mem, loadf64,
2089                                   "ucomisd", SSEPackedDouble>, TB, OpSize, VEX;
2090   let Pattern = []<dag> in {
2091     defm VCOMISS  : sse12_ord_cmp<0x2F, VR128, undef, v4f32, f128mem, load,
2092                                     "comiss", SSEPackedSingle>, TB, VEX;
2093     defm VCOMISD  : sse12_ord_cmp<0x2F, VR128, undef, v2f64, f128mem, load,
2094                                     "comisd", SSEPackedDouble>, TB, OpSize, VEX;
2095   }
2096
2097   defm Int_VUCOMISS  : sse12_ord_cmp<0x2E, VR128, X86ucomi, v4f32, f128mem,
2098                             load, "ucomiss", SSEPackedSingle>, TB, VEX;
2099   defm Int_VUCOMISD  : sse12_ord_cmp<0x2E, VR128, X86ucomi, v2f64, f128mem,
2100                             load, "ucomisd", SSEPackedDouble>, TB, OpSize, VEX;
2101
2102   defm Int_VCOMISS  : sse12_ord_cmp<0x2F, VR128, X86comi, v4f32, f128mem,
2103                             load, "comiss", SSEPackedSingle>, TB, VEX;
2104   defm Int_VCOMISD  : sse12_ord_cmp<0x2F, VR128, X86comi, v2f64, f128mem,
2105                             load, "comisd", SSEPackedDouble>, TB, OpSize, VEX;
2106   defm UCOMISS  : sse12_ord_cmp<0x2E, FR32, X86cmp, f32, f32mem, loadf32,
2107                                   "ucomiss", SSEPackedSingle>, TB;
2108   defm UCOMISD  : sse12_ord_cmp<0x2E, FR64, X86cmp, f64, f64mem, loadf64,
2109                                   "ucomisd", SSEPackedDouble>, TB, OpSize;
2110
2111   let Pattern = []<dag> in {
2112     defm COMISS  : sse12_ord_cmp<0x2F, VR128, undef, v4f32, f128mem, load,
2113                                     "comiss", SSEPackedSingle>, TB;
2114     defm COMISD  : sse12_ord_cmp<0x2F, VR128, undef, v2f64, f128mem, load,
2115                                     "comisd", SSEPackedDouble>, TB, OpSize;
2116   }
2117
2118   defm Int_UCOMISS  : sse12_ord_cmp<0x2E, VR128, X86ucomi, v4f32, f128mem,
2119                               load, "ucomiss", SSEPackedSingle>, TB;
2120   defm Int_UCOMISD  : sse12_ord_cmp<0x2E, VR128, X86ucomi, v2f64, f128mem,
2121                               load, "ucomisd", SSEPackedDouble>, TB, OpSize;
2122
2123   defm Int_COMISS  : sse12_ord_cmp<0x2F, VR128, X86comi, v4f32, f128mem, load,
2124                                   "comiss", SSEPackedSingle>, TB;
2125   defm Int_COMISD  : sse12_ord_cmp<0x2F, VR128, X86comi, v2f64, f128mem, load,
2126                                   "comisd", SSEPackedDouble>, TB, OpSize;
2127 } // Defs = [EFLAGS]
2128
2129 // sse12_cmp_packed - sse 1 & 2 compared packed instructions
2130 multiclass sse12_cmp_packed<RegisterClass RC, X86MemOperand x86memop,
2131                             Intrinsic Int, string asm, string asm_alt,
2132                             Domain d> {
2133   let isAsmParserOnly = 1 in {
2134     def rri : PIi8<0xC2, MRMSrcReg,
2135                (outs RC:$dst), (ins RC:$src1, RC:$src2, SSECC:$cc), asm,
2136                [(set RC:$dst, (Int RC:$src1, RC:$src2, imm:$cc))], d>;
2137     def rmi : PIi8<0xC2, MRMSrcMem,
2138                (outs RC:$dst), (ins RC:$src1, f128mem:$src2, SSECC:$cc), asm,
2139                [(set RC:$dst, (Int RC:$src1, (memop addr:$src2), imm:$cc))], d>;
2140   }
2141
2142   // Accept explicit immediate argument form instead of comparison code.
2143   def rri_alt : PIi8<0xC2, MRMSrcReg,
2144              (outs RC:$dst), (ins RC:$src1, RC:$src2, i8imm:$cc),
2145              asm_alt, [], d>;
2146   def rmi_alt : PIi8<0xC2, MRMSrcMem,
2147              (outs RC:$dst), (ins RC:$src1, f128mem:$src2, i8imm:$cc),
2148              asm_alt, [], d>;
2149 }
2150
2151 defm VCMPPS : sse12_cmp_packed<VR128, f128mem, int_x86_sse_cmp_ps,
2152                "cmp${cc}ps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2153                "cmpps\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2154                SSEPackedSingle>, TB, VEX_4V;
2155 defm VCMPPD : sse12_cmp_packed<VR128, f128mem, int_x86_sse2_cmp_pd,
2156                "cmp${cc}pd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2157                "cmppd\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2158                SSEPackedDouble>, TB, OpSize, VEX_4V;
2159 defm VCMPPSY : sse12_cmp_packed<VR256, f256mem, int_x86_avx_cmp_ps_256,
2160                "cmp${cc}ps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2161                "cmpps\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2162                SSEPackedSingle>, TB, VEX_4V;
2163 defm VCMPPDY : sse12_cmp_packed<VR256, f256mem, int_x86_avx_cmp_pd_256,
2164                "cmp${cc}pd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2165                "cmppd\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}",
2166                SSEPackedDouble>, TB, OpSize, VEX_4V;
2167 let Constraints = "$src1 = $dst" in {
2168   defm CMPPS : sse12_cmp_packed<VR128, f128mem, int_x86_sse_cmp_ps,
2169                  "cmp${cc}ps\t{$src2, $dst|$dst, $src2}",
2170                  "cmpps\t{$cc, $src2, $dst|$dst, $src2, $cc}",
2171                  SSEPackedSingle>, TB;
2172   defm CMPPD : sse12_cmp_packed<VR128, f128mem, int_x86_sse2_cmp_pd,
2173                  "cmp${cc}pd\t{$src2, $dst|$dst, $src2}",
2174                  "cmppd\t{$cc, $src2, $dst|$dst, $src2, $cc}",
2175                  SSEPackedDouble>, TB, OpSize;
2176 }
2177
2178 let Predicates = [HasSSE1] in {
2179 def : Pat<(v4i32 (X86cmpps (v4f32 VR128:$src1), VR128:$src2, imm:$cc)),
2180           (CMPPSrri (v4f32 VR128:$src1), (v4f32 VR128:$src2), imm:$cc)>;
2181 def : Pat<(v4i32 (X86cmpps (v4f32 VR128:$src1), (memop addr:$src2), imm:$cc)),
2182           (CMPPSrmi (v4f32 VR128:$src1), addr:$src2, imm:$cc)>;
2183 }
2184
2185 let Predicates = [HasSSE2] in {
2186 def : Pat<(v2i64 (X86cmppd (v2f64 VR128:$src1), VR128:$src2, imm:$cc)),
2187           (CMPPDrri VR128:$src1, VR128:$src2, imm:$cc)>;
2188 def : Pat<(v2i64 (X86cmppd (v2f64 VR128:$src1), (memop addr:$src2), imm:$cc)),
2189           (CMPPDrmi VR128:$src1, addr:$src2, imm:$cc)>;
2190 }
2191
2192 let Predicates = [HasAVX] in {
2193 def : Pat<(v4i32 (X86cmpps (v4f32 VR128:$src1), VR128:$src2, imm:$cc)),
2194           (VCMPPSrri (v4f32 VR128:$src1), (v4f32 VR128:$src2), imm:$cc)>;
2195 def : Pat<(v4i32 (X86cmpps (v4f32 VR128:$src1), (memop addr:$src2), imm:$cc)),
2196           (VCMPPSrmi (v4f32 VR128:$src1), addr:$src2, imm:$cc)>;
2197 def : Pat<(v2i64 (X86cmppd (v2f64 VR128:$src1), VR128:$src2, imm:$cc)),
2198           (VCMPPDrri VR128:$src1, VR128:$src2, imm:$cc)>;
2199 def : Pat<(v2i64 (X86cmppd (v2f64 VR128:$src1), (memop addr:$src2), imm:$cc)),
2200           (VCMPPDrmi VR128:$src1, addr:$src2, imm:$cc)>;
2201
2202 def : Pat<(v8i32 (X86cmpps (v8f32 VR256:$src1), VR256:$src2, imm:$cc)),
2203           (VCMPPSYrri (v8f32 VR256:$src1), (v8f32 VR256:$src2), imm:$cc)>;
2204 def : Pat<(v8i32 (X86cmpps (v8f32 VR256:$src1), (memop addr:$src2), imm:$cc)),
2205           (VCMPPSYrmi (v8f32 VR256:$src1), addr:$src2, imm:$cc)>;
2206 def : Pat<(v4i64 (X86cmppd (v4f64 VR256:$src1), VR256:$src2, imm:$cc)),
2207           (VCMPPDYrri VR256:$src1, VR256:$src2, imm:$cc)>;
2208 def : Pat<(v4i64 (X86cmppd (v4f64 VR256:$src1), (memop addr:$src2), imm:$cc)),
2209           (VCMPPDYrmi VR256:$src1, addr:$src2, imm:$cc)>;
2210 }
2211
2212 //===----------------------------------------------------------------------===//
2213 // SSE 1 & 2 - Shuffle Instructions
2214 //===----------------------------------------------------------------------===//
2215
2216 /// sse12_shuffle - sse 1 & 2 shuffle instructions
2217 multiclass sse12_shuffle<RegisterClass RC, X86MemOperand x86memop,
2218                          ValueType vt, string asm, PatFrag mem_frag,
2219                          Domain d, bit IsConvertibleToThreeAddress = 0> {
2220   def rmi : PIi8<0xC6, MRMSrcMem, (outs RC:$dst),
2221                    (ins RC:$src1, f128mem:$src2, i8imm:$src3), asm,
2222                    [(set RC:$dst, (vt (shufp:$src3
2223                             RC:$src1, (mem_frag addr:$src2))))], d>;
2224   let isConvertibleToThreeAddress = IsConvertibleToThreeAddress in
2225     def rri : PIi8<0xC6, MRMSrcReg, (outs RC:$dst),
2226                    (ins RC:$src1, RC:$src2, i8imm:$src3), asm,
2227                    [(set RC:$dst,
2228                             (vt (shufp:$src3 RC:$src1, RC:$src2)))], d>;
2229 }
2230
2231 defm VSHUFPS  : sse12_shuffle<VR128, f128mem, v4f32,
2232            "shufps\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
2233            memopv4f32, SSEPackedSingle>, TB, VEX_4V;
2234 defm VSHUFPSY : sse12_shuffle<VR256, f256mem, v8f32,
2235            "shufps\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
2236            memopv8f32, SSEPackedSingle>, TB, VEX_4V;
2237 defm VSHUFPD  : sse12_shuffle<VR128, f128mem, v2f64,
2238            "shufpd\t{$src3, $src2, $src1, $dst|$dst, $src2, $src2, $src3}",
2239            memopv2f64, SSEPackedDouble>, TB, OpSize, VEX_4V;
2240 defm VSHUFPDY : sse12_shuffle<VR256, f256mem, v4f64,
2241            "shufpd\t{$src3, $src2, $src1, $dst|$dst, $src2, $src2, $src3}",
2242            memopv4f64, SSEPackedDouble>, TB, OpSize, VEX_4V;
2243
2244 let Constraints = "$src1 = $dst" in {
2245   defm SHUFPS : sse12_shuffle<VR128, f128mem, v4f32,
2246                     "shufps\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2247                     memopv4f32, SSEPackedSingle, 1 /* cvt to pshufd */>,
2248                     TB;
2249   defm SHUFPD : sse12_shuffle<VR128, f128mem, v2f64,
2250                     "shufpd\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2251                     memopv2f64, SSEPackedDouble>, TB, OpSize;
2252 }
2253
2254 let Predicates = [HasSSE1] in {
2255   def : Pat<(v4f32 (X86Shufps VR128:$src1,
2256                        (memopv4f32 addr:$src2), (i8 imm:$imm))),
2257             (SHUFPSrmi VR128:$src1, addr:$src2, imm:$imm)>;
2258   def : Pat<(v4f32 (X86Shufps VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2259             (SHUFPSrri VR128:$src1, VR128:$src2, imm:$imm)>;
2260   def : Pat<(v4i32 (X86Shufps VR128:$src1,
2261                        (bc_v4i32 (memopv2i64 addr:$src2)), (i8 imm:$imm))),
2262             (SHUFPSrmi VR128:$src1, addr:$src2, imm:$imm)>;
2263   def : Pat<(v4i32 (X86Shufps VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2264             (SHUFPSrri VR128:$src1, VR128:$src2, imm:$imm)>;
2265   // vector_shuffle v1, v2 <4, 5, 2, 3> using SHUFPSrri (we prefer movsd, but
2266   // fall back to this for SSE1)
2267   def : Pat<(v4f32 (movlp:$src3 VR128:$src1, (v4f32 VR128:$src2))),
2268             (SHUFPSrri VR128:$src2, VR128:$src1,
2269                        (SHUFFLE_get_shuf_imm VR128:$src3))>;
2270   // Special unary SHUFPSrri case.
2271   def : Pat<(v4f32 (pshufd:$src3 VR128:$src1, (undef))),
2272             (SHUFPSrri VR128:$src1, VR128:$src1,
2273                        (SHUFFLE_get_shuf_imm VR128:$src3))>;
2274 }
2275
2276 let Predicates = [HasSSE2] in {
2277   // Special binary v4i32 shuffle cases with SHUFPS.
2278   def : Pat<(v4i32 (shufp:$src3 VR128:$src1, (v4i32 VR128:$src2))),
2279             (SHUFPSrri VR128:$src1, VR128:$src2,
2280                        (SHUFFLE_get_shuf_imm VR128:$src3))>;
2281   def : Pat<(v4i32 (shufp:$src3 VR128:$src1,
2282                                 (bc_v4i32 (memopv2i64 addr:$src2)))),
2283             (SHUFPSrmi VR128:$src1, addr:$src2,
2284                       (SHUFFLE_get_shuf_imm VR128:$src3))>;
2285   // Special unary SHUFPDrri cases.
2286   def : Pat<(v2i64 (pshufd:$src3 VR128:$src1, (undef))),
2287             (SHUFPDrri VR128:$src1, VR128:$src1,
2288                        (SHUFFLE_get_shuf_imm VR128:$src3))>;
2289   def : Pat<(v2f64 (pshufd:$src3 VR128:$src1, (undef))),
2290             (SHUFPDrri VR128:$src1, VR128:$src1,
2291                        (SHUFFLE_get_shuf_imm VR128:$src3))>;
2292   // Special binary v2i64 shuffle cases using SHUFPDrri.
2293   def : Pat<(v2i64 (shufp:$src3 VR128:$src1, VR128:$src2)),
2294             (SHUFPDrri VR128:$src1, VR128:$src2,
2295                        (SHUFFLE_get_shuf_imm VR128:$src3))>;
2296   // Generic SHUFPD patterns
2297   def : Pat<(v2f64 (X86Shufps VR128:$src1,
2298                        (memopv2f64 addr:$src2), (i8 imm:$imm))),
2299             (SHUFPDrmi VR128:$src1, addr:$src2, imm:$imm)>;
2300   def : Pat<(v2i64 (X86Shufpd VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2301             (SHUFPDrri VR128:$src1, VR128:$src2, imm:$imm)>;
2302   def : Pat<(v2f64 (X86Shufpd VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2303             (SHUFPDrri VR128:$src1, VR128:$src2, imm:$imm)>;
2304 }
2305
2306 let Predicates = [HasAVX] in {
2307   def : Pat<(v4f32 (X86Shufps VR128:$src1,
2308                        (memopv4f32 addr:$src2), (i8 imm:$imm))),
2309             (VSHUFPSrmi VR128:$src1, addr:$src2, imm:$imm)>;
2310   def : Pat<(v4f32 (X86Shufps VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2311             (VSHUFPSrri VR128:$src1, VR128:$src2, imm:$imm)>;
2312   def : Pat<(v4i32 (X86Shufps VR128:$src1,
2313                        (bc_v4i32 (memopv2i64 addr:$src2)), (i8 imm:$imm))),
2314             (VSHUFPSrmi VR128:$src1, addr:$src2, imm:$imm)>;
2315   def : Pat<(v4i32 (X86Shufps VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2316             (VSHUFPSrri VR128:$src1, VR128:$src2, imm:$imm)>;
2317   // vector_shuffle v1, v2 <4, 5, 2, 3> using SHUFPSrri (we prefer movsd, but
2318   // fall back to this for SSE1)
2319   def : Pat<(v4f32 (movlp:$src3 VR128:$src1, (v4f32 VR128:$src2))),
2320             (VSHUFPSrri VR128:$src2, VR128:$src1,
2321                         (SHUFFLE_get_shuf_imm VR128:$src3))>;
2322   // Special unary SHUFPSrri case.
2323   def : Pat<(v4f32 (pshufd:$src3 VR128:$src1, (undef))),
2324             (VSHUFPSrri VR128:$src1, VR128:$src1,
2325                         (SHUFFLE_get_shuf_imm VR128:$src3))>;
2326   // Special binary v4i32 shuffle cases with SHUFPS.
2327   def : Pat<(v4i32 (shufp:$src3 VR128:$src1, (v4i32 VR128:$src2))),
2328             (VSHUFPSrri VR128:$src1, VR128:$src2,
2329                         (SHUFFLE_get_shuf_imm VR128:$src3))>;
2330   def : Pat<(v4i32 (shufp:$src3 VR128:$src1,
2331                                 (bc_v4i32 (memopv2i64 addr:$src2)))),
2332             (VSHUFPSrmi VR128:$src1, addr:$src2,
2333                         (SHUFFLE_get_shuf_imm VR128:$src3))>;
2334   // Special unary SHUFPDrri cases.
2335   def : Pat<(v2i64 (pshufd:$src3 VR128:$src1, (undef))),
2336             (VSHUFPDrri VR128:$src1, VR128:$src1,
2337                         (SHUFFLE_get_shuf_imm VR128:$src3))>;
2338   def : Pat<(v2f64 (pshufd:$src3 VR128:$src1, (undef))),
2339             (VSHUFPDrri VR128:$src1, VR128:$src1,
2340                         (SHUFFLE_get_shuf_imm VR128:$src3))>;
2341   // Special binary v2i64 shuffle cases using SHUFPDrri.
2342   def : Pat<(v2i64 (shufp:$src3 VR128:$src1, VR128:$src2)),
2343             (VSHUFPDrri VR128:$src1, VR128:$src2,
2344                         (SHUFFLE_get_shuf_imm VR128:$src3))>;
2345
2346   def : Pat<(v2f64 (X86Shufps VR128:$src1,
2347                        (memopv2f64 addr:$src2), (i8 imm:$imm))),
2348             (VSHUFPDrmi VR128:$src1, addr:$src2, imm:$imm)>;
2349   def : Pat<(v2i64 (X86Shufpd VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2350             (VSHUFPDrri VR128:$src1, VR128:$src2, imm:$imm)>;
2351   def : Pat<(v2f64 (X86Shufpd VR128:$src1, VR128:$src2, (i8 imm:$imm))),
2352             (VSHUFPDrri VR128:$src1, VR128:$src2, imm:$imm)>;
2353
2354   // 256-bit patterns
2355   def : Pat<(v8i32 (X86Shufps VR256:$src1, VR256:$src2, (i8 imm:$imm))),
2356             (VSHUFPSYrri VR256:$src1, VR256:$src2, imm:$imm)>;
2357   def : Pat<(v8i32 (X86Shufps VR256:$src1,
2358                       (bc_v8i32 (memopv4i64 addr:$src2)), (i8 imm:$imm))),
2359             (VSHUFPSYrmi VR256:$src1, addr:$src2, imm:$imm)>;
2360
2361   def : Pat<(v8f32 (X86Shufps VR256:$src1, VR256:$src2, (i8 imm:$imm))),
2362             (VSHUFPSYrri VR256:$src1, VR256:$src2, imm:$imm)>;
2363   def : Pat<(v8f32 (X86Shufps VR256:$src1,
2364                               (memopv8f32 addr:$src2), (i8 imm:$imm))),
2365             (VSHUFPSYrmi VR256:$src1, addr:$src2, imm:$imm)>;
2366
2367   def : Pat<(v4i64 (X86Shufpd VR256:$src1, VR256:$src2, (i8 imm:$imm))),
2368             (VSHUFPDYrri VR256:$src1, VR256:$src2, imm:$imm)>;
2369   def : Pat<(v4i64 (X86Shufpd VR256:$src1,
2370                               (memopv4i64 addr:$src2), (i8 imm:$imm))),
2371             (VSHUFPDYrmi VR256:$src1, addr:$src2, imm:$imm)>;
2372
2373   def : Pat<(v4f64 (X86Shufpd VR256:$src1, VR256:$src2, (i8 imm:$imm))),
2374             (VSHUFPDYrri VR256:$src1, VR256:$src2, imm:$imm)>;
2375   def : Pat<(v4f64 (X86Shufpd VR256:$src1,
2376                               (memopv4f64 addr:$src2), (i8 imm:$imm))),
2377             (VSHUFPDYrmi VR256:$src1, addr:$src2, imm:$imm)>;
2378 }
2379
2380 //===----------------------------------------------------------------------===//
2381 // SSE 1 & 2 - Unpack Instructions
2382 //===----------------------------------------------------------------------===//
2383
2384 /// sse12_unpack_interleave - sse 1 & 2 unpack and interleave
2385 multiclass sse12_unpack_interleave<bits<8> opc, PatFrag OpNode, ValueType vt,
2386                                    PatFrag mem_frag, RegisterClass RC,
2387                                    X86MemOperand x86memop, string asm,
2388                                    Domain d> {
2389     def rr : PI<opc, MRMSrcReg,
2390                 (outs RC:$dst), (ins RC:$src1, RC:$src2),
2391                 asm, [(set RC:$dst,
2392                            (vt (OpNode RC:$src1, RC:$src2)))], d>;
2393     def rm : PI<opc, MRMSrcMem,
2394                 (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
2395                 asm, [(set RC:$dst,
2396                            (vt (OpNode RC:$src1,
2397                                        (mem_frag addr:$src2))))], d>;
2398 }
2399
2400 let AddedComplexity = 10 in {
2401   defm VUNPCKHPS: sse12_unpack_interleave<0x15, unpckh, v4f32, memopv4f32,
2402         VR128, f128mem, "unpckhps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2403                        SSEPackedSingle>, TB, VEX_4V;
2404   defm VUNPCKHPD: sse12_unpack_interleave<0x15, unpckh, v2f64, memopv2f64,
2405         VR128, f128mem, "unpckhpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2406                        SSEPackedDouble>, TB, OpSize, VEX_4V;
2407   defm VUNPCKLPS: sse12_unpack_interleave<0x14, unpckl, v4f32, memopv4f32,
2408         VR128, f128mem, "unpcklps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2409                        SSEPackedSingle>, TB, VEX_4V;
2410   defm VUNPCKLPD: sse12_unpack_interleave<0x14, unpckl, v2f64, memopv2f64,
2411         VR128, f128mem, "unpcklpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2412                        SSEPackedDouble>, TB, OpSize, VEX_4V;
2413
2414   defm VUNPCKHPSY: sse12_unpack_interleave<0x15, unpckh, v8f32, memopv8f32,
2415         VR256, f256mem, "unpckhps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2416                        SSEPackedSingle>, TB, VEX_4V;
2417   defm VUNPCKHPDY: sse12_unpack_interleave<0x15, unpckh, v4f64, memopv4f64,
2418         VR256, f256mem, "unpckhpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2419                        SSEPackedDouble>, TB, OpSize, VEX_4V;
2420   defm VUNPCKLPSY: sse12_unpack_interleave<0x14, unpckl, v8f32, memopv8f32,
2421         VR256, f256mem, "unpcklps\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2422                        SSEPackedSingle>, TB, VEX_4V;
2423   defm VUNPCKLPDY: sse12_unpack_interleave<0x14, unpckl, v4f64, memopv4f64,
2424         VR256, f256mem, "unpcklpd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2425                        SSEPackedDouble>, TB, OpSize, VEX_4V;
2426
2427   let Constraints = "$src1 = $dst" in {
2428     defm UNPCKHPS: sse12_unpack_interleave<0x15, unpckh, v4f32, memopv4f32,
2429           VR128, f128mem, "unpckhps\t{$src2, $dst|$dst, $src2}",
2430                          SSEPackedSingle>, TB;
2431     defm UNPCKHPD: sse12_unpack_interleave<0x15, unpckh, v2f64, memopv2f64,
2432           VR128, f128mem, "unpckhpd\t{$src2, $dst|$dst, $src2}",
2433                          SSEPackedDouble>, TB, OpSize;
2434     defm UNPCKLPS: sse12_unpack_interleave<0x14, unpckl, v4f32, memopv4f32,
2435           VR128, f128mem, "unpcklps\t{$src2, $dst|$dst, $src2}",
2436                          SSEPackedSingle>, TB;
2437     defm UNPCKLPD: sse12_unpack_interleave<0x14, unpckl, v2f64, memopv2f64,
2438           VR128, f128mem, "unpcklpd\t{$src2, $dst|$dst, $src2}",
2439                          SSEPackedDouble>, TB, OpSize;
2440   } // Constraints = "$src1 = $dst"
2441 } // AddedComplexity
2442
2443 let Predicates = [HasSSE1] in {
2444   def : Pat<(v4f32 (X86Unpcklps VR128:$src1, (memopv4f32 addr:$src2))),
2445             (UNPCKLPSrm VR128:$src1, addr:$src2)>;
2446   def : Pat<(v4f32 (X86Unpcklps VR128:$src1, VR128:$src2)),
2447             (UNPCKLPSrr VR128:$src1, VR128:$src2)>;
2448   def : Pat<(v4f32 (X86Unpckhps VR128:$src1, (memopv4f32 addr:$src2))),
2449             (UNPCKHPSrm VR128:$src1, addr:$src2)>;
2450   def : Pat<(v4f32 (X86Unpckhps VR128:$src1, VR128:$src2)),
2451             (UNPCKHPSrr VR128:$src1, VR128:$src2)>;
2452 }
2453
2454 let Predicates = [HasSSE2] in {
2455   def : Pat<(v2f64 (X86Unpcklpd VR128:$src1, (memopv2f64 addr:$src2))),
2456             (UNPCKLPDrm VR128:$src1, addr:$src2)>;
2457   def : Pat<(v2f64 (X86Unpcklpd VR128:$src1, VR128:$src2)),
2458             (UNPCKLPDrr VR128:$src1, VR128:$src2)>;
2459   def : Pat<(v2f64 (X86Unpckhpd VR128:$src1, (memopv2f64 addr:$src2))),
2460             (UNPCKHPDrm VR128:$src1, addr:$src2)>;
2461   def : Pat<(v2f64 (X86Unpckhpd VR128:$src1, VR128:$src2)),
2462             (UNPCKHPDrr VR128:$src1, VR128:$src2)>;
2463
2464   // FIXME: Instead of X86Movddup, there should be a X86Unpcklpd here, the
2465   // problem is during lowering, where it's not possible to recognize the load
2466   // fold cause it has two uses through a bitcast. One use disappears at isel
2467   // time and the fold opportunity reappears.
2468   def : Pat<(v2f64 (X86Movddup VR128:$src)),
2469             (UNPCKLPDrr VR128:$src, VR128:$src)>;
2470
2471   let AddedComplexity = 10 in
2472   def : Pat<(splat_lo (v2f64 VR128:$src), (undef)),
2473             (UNPCKLPDrr VR128:$src, VR128:$src)>;
2474 }
2475
2476 let Predicates = [HasAVX] in {
2477   def : Pat<(v4f32 (X86Unpcklps VR128:$src1, (memopv4f32 addr:$src2))),
2478             (VUNPCKLPSrm VR128:$src1, addr:$src2)>;
2479   def : Pat<(v4f32 (X86Unpcklps VR128:$src1, VR128:$src2)),
2480             (VUNPCKLPSrr VR128:$src1, VR128:$src2)>;
2481   def : Pat<(v4f32 (X86Unpckhps VR128:$src1, (memopv4f32 addr:$src2))),
2482             (VUNPCKHPSrm VR128:$src1, addr:$src2)>;
2483   def : Pat<(v4f32 (X86Unpckhps VR128:$src1, VR128:$src2)),
2484             (VUNPCKHPSrr VR128:$src1, VR128:$src2)>;
2485
2486   def : Pat<(v8f32 (X86Unpcklpsy VR256:$src1, (memopv8f32 addr:$src2))),
2487             (VUNPCKLPSYrm VR256:$src1, addr:$src2)>;
2488   def : Pat<(v8f32 (X86Unpcklpsy VR256:$src1, VR256:$src2)),
2489             (VUNPCKLPSYrr VR256:$src1, VR256:$src2)>;
2490   def : Pat<(v8i32 (X86Unpcklpsy VR256:$src1, VR256:$src2)),
2491             (VUNPCKLPSYrr VR256:$src1, VR256:$src2)>;
2492   def : Pat<(v8i32 (X86Unpcklpsy VR256:$src1, (memopv8i32 addr:$src2))),
2493             (VUNPCKLPSYrm VR256:$src1, addr:$src2)>;
2494   def : Pat<(v8f32 (X86Unpckhpsy VR256:$src1, (memopv8f32 addr:$src2))),
2495             (VUNPCKHPSYrm VR256:$src1, addr:$src2)>;
2496   def : Pat<(v8f32 (X86Unpckhpsy VR256:$src1, VR256:$src2)),
2497             (VUNPCKHPSYrr VR256:$src1, VR256:$src2)>;
2498   def : Pat<(v8i32 (X86Unpckhpsy VR256:$src1, (memopv8i32 addr:$src2))),
2499             (VUNPCKHPSYrm VR256:$src1, addr:$src2)>;
2500   def : Pat<(v8i32 (X86Unpckhpsy VR256:$src1, VR256:$src2)),
2501             (VUNPCKHPSYrr VR256:$src1, VR256:$src2)>;
2502
2503   def : Pat<(v2f64 (X86Unpcklpd VR128:$src1, (memopv2f64 addr:$src2))),
2504             (VUNPCKLPDrm VR128:$src1, addr:$src2)>;
2505   def : Pat<(v2f64 (X86Unpcklpd VR128:$src1, VR128:$src2)),
2506             (VUNPCKLPDrr VR128:$src1, VR128:$src2)>;
2507   def : Pat<(v2f64 (X86Unpckhpd VR128:$src1, (memopv2f64 addr:$src2))),
2508             (VUNPCKHPDrm VR128:$src1, addr:$src2)>;
2509   def : Pat<(v2f64 (X86Unpckhpd VR128:$src1, VR128:$src2)),
2510             (VUNPCKHPDrr VR128:$src1, VR128:$src2)>;
2511
2512   def : Pat<(v4f64 (X86Unpcklpdy VR256:$src1, (memopv4f64 addr:$src2))),
2513             (VUNPCKLPDYrm VR256:$src1, addr:$src2)>;
2514   def : Pat<(v4f64 (X86Unpcklpdy VR256:$src1, VR256:$src2)),
2515             (VUNPCKLPDYrr VR256:$src1, VR256:$src2)>;
2516   def : Pat<(v4i64 (X86Unpcklpdy VR256:$src1, (memopv4i64 addr:$src2))),
2517             (VUNPCKLPDYrm VR256:$src1, addr:$src2)>;
2518   def : Pat<(v4i64 (X86Unpcklpdy VR256:$src1, VR256:$src2)),
2519             (VUNPCKLPDYrr VR256:$src1, VR256:$src2)>;
2520   def : Pat<(v4f64 (X86Unpckhpdy VR256:$src1, (memopv4f64 addr:$src2))),
2521             (VUNPCKHPDYrm VR256:$src1, addr:$src2)>;
2522   def : Pat<(v4f64 (X86Unpckhpdy VR256:$src1, VR256:$src2)),
2523             (VUNPCKHPDYrr VR256:$src1, VR256:$src2)>;
2524   def : Pat<(v4i64 (X86Unpckhpdy VR256:$src1, (memopv4i64 addr:$src2))),
2525             (VUNPCKHPDYrm VR256:$src1, addr:$src2)>;
2526   def : Pat<(v4i64 (X86Unpckhpdy VR256:$src1, VR256:$src2)),
2527             (VUNPCKHPDYrr VR256:$src1, VR256:$src2)>;
2528
2529   // FIXME: Instead of X86Movddup, there should be a X86Unpcklpd here, the
2530   // problem is during lowering, where it's not possible to recognize the load
2531   // fold cause it has two uses through a bitcast. One use disappears at isel
2532   // time and the fold opportunity reappears.
2533   def : Pat<(v2f64 (X86Movddup VR128:$src)),
2534             (VUNPCKLPDrr VR128:$src, VR128:$src)>;
2535   let AddedComplexity = 10 in
2536   def : Pat<(splat_lo (v2f64 VR128:$src), (undef)),
2537             (VUNPCKLPDrr VR128:$src, VR128:$src)>;
2538 }
2539
2540 //===----------------------------------------------------------------------===//
2541 // SSE 1 & 2 - Extract Floating-Point Sign mask
2542 //===----------------------------------------------------------------------===//
2543
2544 /// sse12_extr_sign_mask - sse 1 & 2 unpack and interleave
2545 multiclass sse12_extr_sign_mask<RegisterClass RC, Intrinsic Int, string asm,
2546                                 Domain d> {
2547   def rr32 : PI<0x50, MRMSrcReg, (outs GR32:$dst), (ins RC:$src),
2548                 !strconcat(asm, "\t{$src, $dst|$dst, $src}"),
2549                      [(set GR32:$dst, (Int RC:$src))], d>;
2550   def rr64 : PI<0x50, MRMSrcReg, (outs GR64:$dst), (ins RC:$src),
2551                 !strconcat(asm, "\t{$src, $dst|$dst, $src}"), [], d>, REX_W;
2552 }
2553
2554 defm MOVMSKPS : sse12_extr_sign_mask<VR128, int_x86_sse_movmsk_ps, "movmskps",
2555                                      SSEPackedSingle>, TB;
2556 defm MOVMSKPD : sse12_extr_sign_mask<VR128, int_x86_sse2_movmsk_pd, "movmskpd",
2557                                      SSEPackedDouble>, TB, OpSize;
2558
2559 def : Pat<(i32 (X86fgetsign FR32:$src)),
2560           (MOVMSKPSrr32 (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), FR32:$src,
2561                                        sub_ss))>, Requires<[HasSSE1]>;
2562 def : Pat<(i64 (X86fgetsign FR32:$src)),
2563           (MOVMSKPSrr64 (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), FR32:$src,
2564                                        sub_ss))>, Requires<[HasSSE1]>;
2565 def : Pat<(i32 (X86fgetsign FR64:$src)),
2566           (MOVMSKPDrr32 (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), FR64:$src,
2567                                        sub_sd))>, Requires<[HasSSE2]>;
2568 def : Pat<(i64 (X86fgetsign FR64:$src)),
2569           (MOVMSKPDrr64 (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), FR64:$src,
2570                                        sub_sd))>, Requires<[HasSSE2]>;
2571
2572 let Predicates = [HasAVX] in {
2573   defm VMOVMSKPS : sse12_extr_sign_mask<VR128, int_x86_sse_movmsk_ps,
2574                                         "movmskps", SSEPackedSingle>, TB, VEX;
2575   defm VMOVMSKPD : sse12_extr_sign_mask<VR128, int_x86_sse2_movmsk_pd,
2576                                         "movmskpd", SSEPackedDouble>, TB,
2577                                         OpSize, VEX;
2578   defm VMOVMSKPSY : sse12_extr_sign_mask<VR256, int_x86_avx_movmsk_ps_256,
2579                                         "movmskps", SSEPackedSingle>, TB, VEX;
2580   defm VMOVMSKPDY : sse12_extr_sign_mask<VR256, int_x86_avx_movmsk_pd_256,
2581                                         "movmskpd", SSEPackedDouble>, TB,
2582                                         OpSize, VEX;
2583
2584   def : Pat<(i32 (X86fgetsign FR32:$src)),
2585             (VMOVMSKPSrr32 (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), FR32:$src,
2586                                           sub_ss))>;
2587   def : Pat<(i64 (X86fgetsign FR32:$src)),
2588             (VMOVMSKPSrr64 (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), FR32:$src,
2589                                           sub_ss))>;
2590   def : Pat<(i32 (X86fgetsign FR64:$src)),
2591             (VMOVMSKPDrr32 (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), FR64:$src,
2592                                           sub_sd))>;
2593   def : Pat<(i64 (X86fgetsign FR64:$src)),
2594             (VMOVMSKPDrr64 (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), FR64:$src,
2595                                           sub_sd))>;
2596
2597   // Assembler Only
2598   def VMOVMSKPSr64r : PI<0x50, MRMSrcReg, (outs GR64:$dst), (ins VR128:$src),
2599              "movmskps\t{$src, $dst|$dst, $src}", [], SSEPackedSingle>, TB, VEX;
2600   def VMOVMSKPDr64r : PI<0x50, MRMSrcReg, (outs GR64:$dst), (ins VR128:$src),
2601              "movmskpd\t{$src, $dst|$dst, $src}", [], SSEPackedDouble>, TB,
2602              OpSize, VEX;
2603   def VMOVMSKPSYr64r : PI<0x50, MRMSrcReg, (outs GR64:$dst), (ins VR256:$src),
2604              "movmskps\t{$src, $dst|$dst, $src}", [], SSEPackedSingle>, TB, VEX;
2605   def VMOVMSKPDYr64r : PI<0x50, MRMSrcReg, (outs GR64:$dst), (ins VR256:$src),
2606              "movmskpd\t{$src, $dst|$dst, $src}", [], SSEPackedDouble>, TB,
2607              OpSize, VEX;
2608 }
2609
2610 //===----------------------------------------------------------------------===//
2611 // SSE 1 & 2 - Logical Instructions
2612 //===----------------------------------------------------------------------===//
2613
2614 /// sse12_fp_alias_pack_logical - SSE 1 & 2 aliased packed FP logical ops
2615 ///
2616 multiclass sse12_fp_alias_pack_logical<bits<8> opc, string OpcodeStr,
2617                                        SDNode OpNode> {
2618   defm V#NAME#PS : sse12_fp_packed<opc, !strconcat(OpcodeStr, "ps"), OpNode,
2619               FR32, f32, f128mem, memopfsf32, SSEPackedSingle, 0>, TB, VEX_4V;
2620
2621   defm V#NAME#PD : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode,
2622         FR64, f64, f128mem, memopfsf64, SSEPackedDouble, 0>, TB, OpSize, VEX_4V;
2623
2624   let Constraints = "$src1 = $dst" in {
2625     defm PS : sse12_fp_packed<opc, !strconcat(OpcodeStr, "ps"), OpNode, FR32,
2626                 f32, f128mem, memopfsf32, SSEPackedSingle>, TB;
2627
2628     defm PD : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode, FR64,
2629                 f64, f128mem, memopfsf64, SSEPackedDouble>, TB, OpSize;
2630   }
2631 }
2632
2633 // Alias bitwise logical operations using SSE logical ops on packed FP values.
2634 let mayLoad = 0 in {
2635   defm FsAND  : sse12_fp_alias_pack_logical<0x54, "and", X86fand>;
2636   defm FsOR   : sse12_fp_alias_pack_logical<0x56, "or", X86for>;
2637   defm FsXOR  : sse12_fp_alias_pack_logical<0x57, "xor", X86fxor>;
2638 }
2639
2640 let neverHasSideEffects = 1, Pattern = []<dag>, isCommutable = 0 in
2641   defm FsANDN : sse12_fp_alias_pack_logical<0x55, "andn", undef>;
2642
2643 /// sse12_fp_packed_logical - SSE 1 & 2 packed FP logical ops
2644 ///
2645 multiclass sse12_fp_packed_logical<bits<8> opc, string OpcodeStr,
2646                                    SDNode OpNode> {
2647   // In AVX no need to add a pattern for 128-bit logical rr ps, because they
2648   // are all promoted to v2i64, and the patterns are covered by the int
2649   // version. This is needed in SSE only, because v2i64 isn't supported on
2650   // SSE1, but only on SSE2.
2651   defm V#NAME#PS : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedSingle,
2652        !strconcat(OpcodeStr, "ps"), f128mem, [],
2653        [(set VR128:$dst, (OpNode (bc_v2i64 (v4f32 VR128:$src1)),
2654                                  (memopv2i64 addr:$src2)))], 0>, TB, VEX_4V;
2655
2656   defm V#NAME#PD : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedDouble,
2657        !strconcat(OpcodeStr, "pd"), f128mem,
2658        [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2659                                  (bc_v2i64 (v2f64 VR128:$src2))))],
2660        [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2661                                  (memopv2i64 addr:$src2)))], 0>,
2662                                                  TB, OpSize, VEX_4V;
2663   let Constraints = "$src1 = $dst" in {
2664     defm PS : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedSingle,
2665          !strconcat(OpcodeStr, "ps"), f128mem,
2666          [(set VR128:$dst, (v2i64 (OpNode VR128:$src1, VR128:$src2)))],
2667          [(set VR128:$dst, (OpNode (bc_v2i64 (v4f32 VR128:$src1)),
2668                                    (memopv2i64 addr:$src2)))]>, TB;
2669
2670     defm PD : sse12_fp_packed_logical_rm<opc, VR128, SSEPackedDouble,
2671          !strconcat(OpcodeStr, "pd"), f128mem,
2672          [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2673                                    (bc_v2i64 (v2f64 VR128:$src2))))],
2674          [(set VR128:$dst, (OpNode (bc_v2i64 (v2f64 VR128:$src1)),
2675                                    (memopv2i64 addr:$src2)))]>, TB, OpSize;
2676   }
2677 }
2678
2679 /// sse12_fp_packed_logical_y - AVX 256-bit SSE 1 & 2 logical ops forms
2680 ///
2681 multiclass sse12_fp_packed_logical_y<bits<8> opc, string OpcodeStr,
2682                                      SDNode OpNode> {
2683     defm PSY : sse12_fp_packed_logical_rm<opc, VR256, SSEPackedSingle,
2684           !strconcat(OpcodeStr, "ps"), f256mem,
2685           [(set VR256:$dst, (v4i64 (OpNode VR256:$src1, VR256:$src2)))],
2686           [(set VR256:$dst, (OpNode (bc_v4i64 (v8f32 VR256:$src1)),
2687                                     (memopv4i64 addr:$src2)))], 0>, TB, VEX_4V;
2688
2689     defm PDY : sse12_fp_packed_logical_rm<opc, VR256, SSEPackedDouble,
2690           !strconcat(OpcodeStr, "pd"), f256mem,
2691           [(set VR256:$dst, (OpNode (bc_v4i64 (v4f64 VR256:$src1)),
2692                                     (bc_v4i64 (v4f64 VR256:$src2))))],
2693           [(set VR256:$dst, (OpNode (bc_v4i64 (v4f64 VR256:$src1)),
2694                                     (memopv4i64 addr:$src2)))], 0>,
2695                                     TB, OpSize, VEX_4V;
2696 }
2697
2698 // AVX 256-bit packed logical ops forms
2699 defm VAND  : sse12_fp_packed_logical_y<0x54, "and", and>;
2700 defm VOR   : sse12_fp_packed_logical_y<0x56, "or", or>;
2701 defm VXOR  : sse12_fp_packed_logical_y<0x57, "xor", xor>;
2702 defm VANDN : sse12_fp_packed_logical_y<0x55, "andn", X86andnp>;
2703
2704 defm AND  : sse12_fp_packed_logical<0x54, "and", and>;
2705 defm OR   : sse12_fp_packed_logical<0x56, "or", or>;
2706 defm XOR  : sse12_fp_packed_logical<0x57, "xor", xor>;
2707 let isCommutable = 0 in
2708   defm ANDN : sse12_fp_packed_logical<0x55, "andn", X86andnp>;
2709
2710 //===----------------------------------------------------------------------===//
2711 // SSE 1 & 2 - Arithmetic Instructions
2712 //===----------------------------------------------------------------------===//
2713
2714 /// basic_sse12_fp_binop_xxx - SSE 1 & 2 binops come in both scalar and
2715 /// vector forms.
2716 ///
2717 /// In addition, we also have a special variant of the scalar form here to
2718 /// represent the associated intrinsic operation.  This form is unlike the
2719 /// plain scalar form, in that it takes an entire vector (instead of a scalar)
2720 /// and leaves the top elements unmodified (therefore these cannot be commuted).
2721 ///
2722 /// These three forms can each be reg+reg or reg+mem.
2723 ///
2724
2725 /// FIXME: once all 256-bit intrinsics are matched, cleanup and refactor those
2726 /// classes below
2727 multiclass basic_sse12_fp_binop_s<bits<8> opc, string OpcodeStr, SDNode OpNode,
2728                                   bit Is2Addr = 1> {
2729   defm SS : sse12_fp_scalar<opc, !strconcat(OpcodeStr, "ss"),
2730                             OpNode, FR32, f32mem, Is2Addr>, XS;
2731   defm SD : sse12_fp_scalar<opc, !strconcat(OpcodeStr, "sd"),
2732                             OpNode, FR64, f64mem, Is2Addr>, XD;
2733 }
2734
2735 multiclass basic_sse12_fp_binop_p<bits<8> opc, string OpcodeStr, SDNode OpNode,
2736                                    bit Is2Addr = 1> {
2737   let mayLoad = 0 in {
2738   defm PS : sse12_fp_packed<opc, !strconcat(OpcodeStr, "ps"), OpNode, VR128,
2739               v4f32, f128mem, memopv4f32, SSEPackedSingle, Is2Addr>, TB;
2740   defm PD : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode, VR128,
2741               v2f64, f128mem, memopv2f64, SSEPackedDouble, Is2Addr>, TB, OpSize;
2742   }
2743 }
2744
2745 multiclass basic_sse12_fp_binop_p_y<bits<8> opc, string OpcodeStr,
2746                                     SDNode OpNode> {
2747   let mayLoad = 0 in {
2748     defm PSY : sse12_fp_packed<opc, !strconcat(OpcodeStr, "ps"), OpNode, VR256,
2749                 v8f32, f256mem, memopv8f32, SSEPackedSingle, 0>, TB;
2750     defm PDY : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode, VR256,
2751                 v4f64, f256mem, memopv4f64, SSEPackedDouble, 0>, TB, OpSize;
2752   }
2753 }
2754
2755 multiclass basic_sse12_fp_binop_s_int<bits<8> opc, string OpcodeStr,
2756                                       bit Is2Addr = 1> {
2757   defm SS : sse12_fp_scalar_int<opc, OpcodeStr, VR128,
2758      !strconcat(OpcodeStr, "ss"), "", "_ss", ssmem, sse_load_f32, Is2Addr>, XS;
2759   defm SD : sse12_fp_scalar_int<opc, OpcodeStr, VR128,
2760      !strconcat(OpcodeStr, "sd"), "2", "_sd", sdmem, sse_load_f64, Is2Addr>, XD;
2761 }
2762
2763 multiclass basic_sse12_fp_binop_p_int<bits<8> opc, string OpcodeStr,
2764                                       bit Is2Addr = 1> {
2765   defm PS : sse12_fp_packed_int<opc, OpcodeStr, VR128,
2766      !strconcat(OpcodeStr, "ps"), "sse", "_ps", f128mem, memopv4f32,
2767                                               SSEPackedSingle, Is2Addr>, TB;
2768
2769   defm PD : sse12_fp_packed_int<opc, OpcodeStr, VR128,
2770      !strconcat(OpcodeStr, "pd"), "sse2", "_pd", f128mem, memopv2f64,
2771                                       SSEPackedDouble, Is2Addr>, TB, OpSize;
2772 }
2773
2774 multiclass basic_sse12_fp_binop_p_y_int<bits<8> opc, string OpcodeStr> {
2775   defm PSY : sse12_fp_packed_int<opc, OpcodeStr, VR256,
2776      !strconcat(OpcodeStr, "ps"), "avx", "_ps_256", f256mem, memopv8f32,
2777       SSEPackedSingle, 0>, TB;
2778
2779   defm PDY : sse12_fp_packed_int<opc, OpcodeStr, VR256,
2780      !strconcat(OpcodeStr, "pd"), "avx", "_pd_256", f256mem, memopv4f64,
2781       SSEPackedDouble, 0>, TB, OpSize;
2782 }
2783
2784 // Binary Arithmetic instructions
2785 defm VADD : basic_sse12_fp_binop_s<0x58, "add", fadd, 0>,
2786             basic_sse12_fp_binop_s_int<0x58, "add", 0>,
2787             basic_sse12_fp_binop_p<0x58, "add", fadd, 0>,
2788             basic_sse12_fp_binop_p_y<0x58, "add", fadd>, VEX_4V;
2789 defm VMUL : basic_sse12_fp_binop_s<0x59, "mul", fmul, 0>,
2790             basic_sse12_fp_binop_s_int<0x59, "mul", 0>,
2791             basic_sse12_fp_binop_p<0x59, "mul", fmul, 0>,
2792             basic_sse12_fp_binop_p_y<0x59, "mul", fmul>, VEX_4V;
2793
2794 let isCommutable = 0 in {
2795   defm VSUB : basic_sse12_fp_binop_s<0x5C, "sub", fsub, 0>,
2796               basic_sse12_fp_binop_s_int<0x5C, "sub", 0>,
2797               basic_sse12_fp_binop_p<0x5C, "sub", fsub, 0>,
2798               basic_sse12_fp_binop_p_y<0x5C, "sub", fsub>, VEX_4V;
2799   defm VDIV : basic_sse12_fp_binop_s<0x5E, "div", fdiv, 0>,
2800               basic_sse12_fp_binop_s_int<0x5E, "div", 0>,
2801               basic_sse12_fp_binop_p<0x5E, "div", fdiv, 0>,
2802               basic_sse12_fp_binop_p_y<0x5E, "div", fdiv>, VEX_4V;
2803   defm VMAX : basic_sse12_fp_binop_s<0x5F, "max", X86fmax, 0>,
2804               basic_sse12_fp_binop_s_int<0x5F, "max", 0>,
2805               basic_sse12_fp_binop_p<0x5F, "max", X86fmax, 0>,
2806               basic_sse12_fp_binop_p_int<0x5F, "max", 0>,
2807               basic_sse12_fp_binop_p_y<0x5F, "max", X86fmax>,
2808               basic_sse12_fp_binop_p_y_int<0x5F, "max">, VEX_4V;
2809   defm VMIN : basic_sse12_fp_binop_s<0x5D, "min", X86fmin, 0>,
2810               basic_sse12_fp_binop_s_int<0x5D, "min", 0>,
2811               basic_sse12_fp_binop_p<0x5D, "min", X86fmin, 0>,
2812               basic_sse12_fp_binop_p_int<0x5D, "min", 0>,
2813               basic_sse12_fp_binop_p_y_int<0x5D, "min">,
2814               basic_sse12_fp_binop_p_y<0x5D, "min", X86fmin>, VEX_4V;
2815 }
2816
2817 let Constraints = "$src1 = $dst" in {
2818   defm ADD : basic_sse12_fp_binop_s<0x58, "add", fadd>,
2819              basic_sse12_fp_binop_p<0x58, "add", fadd>,
2820              basic_sse12_fp_binop_s_int<0x58, "add">;
2821   defm MUL : basic_sse12_fp_binop_s<0x59, "mul", fmul>,
2822              basic_sse12_fp_binop_p<0x59, "mul", fmul>,
2823              basic_sse12_fp_binop_s_int<0x59, "mul">;
2824
2825   let isCommutable = 0 in {
2826     defm SUB : basic_sse12_fp_binop_s<0x5C, "sub", fsub>,
2827                basic_sse12_fp_binop_p<0x5C, "sub", fsub>,
2828                basic_sse12_fp_binop_s_int<0x5C, "sub">;
2829     defm DIV : basic_sse12_fp_binop_s<0x5E, "div", fdiv>,
2830                basic_sse12_fp_binop_p<0x5E, "div", fdiv>,
2831                basic_sse12_fp_binop_s_int<0x5E, "div">;
2832     defm MAX : basic_sse12_fp_binop_s<0x5F, "max", X86fmax>,
2833                basic_sse12_fp_binop_p<0x5F, "max", X86fmax>,
2834                basic_sse12_fp_binop_s_int<0x5F, "max">,
2835                basic_sse12_fp_binop_p_int<0x5F, "max">;
2836     defm MIN : basic_sse12_fp_binop_s<0x5D, "min", X86fmin>,
2837                basic_sse12_fp_binop_p<0x5D, "min", X86fmin>,
2838                basic_sse12_fp_binop_s_int<0x5D, "min">,
2839                basic_sse12_fp_binop_p_int<0x5D, "min">;
2840   }
2841 }
2842
2843 /// Unop Arithmetic
2844 /// In addition, we also have a special variant of the scalar form here to
2845 /// represent the associated intrinsic operation.  This form is unlike the
2846 /// plain scalar form, in that it takes an entire vector (instead of a
2847 /// scalar) and leaves the top elements undefined.
2848 ///
2849 /// And, we have a special variant form for a full-vector intrinsic form.
2850
2851 /// sse1_fp_unop_s - SSE1 unops in scalar form.
2852 multiclass sse1_fp_unop_s<bits<8> opc, string OpcodeStr,
2853                           SDNode OpNode, Intrinsic F32Int> {
2854   def SSr : SSI<opc, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src),
2855                 !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
2856                 [(set FR32:$dst, (OpNode FR32:$src))]>;
2857   // For scalar unary operations, fold a load into the operation
2858   // only in OptForSize mode. It eliminates an instruction, but it also
2859   // eliminates a whole-register clobber (the load), so it introduces a
2860   // partial register update condition.
2861   def SSm : I<opc, MRMSrcMem, (outs FR32:$dst), (ins f32mem:$src),
2862                 !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
2863                 [(set FR32:$dst, (OpNode (load addr:$src)))]>, XS,
2864             Requires<[HasSSE1, OptForSize]>;
2865   def SSr_Int : SSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2866                     !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
2867                     [(set VR128:$dst, (F32Int VR128:$src))]>;
2868   def SSm_Int : SSI<opc, MRMSrcMem, (outs VR128:$dst), (ins ssmem:$src),
2869                     !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
2870                     [(set VR128:$dst, (F32Int sse_load_f32:$src))]>;
2871 }
2872
2873 /// sse1_fp_unop_s_avx - AVX SSE1 unops in scalar form.
2874 multiclass sse1_fp_unop_s_avx<bits<8> opc, string OpcodeStr> {
2875   def SSr : SSI<opc, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src1, FR32:$src2),
2876                 !strconcat(OpcodeStr,
2877                            "ss\t{$src2, $src1, $dst|$dst, $src1, $src2}"), []>;
2878   let mayLoad = 1 in
2879   def SSm : SSI<opc, MRMSrcMem, (outs FR32:$dst), (ins FR32:$src1,f32mem:$src2),
2880                 !strconcat(OpcodeStr,
2881                            "ss\t{$src2, $src1, $dst|$dst, $src1, $src2}"), []>;
2882   def SSm_Int : SSI<opc, MRMSrcMem, (outs VR128:$dst),
2883                 (ins ssmem:$src1, VR128:$src2),
2884                 !strconcat(OpcodeStr,
2885                            "ss\t{$src2, $src1, $dst|$dst, $src1, $src2}"), []>;
2886 }
2887
2888 /// sse1_fp_unop_p - SSE1 unops in packed form.
2889 multiclass sse1_fp_unop_p<bits<8> opc, string OpcodeStr, SDNode OpNode> {
2890   def PSr : PSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2891               !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2892               [(set VR128:$dst, (v4f32 (OpNode VR128:$src)))]>;
2893   def PSm : PSI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2894                 !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2895                 [(set VR128:$dst, (OpNode (memopv4f32 addr:$src)))]>;
2896 }
2897
2898 /// sse1_fp_unop_p_y - AVX 256-bit SSE1 unops in packed form.
2899 multiclass sse1_fp_unop_p_y<bits<8> opc, string OpcodeStr, SDNode OpNode> {
2900   def PSYr : PSI<opc, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
2901               !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2902               [(set VR256:$dst, (v8f32 (OpNode VR256:$src)))]>;
2903   def PSYm : PSI<opc, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
2904                 !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2905                 [(set VR256:$dst, (OpNode (memopv8f32 addr:$src)))]>;
2906 }
2907
2908 /// sse1_fp_unop_p_int - SSE1 intrinsics unops in packed forms.
2909 multiclass sse1_fp_unop_p_int<bits<8> opc, string OpcodeStr,
2910                               Intrinsic V4F32Int> {
2911   def PSr_Int : PSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2912                     !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2913                     [(set VR128:$dst, (V4F32Int VR128:$src))]>;
2914   def PSm_Int : PSI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2915                     !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2916                     [(set VR128:$dst, (V4F32Int (memopv4f32 addr:$src)))]>;
2917 }
2918
2919 /// sse1_fp_unop_p_y_int - AVX 256-bit intrinsics unops in packed forms.
2920 multiclass sse1_fp_unop_p_y_int<bits<8> opc, string OpcodeStr,
2921                                 Intrinsic V4F32Int> {
2922   def PSYr_Int : PSI<opc, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
2923                     !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2924                     [(set VR256:$dst, (V4F32Int VR256:$src))]>;
2925   def PSYm_Int : PSI<opc, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
2926                     !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
2927                     [(set VR256:$dst, (V4F32Int (memopv8f32 addr:$src)))]>;
2928 }
2929
2930 /// sse2_fp_unop_s - SSE2 unops in scalar form.
2931 multiclass sse2_fp_unop_s<bits<8> opc, string OpcodeStr,
2932                           SDNode OpNode, Intrinsic F64Int> {
2933   def SDr : SDI<opc, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src),
2934                 !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
2935                 [(set FR64:$dst, (OpNode FR64:$src))]>;
2936   // See the comments in sse1_fp_unop_s for why this is OptForSize.
2937   def SDm : I<opc, MRMSrcMem, (outs FR64:$dst), (ins f64mem:$src),
2938                 !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
2939                 [(set FR64:$dst, (OpNode (load addr:$src)))]>, XD,
2940             Requires<[HasSSE2, OptForSize]>;
2941   def SDr_Int : SDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2942                     !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
2943                     [(set VR128:$dst, (F64Int VR128:$src))]>;
2944   def SDm_Int : SDI<opc, MRMSrcMem, (outs VR128:$dst), (ins sdmem:$src),
2945                     !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
2946                     [(set VR128:$dst, (F64Int sse_load_f64:$src))]>;
2947 }
2948
2949 /// sse2_fp_unop_s_avx - AVX SSE2 unops in scalar form.
2950 multiclass sse2_fp_unop_s_avx<bits<8> opc, string OpcodeStr> {
2951   def SDr : SDI<opc, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src1, FR64:$src2),
2952                !strconcat(OpcodeStr,
2953                           "sd\t{$src2, $src1, $dst|$dst, $src1, $src2}"), []>;
2954   def SDm : SDI<opc, MRMSrcMem, (outs FR64:$dst), (ins FR64:$src1,f64mem:$src2),
2955                !strconcat(OpcodeStr,
2956                           "sd\t{$src2, $src1, $dst|$dst, $src1, $src2}"), []>;
2957   def SDm_Int : SDI<opc, MRMSrcMem, (outs VR128:$dst),
2958                (ins VR128:$src1, sdmem:$src2),
2959                !strconcat(OpcodeStr,
2960                           "sd\t{$src2, $src1, $dst|$dst, $src1, $src2}"), []>;
2961 }
2962
2963 /// sse2_fp_unop_p - SSE2 unops in vector forms.
2964 multiclass sse2_fp_unop_p<bits<8> opc, string OpcodeStr,
2965                           SDNode OpNode> {
2966   def PDr : PDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2967               !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
2968               [(set VR128:$dst, (v2f64 (OpNode VR128:$src)))]>;
2969   def PDm : PDI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2970                 !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
2971                 [(set VR128:$dst, (OpNode (memopv2f64 addr:$src)))]>;
2972 }
2973
2974 /// sse2_fp_unop_p_y - AVX SSE2 256-bit unops in vector forms.
2975 multiclass sse2_fp_unop_p_y<bits<8> opc, string OpcodeStr, SDNode OpNode> {
2976   def PDYr : PDI<opc, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
2977               !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
2978               [(set VR256:$dst, (v4f64 (OpNode VR256:$src)))]>;
2979   def PDYm : PDI<opc, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
2980                 !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
2981                 [(set VR256:$dst, (OpNode (memopv4f64 addr:$src)))]>;
2982 }
2983
2984 /// sse2_fp_unop_p_int - SSE2 intrinsic unops in vector forms.
2985 multiclass sse2_fp_unop_p_int<bits<8> opc, string OpcodeStr,
2986                               Intrinsic V2F64Int> {
2987   def PDr_Int : PDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2988                     !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
2989                     [(set VR128:$dst, (V2F64Int VR128:$src))]>;
2990   def PDm_Int : PDI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2991                     !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
2992                     [(set VR128:$dst, (V2F64Int (memopv2f64 addr:$src)))]>;
2993 }
2994
2995 /// sse2_fp_unop_p_y_int - AVX 256-bit intrinsic unops in vector forms.
2996 multiclass sse2_fp_unop_p_y_int<bits<8> opc, string OpcodeStr,
2997                                 Intrinsic V2F64Int> {
2998   def PDYr_Int : PDI<opc, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
2999                     !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
3000                     [(set VR256:$dst, (V2F64Int VR256:$src))]>;
3001   def PDYm_Int : PDI<opc, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
3002                     !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
3003                     [(set VR256:$dst, (V2F64Int (memopv4f64 addr:$src)))]>;
3004 }
3005
3006 let Predicates = [HasAVX] in {
3007   // Square root.
3008   defm VSQRT  : sse1_fp_unop_s_avx<0x51, "vsqrt">,
3009                 sse2_fp_unop_s_avx<0x51, "vsqrt">, VEX_4V;
3010
3011   defm VSQRT  : sse1_fp_unop_p<0x51, "vsqrt", fsqrt>,
3012                 sse2_fp_unop_p<0x51, "vsqrt", fsqrt>,
3013                 sse1_fp_unop_p_y<0x51, "vsqrt", fsqrt>,
3014                 sse2_fp_unop_p_y<0x51, "vsqrt", fsqrt>,
3015                 sse1_fp_unop_p_int<0x51, "vsqrt", int_x86_sse_sqrt_ps>,
3016                 sse2_fp_unop_p_int<0x51, "vsqrt", int_x86_sse2_sqrt_pd>,
3017                 sse1_fp_unop_p_y_int<0x51, "vsqrt", int_x86_avx_sqrt_ps_256>,
3018                 sse2_fp_unop_p_y_int<0x51, "vsqrt", int_x86_avx_sqrt_pd_256>,
3019                 VEX;
3020
3021   // Reciprocal approximations. Note that these typically require refinement
3022   // in order to obtain suitable precision.
3023   defm VRSQRT : sse1_fp_unop_s_avx<0x52, "vrsqrt">, VEX_4V;
3024   defm VRSQRT : sse1_fp_unop_p<0x52, "vrsqrt", X86frsqrt>,
3025                 sse1_fp_unop_p_y<0x52, "vrsqrt", X86frsqrt>,
3026                 sse1_fp_unop_p_y_int<0x52, "vrsqrt", int_x86_avx_rsqrt_ps_256>,
3027                 sse1_fp_unop_p_int<0x52, "vrsqrt", int_x86_sse_rsqrt_ps>, VEX;
3028
3029   defm VRCP   : sse1_fp_unop_s_avx<0x53, "vrcp">, VEX_4V;
3030   defm VRCP   : sse1_fp_unop_p<0x53, "vrcp", X86frcp>,
3031                 sse1_fp_unop_p_y<0x53, "vrcp", X86frcp>,
3032                 sse1_fp_unop_p_y_int<0x53, "vrcp", int_x86_avx_rcp_ps_256>,
3033                 sse1_fp_unop_p_int<0x53, "vrcp", int_x86_sse_rcp_ps>, VEX;
3034 }
3035
3036 def : Pat<(f32 (fsqrt FR32:$src)),
3037           (VSQRTSSr (f32 (IMPLICIT_DEF)), FR32:$src)>, Requires<[HasAVX]>;
3038 def : Pat<(f32 (fsqrt (load addr:$src))),
3039           (VSQRTSSm (f32 (IMPLICIT_DEF)), addr:$src)>,
3040           Requires<[HasAVX, OptForSize]>;
3041 def : Pat<(f64 (fsqrt FR64:$src)),
3042           (VSQRTSDr (f64 (IMPLICIT_DEF)), FR64:$src)>, Requires<[HasAVX]>;
3043 def : Pat<(f64 (fsqrt (load addr:$src))),
3044           (VSQRTSDm (f64 (IMPLICIT_DEF)), addr:$src)>,
3045           Requires<[HasAVX, OptForSize]>;
3046
3047 def : Pat<(f32 (X86frsqrt FR32:$src)),
3048           (VRSQRTSSr (f32 (IMPLICIT_DEF)), FR32:$src)>, Requires<[HasAVX]>;
3049 def : Pat<(f32 (X86frsqrt (load addr:$src))),
3050           (VRSQRTSSm (f32 (IMPLICIT_DEF)), addr:$src)>,
3051           Requires<[HasAVX, OptForSize]>;
3052
3053 def : Pat<(f32 (X86frcp FR32:$src)),
3054           (VRCPSSr (f32 (IMPLICIT_DEF)), FR32:$src)>, Requires<[HasAVX]>;
3055 def : Pat<(f32 (X86frcp (load addr:$src))),
3056           (VRCPSSm (f32 (IMPLICIT_DEF)), addr:$src)>,
3057           Requires<[HasAVX, OptForSize]>;
3058
3059 let Predicates = [HasAVX] in {
3060   def : Pat<(int_x86_sse_sqrt_ss VR128:$src),
3061             (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)),
3062                 (VSQRTSSr (f32 (IMPLICIT_DEF)),
3063                           (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss)),
3064                 sub_ss)>;
3065   def : Pat<(int_x86_sse_sqrt_ss sse_load_f32:$src),
3066             (VSQRTSSm_Int (v4f32 (IMPLICIT_DEF)), sse_load_f32:$src)>;
3067
3068   def : Pat<(int_x86_sse2_sqrt_sd VR128:$src),
3069             (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)),
3070                 (VSQRTSDr (f64 (IMPLICIT_DEF)),
3071                           (EXTRACT_SUBREG (v2f64 VR128:$src), sub_sd)),
3072                 sub_sd)>;
3073   def : Pat<(int_x86_sse2_sqrt_sd sse_load_f64:$src),
3074             (VSQRTSDm_Int (v2f64 (IMPLICIT_DEF)), sse_load_f64:$src)>;
3075
3076   def : Pat<(int_x86_sse_rsqrt_ss VR128:$src),
3077             (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)),
3078                 (VRSQRTSSr (f32 (IMPLICIT_DEF)),
3079                           (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss)),
3080                 sub_ss)>;
3081   def : Pat<(int_x86_sse_rsqrt_ss sse_load_f32:$src),
3082             (VRSQRTSSm_Int (v4f32 (IMPLICIT_DEF)), sse_load_f32:$src)>;
3083
3084   def : Pat<(int_x86_sse_rcp_ss VR128:$src),
3085             (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)),
3086                 (VRCPSSr (f32 (IMPLICIT_DEF)),
3087                          (EXTRACT_SUBREG (v4f32 VR128:$src), sub_ss)),
3088                 sub_ss)>;
3089   def : Pat<(int_x86_sse_rcp_ss sse_load_f32:$src),
3090             (VRCPSSm_Int (v4f32 (IMPLICIT_DEF)), sse_load_f32:$src)>;
3091 }
3092
3093 // Square root.
3094 defm SQRT  : sse1_fp_unop_s<0x51, "sqrt",  fsqrt, int_x86_sse_sqrt_ss>,
3095              sse1_fp_unop_p<0x51, "sqrt",  fsqrt>,
3096              sse1_fp_unop_p_int<0x51, "sqrt",  int_x86_sse_sqrt_ps>,
3097              sse2_fp_unop_s<0x51, "sqrt",  fsqrt, int_x86_sse2_sqrt_sd>,
3098              sse2_fp_unop_p<0x51, "sqrt",  fsqrt>,
3099              sse2_fp_unop_p_int<0x51, "sqrt", int_x86_sse2_sqrt_pd>;
3100
3101 // Reciprocal approximations. Note that these typically require refinement
3102 // in order to obtain suitable precision.
3103 defm RSQRT : sse1_fp_unop_s<0x52, "rsqrt", X86frsqrt, int_x86_sse_rsqrt_ss>,
3104              sse1_fp_unop_p<0x52, "rsqrt", X86frsqrt>,
3105              sse1_fp_unop_p_int<0x52, "rsqrt", int_x86_sse_rsqrt_ps>;
3106 defm RCP   : sse1_fp_unop_s<0x53, "rcp", X86frcp, int_x86_sse_rcp_ss>,
3107              sse1_fp_unop_p<0x53, "rcp", X86frcp>,
3108              sse1_fp_unop_p_int<0x53, "rcp", int_x86_sse_rcp_ps>;
3109
3110 // There is no f64 version of the reciprocal approximation instructions.
3111
3112 //===----------------------------------------------------------------------===//
3113 // SSE 1 & 2 - Non-temporal stores
3114 //===----------------------------------------------------------------------===//
3115
3116 let AddedComplexity = 400 in { // Prefer non-temporal versions
3117   def VMOVNTPSmr : VPSI<0x2B, MRMDestMem, (outs),
3118                        (ins f128mem:$dst, VR128:$src),
3119                        "movntps\t{$src, $dst|$dst, $src}",
3120                        [(alignednontemporalstore (v4f32 VR128:$src),
3121                                                  addr:$dst)]>, VEX;
3122   def VMOVNTPDmr : VPDI<0x2B, MRMDestMem, (outs),
3123                        (ins f128mem:$dst, VR128:$src),
3124                        "movntpd\t{$src, $dst|$dst, $src}",
3125                        [(alignednontemporalstore (v2f64 VR128:$src),
3126                                                  addr:$dst)]>, VEX;
3127   def VMOVNTDQ_64mr : VPDI<0xE7, MRMDestMem, (outs),
3128                         (ins f128mem:$dst, VR128:$src),
3129                         "movntdq\t{$src, $dst|$dst, $src}",
3130                         [(alignednontemporalstore (v2f64 VR128:$src),
3131                                                   addr:$dst)]>, VEX;
3132
3133   let ExeDomain = SSEPackedInt in
3134   def VMOVNTDQmr    : VPDI<0xE7, MRMDestMem, (outs),
3135                            (ins f128mem:$dst, VR128:$src),
3136                            "movntdq\t{$src, $dst|$dst, $src}",
3137                            [(alignednontemporalstore (v4f32 VR128:$src),
3138                                                      addr:$dst)]>, VEX;
3139
3140   def : Pat<(alignednontemporalstore (v2i64 VR128:$src), addr:$dst),
3141             (VMOVNTDQmr addr:$dst, VR128:$src)>, Requires<[HasAVX]>;
3142
3143   def VMOVNTPSYmr : VPSI<0x2B, MRMDestMem, (outs),
3144                        (ins f256mem:$dst, VR256:$src),
3145                        "movntps\t{$src, $dst|$dst, $src}",
3146                        [(alignednontemporalstore (v8f32 VR256:$src),
3147                                                  addr:$dst)]>, VEX;
3148   def VMOVNTPDYmr : VPDI<0x2B, MRMDestMem, (outs),
3149                        (ins f256mem:$dst, VR256:$src),
3150                        "movntpd\t{$src, $dst|$dst, $src}",
3151                        [(alignednontemporalstore (v4f64 VR256:$src),
3152                                                  addr:$dst)]>, VEX;
3153   def VMOVNTDQY_64mr : VPDI<0xE7, MRMDestMem, (outs),
3154                         (ins f256mem:$dst, VR256:$src),
3155                         "movntdq\t{$src, $dst|$dst, $src}",
3156                         [(alignednontemporalstore (v4f64 VR256:$src),
3157                                                   addr:$dst)]>, VEX;
3158   let ExeDomain = SSEPackedInt in
3159   def VMOVNTDQYmr : VPDI<0xE7, MRMDestMem, (outs),
3160                       (ins f256mem:$dst, VR256:$src),
3161                       "movntdq\t{$src, $dst|$dst, $src}",
3162                       [(alignednontemporalstore (v8f32 VR256:$src),
3163                                                 addr:$dst)]>, VEX;
3164 }
3165
3166 def : Pat<(int_x86_avx_movnt_dq_256 addr:$dst, VR256:$src),
3167           (VMOVNTDQYmr addr:$dst, VR256:$src)>;
3168 def : Pat<(int_x86_avx_movnt_pd_256 addr:$dst, VR256:$src),
3169           (VMOVNTPDYmr addr:$dst, VR256:$src)>;
3170 def : Pat<(int_x86_avx_movnt_ps_256 addr:$dst, VR256:$src),
3171           (VMOVNTPSYmr addr:$dst, VR256:$src)>;
3172
3173 let AddedComplexity = 400 in { // Prefer non-temporal versions
3174 def MOVNTPSmr : PSI<0x2B, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
3175                     "movntps\t{$src, $dst|$dst, $src}",
3176                     [(alignednontemporalstore (v4f32 VR128:$src), addr:$dst)]>;
3177 def MOVNTPDmr : PDI<0x2B, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
3178                     "movntpd\t{$src, $dst|$dst, $src}",
3179                     [(alignednontemporalstore(v2f64 VR128:$src), addr:$dst)]>;
3180
3181 def MOVNTDQ_64mr : PDI<0xE7, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
3182                     "movntdq\t{$src, $dst|$dst, $src}",
3183                     [(alignednontemporalstore (v2f64 VR128:$src), addr:$dst)]>;
3184
3185 let ExeDomain = SSEPackedInt in
3186 def MOVNTDQmr : PDI<0xE7, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
3187                     "movntdq\t{$src, $dst|$dst, $src}",
3188                     [(alignednontemporalstore (v4f32 VR128:$src), addr:$dst)]>;
3189
3190 def : Pat<(alignednontemporalstore (v2i64 VR128:$src), addr:$dst),
3191           (MOVNTDQmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3192
3193 // There is no AVX form for instructions below this point
3194 def MOVNTImr : I<0xC3, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
3195                  "movnti{l}\t{$src, $dst|$dst, $src}",
3196                  [(nontemporalstore (i32 GR32:$src), addr:$dst)]>,
3197                TB, Requires<[HasSSE2]>;
3198 def MOVNTI_64mr : RI<0xC3, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
3199                      "movnti{q}\t{$src, $dst|$dst, $src}",
3200                      [(nontemporalstore (i64 GR64:$src), addr:$dst)]>,
3201                   TB, Requires<[HasSSE2]>;
3202 }
3203
3204 //===----------------------------------------------------------------------===//
3205 // SSE 1 & 2 - Prefetch and memory fence
3206 //===----------------------------------------------------------------------===//
3207
3208 // Prefetch intrinsic.
3209 def PREFETCHT0   : PSI<0x18, MRM1m, (outs), (ins i8mem:$src),
3210     "prefetcht0\t$src", [(prefetch addr:$src, imm, (i32 3), (i32 1))]>;
3211 def PREFETCHT1   : PSI<0x18, MRM2m, (outs), (ins i8mem:$src),
3212     "prefetcht1\t$src", [(prefetch addr:$src, imm, (i32 2), (i32 1))]>;
3213 def PREFETCHT2   : PSI<0x18, MRM3m, (outs), (ins i8mem:$src),
3214     "prefetcht2\t$src", [(prefetch addr:$src, imm, (i32 1), (i32 1))]>;
3215 def PREFETCHNTA  : PSI<0x18, MRM0m, (outs), (ins i8mem:$src),
3216     "prefetchnta\t$src", [(prefetch addr:$src, imm, (i32 0), (i32 1))]>;
3217
3218 // Flush cache
3219 def CLFLUSH : I<0xAE, MRM7m, (outs), (ins i8mem:$src),
3220                "clflush\t$src", [(int_x86_sse2_clflush addr:$src)]>,
3221               TB, Requires<[HasSSE2]>;
3222
3223 // Pause. This "instruction" is encoded as "rep; nop", so even though it
3224 // was introduced with SSE2, it's backward compatible.
3225 def PAUSE : I<0x90, RawFrm, (outs), (ins), "pause", []>, REP;
3226
3227 // Load, store, and memory fence
3228 def SFENCE : I<0xAE, MRM_F8, (outs), (ins),
3229                "sfence", [(int_x86_sse_sfence)]>, TB, Requires<[HasSSE1]>;
3230 def LFENCE : I<0xAE, MRM_E8, (outs), (ins),
3231                "lfence", [(int_x86_sse2_lfence)]>, TB, Requires<[HasSSE2]>;
3232 def MFENCE : I<0xAE, MRM_F0, (outs), (ins),
3233                "mfence", [(int_x86_sse2_mfence)]>, TB, Requires<[HasSSE2]>;
3234
3235 def : Pat<(X86SFence), (SFENCE)>;
3236 def : Pat<(X86LFence), (LFENCE)>;
3237 def : Pat<(X86MFence), (MFENCE)>;
3238
3239 //===----------------------------------------------------------------------===//
3240 // SSE 1 & 2 - Load/Store XCSR register
3241 //===----------------------------------------------------------------------===//
3242
3243 def VLDMXCSR : VPSI<0xAE, MRM2m, (outs), (ins i32mem:$src),
3244                   "ldmxcsr\t$src", [(int_x86_sse_ldmxcsr addr:$src)]>, VEX;
3245 def VSTMXCSR : VPSI<0xAE, MRM3m, (outs), (ins i32mem:$dst),
3246                   "stmxcsr\t$dst", [(int_x86_sse_stmxcsr addr:$dst)]>, VEX;
3247
3248 def LDMXCSR : PSI<0xAE, MRM2m, (outs), (ins i32mem:$src),
3249                   "ldmxcsr\t$src", [(int_x86_sse_ldmxcsr addr:$src)]>;
3250 def STMXCSR : PSI<0xAE, MRM3m, (outs), (ins i32mem:$dst),
3251                   "stmxcsr\t$dst", [(int_x86_sse_stmxcsr addr:$dst)]>;
3252
3253 //===---------------------------------------------------------------------===//
3254 // SSE2 - Move Aligned/Unaligned Packed Integer Instructions
3255 //===---------------------------------------------------------------------===//
3256
3257 let ExeDomain = SSEPackedInt in { // SSE integer instructions
3258
3259 let neverHasSideEffects = 1 in {
3260 def VMOVDQArr  : VPDI<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3261                     "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3262 def VMOVDQAYrr : VPDI<0x6F, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
3263                     "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3264 }
3265 def VMOVDQUrr  : VSSI<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3266                     "movdqu\t{$src, $dst|$dst, $src}", []>, VEX;
3267 def VMOVDQUYrr : VSSI<0x6F, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
3268                     "movdqu\t{$src, $dst|$dst, $src}", []>, VEX;
3269
3270 // For Disassembler
3271 let isCodeGenOnly = 1 in {
3272 def VMOVDQArr_REV  : VPDI<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3273                         "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3274 def VMOVDQAYrr_REV : VPDI<0x7F, MRMDestReg, (outs VR256:$dst), (ins VR256:$src),
3275                         "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3276 def VMOVDQUrr_REV  : VSSI<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3277                         "movdqu\t{$src, $dst|$dst, $src}", []>, VEX;
3278 def VMOVDQUYrr_REV : VSSI<0x7F, MRMDestReg, (outs VR256:$dst), (ins VR256:$src),
3279                         "movdqu\t{$src, $dst|$dst, $src}", []>, VEX;
3280 }
3281
3282 let canFoldAsLoad = 1, mayLoad = 1 in {
3283 def VMOVDQArm  : VPDI<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3284                    "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3285 def VMOVDQAYrm : VPDI<0x6F, MRMSrcMem, (outs VR256:$dst), (ins i256mem:$src),
3286                    "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3287 let Predicates = [HasAVX] in {
3288   def VMOVDQUrm  : I<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3289                     "vmovdqu\t{$src, $dst|$dst, $src}",[]>, XS, VEX;
3290   def VMOVDQUYrm : I<0x6F, MRMSrcMem, (outs VR256:$dst), (ins i256mem:$src),
3291                     "vmovdqu\t{$src, $dst|$dst, $src}",[]>, XS, VEX;
3292 }
3293 }
3294
3295 let mayStore = 1 in {
3296 def VMOVDQAmr  : VPDI<0x7F, MRMDestMem, (outs),
3297                      (ins i128mem:$dst, VR128:$src),
3298                      "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3299 def VMOVDQAYmr : VPDI<0x7F, MRMDestMem, (outs),
3300                      (ins i256mem:$dst, VR256:$src),
3301                      "movdqa\t{$src, $dst|$dst, $src}", []>, VEX;
3302 let Predicates = [HasAVX] in {
3303 def VMOVDQUmr  : I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3304                   "vmovdqu\t{$src, $dst|$dst, $src}",[]>, XS, VEX;
3305 def VMOVDQUYmr : I<0x7F, MRMDestMem, (outs), (ins i256mem:$dst, VR256:$src),
3306                   "vmovdqu\t{$src, $dst|$dst, $src}",[]>, XS, VEX;
3307 }
3308 }
3309
3310 let neverHasSideEffects = 1 in
3311 def MOVDQArr : PDI<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3312                    "movdqa\t{$src, $dst|$dst, $src}", []>;
3313
3314 def MOVDQUrr :   I<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3315                    "movdqu\t{$src, $dst|$dst, $src}",
3316                    []>, XS, Requires<[HasSSE2]>;
3317
3318 // For Disassembler
3319 let isCodeGenOnly = 1 in {
3320 def MOVDQArr_REV : PDI<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3321                        "movdqa\t{$src, $dst|$dst, $src}", []>;
3322
3323 def MOVDQUrr_REV :   I<0x7F, MRMDestReg, (outs VR128:$dst), (ins VR128:$src),
3324                        "movdqu\t{$src, $dst|$dst, $src}",
3325                        []>, XS, Requires<[HasSSE2]>;
3326 }
3327
3328 let canFoldAsLoad = 1, mayLoad = 1 in {
3329 def MOVDQArm : PDI<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3330                    "movdqa\t{$src, $dst|$dst, $src}",
3331                    [/*(set VR128:$dst, (alignedloadv2i64 addr:$src))*/]>;
3332 def MOVDQUrm :   I<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3333                    "movdqu\t{$src, $dst|$dst, $src}",
3334                    [/*(set VR128:$dst, (loadv2i64 addr:$src))*/]>,
3335                  XS, Requires<[HasSSE2]>;
3336 }
3337
3338 let mayStore = 1 in {
3339 def MOVDQAmr : PDI<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3340                    "movdqa\t{$src, $dst|$dst, $src}",
3341                    [/*(alignedstore (v2i64 VR128:$src), addr:$dst)*/]>;
3342 def MOVDQUmr :   I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3343                    "movdqu\t{$src, $dst|$dst, $src}",
3344                    [/*(store (v2i64 VR128:$src), addr:$dst)*/]>,
3345                  XS, Requires<[HasSSE2]>;
3346 }
3347
3348 // Intrinsic forms of MOVDQU load and store
3349 def VMOVDQUmr_Int : I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3350                        "vmovdqu\t{$src, $dst|$dst, $src}",
3351                        [(int_x86_sse2_storeu_dq addr:$dst, VR128:$src)]>,
3352                      XS, VEX, Requires<[HasAVX]>;
3353
3354 def MOVDQUmr_Int :   I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
3355                        "movdqu\t{$src, $dst|$dst, $src}",
3356                        [(int_x86_sse2_storeu_dq addr:$dst, VR128:$src)]>,
3357                      XS, Requires<[HasSSE2]>;
3358
3359 } // ExeDomain = SSEPackedInt
3360
3361 let Predicates = [HasAVX] in {
3362   def : Pat<(int_x86_avx_loadu_dq_256 addr:$src), (VMOVDQUYrm addr:$src)>;
3363   def : Pat<(int_x86_avx_storeu_dq_256 addr:$dst, VR256:$src),
3364             (VMOVDQUYmr addr:$dst, VR256:$src)>;
3365 }
3366
3367 //===---------------------------------------------------------------------===//
3368 // SSE2 - Packed Integer Arithmetic Instructions
3369 //===---------------------------------------------------------------------===//
3370
3371 let ExeDomain = SSEPackedInt in { // SSE integer instructions
3372
3373 multiclass PDI_binop_rm_int<bits<8> opc, string OpcodeStr, Intrinsic IntId,
3374                             bit IsCommutable = 0, bit Is2Addr = 1> {
3375   let isCommutable = IsCommutable in
3376   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
3377        (ins VR128:$src1, VR128:$src2),
3378        !if(Is2Addr,
3379            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3380            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3381        [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
3382   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
3383        (ins VR128:$src1, i128mem:$src2),
3384        !if(Is2Addr,
3385            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3386            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3387        [(set VR128:$dst, (IntId VR128:$src1,
3388                                 (bitconvert (memopv2i64 addr:$src2))))]>;
3389 }
3390
3391 multiclass PDI_binop_rmi_int<bits<8> opc, bits<8> opc2, Format ImmForm,
3392                              string OpcodeStr, Intrinsic IntId,
3393                              Intrinsic IntId2, bit Is2Addr = 1> {
3394   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
3395        (ins VR128:$src1, VR128:$src2),
3396        !if(Is2Addr,
3397            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3398            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3399        [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
3400   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
3401        (ins VR128:$src1, i128mem:$src2),
3402        !if(Is2Addr,
3403            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3404            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3405        [(set VR128:$dst, (IntId VR128:$src1,
3406                                       (bitconvert (memopv2i64 addr:$src2))))]>;
3407   def ri : PDIi8<opc2, ImmForm, (outs VR128:$dst),
3408        (ins VR128:$src1, i32i8imm:$src2),
3409        !if(Is2Addr,
3410            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3411            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3412        [(set VR128:$dst, (IntId2 VR128:$src1, (i32 imm:$src2)))]>;
3413 }
3414
3415 /// PDI_binop_rm - Simple SSE2 binary operator.
3416 multiclass PDI_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
3417                         ValueType OpVT, bit IsCommutable = 0, bit Is2Addr = 1> {
3418   let isCommutable = IsCommutable in
3419   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
3420        (ins VR128:$src1, VR128:$src2),
3421        !if(Is2Addr,
3422            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3423            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3424        [(set VR128:$dst, (OpVT (OpNode VR128:$src1, VR128:$src2)))]>;
3425   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
3426        (ins VR128:$src1, i128mem:$src2),
3427        !if(Is2Addr,
3428            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3429            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3430        [(set VR128:$dst, (OpVT (OpNode VR128:$src1,
3431                                      (bitconvert (memopv2i64 addr:$src2)))))]>;
3432 }
3433
3434 /// PDI_binop_rm_v2i64 - Simple SSE2 binary operator whose type is v2i64.
3435 ///
3436 /// FIXME: we could eliminate this and use PDI_binop_rm instead if tblgen knew
3437 /// to collapse (bitconvert VT to VT) into its operand.
3438 ///
3439 multiclass PDI_binop_rm_v2i64<bits<8> opc, string OpcodeStr, SDNode OpNode,
3440                               bit IsCommutable = 0, bit Is2Addr = 1> {
3441   let isCommutable = IsCommutable in
3442   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
3443        (ins VR128:$src1, VR128:$src2),
3444        !if(Is2Addr,
3445            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3446            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3447        [(set VR128:$dst, (v2i64 (OpNode VR128:$src1, VR128:$src2)))]>;
3448   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
3449        (ins VR128:$src1, i128mem:$src2),
3450        !if(Is2Addr,
3451            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3452            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3453        [(set VR128:$dst, (OpNode VR128:$src1, (memopv2i64 addr:$src2)))]>;
3454 }
3455
3456 } // ExeDomain = SSEPackedInt
3457
3458 // 128-bit Integer Arithmetic
3459
3460 let Predicates = [HasAVX] in {
3461 defm VPADDB  : PDI_binop_rm<0xFC, "vpaddb", add, v16i8, 1, 0 /*3addr*/>, VEX_4V;
3462 defm VPADDW  : PDI_binop_rm<0xFD, "vpaddw", add, v8i16, 1, 0>, VEX_4V;
3463 defm VPADDD  : PDI_binop_rm<0xFE, "vpaddd", add, v4i32, 1, 0>, VEX_4V;
3464 defm VPADDQ  : PDI_binop_rm_v2i64<0xD4, "vpaddq", add, 1, 0>, VEX_4V;
3465 defm VPMULLW : PDI_binop_rm<0xD5, "vpmullw", mul, v8i16, 1, 0>, VEX_4V;
3466 defm VPSUBB : PDI_binop_rm<0xF8, "vpsubb", sub, v16i8, 0, 0>, VEX_4V;
3467 defm VPSUBW : PDI_binop_rm<0xF9, "vpsubw", sub, v8i16, 0, 0>, VEX_4V;
3468 defm VPSUBD : PDI_binop_rm<0xFA, "vpsubd", sub, v4i32, 0, 0>, VEX_4V;
3469 defm VPSUBQ : PDI_binop_rm_v2i64<0xFB, "vpsubq", sub, 0, 0>, VEX_4V;
3470
3471 // Intrinsic forms
3472 defm VPSUBSB  : PDI_binop_rm_int<0xE8, "vpsubsb" , int_x86_sse2_psubs_b, 0, 0>,
3473                                  VEX_4V;
3474 defm VPSUBSW  : PDI_binop_rm_int<0xE9, "vpsubsw" , int_x86_sse2_psubs_w, 0, 0>,
3475                                  VEX_4V;
3476 defm VPSUBUSB : PDI_binop_rm_int<0xD8, "vpsubusb", int_x86_sse2_psubus_b, 0, 0>,
3477                                  VEX_4V;
3478 defm VPSUBUSW : PDI_binop_rm_int<0xD9, "vpsubusw", int_x86_sse2_psubus_w, 0, 0>,
3479                                  VEX_4V;
3480 defm VPADDSB  : PDI_binop_rm_int<0xEC, "vpaddsb" , int_x86_sse2_padds_b, 1, 0>,
3481                                  VEX_4V;
3482 defm VPADDSW  : PDI_binop_rm_int<0xED, "vpaddsw" , int_x86_sse2_padds_w, 1, 0>,
3483                                  VEX_4V;
3484 defm VPADDUSB : PDI_binop_rm_int<0xDC, "vpaddusb", int_x86_sse2_paddus_b, 1, 0>,
3485                                  VEX_4V;
3486 defm VPADDUSW : PDI_binop_rm_int<0xDD, "vpaddusw", int_x86_sse2_paddus_w, 1, 0>,
3487                                  VEX_4V;
3488 defm VPMULHUW : PDI_binop_rm_int<0xE4, "vpmulhuw", int_x86_sse2_pmulhu_w, 1, 0>,
3489                                  VEX_4V;
3490 defm VPMULHW  : PDI_binop_rm_int<0xE5, "vpmulhw" , int_x86_sse2_pmulh_w, 1, 0>,
3491                                  VEX_4V;
3492 defm VPMULUDQ : PDI_binop_rm_int<0xF4, "vpmuludq", int_x86_sse2_pmulu_dq, 1, 0>,
3493                                  VEX_4V;
3494 defm VPMADDWD : PDI_binop_rm_int<0xF5, "vpmaddwd", int_x86_sse2_pmadd_wd, 1, 0>,
3495                                  VEX_4V;
3496 defm VPAVGB   : PDI_binop_rm_int<0xE0, "vpavgb", int_x86_sse2_pavg_b, 1, 0>,
3497                                  VEX_4V;
3498 defm VPAVGW   : PDI_binop_rm_int<0xE3, "vpavgw", int_x86_sse2_pavg_w, 1, 0>,
3499                                  VEX_4V;
3500 defm VPMINUB  : PDI_binop_rm_int<0xDA, "vpminub", int_x86_sse2_pminu_b, 1, 0>,
3501                                  VEX_4V;
3502 defm VPMINSW  : PDI_binop_rm_int<0xEA, "vpminsw", int_x86_sse2_pmins_w, 1, 0>,
3503                                  VEX_4V;
3504 defm VPMAXUB  : PDI_binop_rm_int<0xDE, "vpmaxub", int_x86_sse2_pmaxu_b, 1, 0>,
3505                                  VEX_4V;
3506 defm VPMAXSW  : PDI_binop_rm_int<0xEE, "vpmaxsw", int_x86_sse2_pmaxs_w, 1, 0>,
3507                                  VEX_4V;
3508 defm VPSADBW  : PDI_binop_rm_int<0xF6, "vpsadbw", int_x86_sse2_psad_bw, 1, 0>,
3509                                  VEX_4V;
3510 }
3511
3512 let Constraints = "$src1 = $dst" in {
3513 defm PADDB  : PDI_binop_rm<0xFC, "paddb", add, v16i8, 1>;
3514 defm PADDW  : PDI_binop_rm<0xFD, "paddw", add, v8i16, 1>;
3515 defm PADDD  : PDI_binop_rm<0xFE, "paddd", add, v4i32, 1>;
3516 defm PADDQ  : PDI_binop_rm_v2i64<0xD4, "paddq", add, 1>;
3517 defm PMULLW : PDI_binop_rm<0xD5, "pmullw", mul, v8i16, 1>;
3518 defm PSUBB : PDI_binop_rm<0xF8, "psubb", sub, v16i8>;
3519 defm PSUBW : PDI_binop_rm<0xF9, "psubw", sub, v8i16>;
3520 defm PSUBD : PDI_binop_rm<0xFA, "psubd", sub, v4i32>;
3521 defm PSUBQ : PDI_binop_rm_v2i64<0xFB, "psubq", sub>;
3522
3523 // Intrinsic forms
3524 defm PSUBSB  : PDI_binop_rm_int<0xE8, "psubsb" , int_x86_sse2_psubs_b>;
3525 defm PSUBSW  : PDI_binop_rm_int<0xE9, "psubsw" , int_x86_sse2_psubs_w>;
3526 defm PSUBUSB : PDI_binop_rm_int<0xD8, "psubusb", int_x86_sse2_psubus_b>;
3527 defm PSUBUSW : PDI_binop_rm_int<0xD9, "psubusw", int_x86_sse2_psubus_w>;
3528 defm PADDSB  : PDI_binop_rm_int<0xEC, "paddsb" , int_x86_sse2_padds_b, 1>;
3529 defm PADDSW  : PDI_binop_rm_int<0xED, "paddsw" , int_x86_sse2_padds_w, 1>;
3530 defm PADDUSB : PDI_binop_rm_int<0xDC, "paddusb", int_x86_sse2_paddus_b, 1>;
3531 defm PADDUSW : PDI_binop_rm_int<0xDD, "paddusw", int_x86_sse2_paddus_w, 1>;
3532 defm PMULHUW : PDI_binop_rm_int<0xE4, "pmulhuw", int_x86_sse2_pmulhu_w, 1>;
3533 defm PMULHW  : PDI_binop_rm_int<0xE5, "pmulhw" , int_x86_sse2_pmulh_w, 1>;
3534 defm PMULUDQ : PDI_binop_rm_int<0xF4, "pmuludq", int_x86_sse2_pmulu_dq, 1>;
3535 defm PMADDWD : PDI_binop_rm_int<0xF5, "pmaddwd", int_x86_sse2_pmadd_wd, 1>;
3536 defm PAVGB   : PDI_binop_rm_int<0xE0, "pavgb", int_x86_sse2_pavg_b, 1>;
3537 defm PAVGW   : PDI_binop_rm_int<0xE3, "pavgw", int_x86_sse2_pavg_w, 1>;
3538 defm PMINUB  : PDI_binop_rm_int<0xDA, "pminub", int_x86_sse2_pminu_b, 1>;
3539 defm PMINSW  : PDI_binop_rm_int<0xEA, "pminsw", int_x86_sse2_pmins_w, 1>;
3540 defm PMAXUB  : PDI_binop_rm_int<0xDE, "pmaxub", int_x86_sse2_pmaxu_b, 1>;
3541 defm PMAXSW  : PDI_binop_rm_int<0xEE, "pmaxsw", int_x86_sse2_pmaxs_w, 1>;
3542 defm PSADBW  : PDI_binop_rm_int<0xF6, "psadbw", int_x86_sse2_psad_bw, 1>;
3543
3544 } // Constraints = "$src1 = $dst"
3545
3546 //===---------------------------------------------------------------------===//
3547 // SSE2 - Packed Integer Logical Instructions
3548 //===---------------------------------------------------------------------===//
3549
3550 let Predicates = [HasAVX] in {
3551 defm VPSLLW : PDI_binop_rmi_int<0xF1, 0x71, MRM6r, "vpsllw",
3552                                 int_x86_sse2_psll_w, int_x86_sse2_pslli_w, 0>,
3553                                 VEX_4V;
3554 defm VPSLLD : PDI_binop_rmi_int<0xF2, 0x72, MRM6r, "vpslld",
3555                                 int_x86_sse2_psll_d, int_x86_sse2_pslli_d, 0>,
3556                                 VEX_4V;
3557 defm VPSLLQ : PDI_binop_rmi_int<0xF3, 0x73, MRM6r, "vpsllq",
3558                                 int_x86_sse2_psll_q, int_x86_sse2_pslli_q, 0>,
3559                                 VEX_4V;
3560
3561 defm VPSRLW : PDI_binop_rmi_int<0xD1, 0x71, MRM2r, "vpsrlw",
3562                                 int_x86_sse2_psrl_w, int_x86_sse2_psrli_w, 0>,
3563                                 VEX_4V;
3564 defm VPSRLD : PDI_binop_rmi_int<0xD2, 0x72, MRM2r, "vpsrld",
3565                                 int_x86_sse2_psrl_d, int_x86_sse2_psrli_d, 0>,
3566                                 VEX_4V;
3567 defm VPSRLQ : PDI_binop_rmi_int<0xD3, 0x73, MRM2r, "vpsrlq",
3568                                 int_x86_sse2_psrl_q, int_x86_sse2_psrli_q, 0>,
3569                                 VEX_4V;
3570
3571 defm VPSRAW : PDI_binop_rmi_int<0xE1, 0x71, MRM4r, "vpsraw",
3572                                 int_x86_sse2_psra_w, int_x86_sse2_psrai_w, 0>,
3573                                 VEX_4V;
3574 defm VPSRAD : PDI_binop_rmi_int<0xE2, 0x72, MRM4r, "vpsrad",
3575                                 int_x86_sse2_psra_d, int_x86_sse2_psrai_d, 0>,
3576                                 VEX_4V;
3577
3578 defm VPAND : PDI_binop_rm_v2i64<0xDB, "vpand", and, 1, 0>, VEX_4V;
3579 defm VPOR  : PDI_binop_rm_v2i64<0xEB, "vpor" , or, 1, 0>, VEX_4V;
3580 defm VPXOR : PDI_binop_rm_v2i64<0xEF, "vpxor", xor, 1, 0>, VEX_4V;
3581
3582 let ExeDomain = SSEPackedInt in {
3583   let neverHasSideEffects = 1 in {
3584     // 128-bit logical shifts.
3585     def VPSLLDQri : PDIi8<0x73, MRM7r,
3586                       (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
3587                       "vpslldq\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
3588                       VEX_4V;
3589     def VPSRLDQri : PDIi8<0x73, MRM3r,
3590                       (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
3591                       "vpsrldq\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>,
3592                       VEX_4V;
3593     // PSRADQri doesn't exist in SSE[1-3].
3594   }
3595   def VPANDNrr : PDI<0xDF, MRMSrcReg,
3596                     (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3597                     "vpandn\t{$src2, $src1, $dst|$dst, $src1, $src2}",
3598                     [(set VR128:$dst,
3599                           (v2i64 (X86andnp VR128:$src1, VR128:$src2)))]>,VEX_4V;
3600
3601   def VPANDNrm : PDI<0xDF, MRMSrcMem,
3602                     (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
3603                     "vpandn\t{$src2, $src1, $dst|$dst, $src1, $src2}",
3604                     [(set VR128:$dst, (X86andnp VR128:$src1,
3605                                             (memopv2i64 addr:$src2)))]>, VEX_4V;
3606 }
3607 }
3608
3609 let Constraints = "$src1 = $dst" in {
3610 defm PSLLW : PDI_binop_rmi_int<0xF1, 0x71, MRM6r, "psllw",
3611                                int_x86_sse2_psll_w, int_x86_sse2_pslli_w>;
3612 defm PSLLD : PDI_binop_rmi_int<0xF2, 0x72, MRM6r, "pslld",
3613                                int_x86_sse2_psll_d, int_x86_sse2_pslli_d>;
3614 defm PSLLQ : PDI_binop_rmi_int<0xF3, 0x73, MRM6r, "psllq",
3615                                int_x86_sse2_psll_q, int_x86_sse2_pslli_q>;
3616
3617 defm PSRLW : PDI_binop_rmi_int<0xD1, 0x71, MRM2r, "psrlw",
3618                                int_x86_sse2_psrl_w, int_x86_sse2_psrli_w>;
3619 defm PSRLD : PDI_binop_rmi_int<0xD2, 0x72, MRM2r, "psrld",
3620                                int_x86_sse2_psrl_d, int_x86_sse2_psrli_d>;
3621 defm PSRLQ : PDI_binop_rmi_int<0xD3, 0x73, MRM2r, "psrlq",
3622                                int_x86_sse2_psrl_q, int_x86_sse2_psrli_q>;
3623
3624 defm PSRAW : PDI_binop_rmi_int<0xE1, 0x71, MRM4r, "psraw",
3625                                int_x86_sse2_psra_w, int_x86_sse2_psrai_w>;
3626 defm PSRAD : PDI_binop_rmi_int<0xE2, 0x72, MRM4r, "psrad",
3627                                int_x86_sse2_psra_d, int_x86_sse2_psrai_d>;
3628
3629 defm PAND : PDI_binop_rm_v2i64<0xDB, "pand", and, 1>;
3630 defm POR  : PDI_binop_rm_v2i64<0xEB, "por" , or, 1>;
3631 defm PXOR : PDI_binop_rm_v2i64<0xEF, "pxor", xor, 1>;
3632
3633 let ExeDomain = SSEPackedInt in {
3634   let neverHasSideEffects = 1 in {
3635     // 128-bit logical shifts.
3636     def PSLLDQri : PDIi8<0x73, MRM7r,
3637                          (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
3638                          "pslldq\t{$src2, $dst|$dst, $src2}", []>;
3639     def PSRLDQri : PDIi8<0x73, MRM3r,
3640                          (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
3641                          "psrldq\t{$src2, $dst|$dst, $src2}", []>;
3642     // PSRADQri doesn't exist in SSE[1-3].
3643   }
3644   def PANDNrr : PDI<0xDF, MRMSrcReg,
3645                     (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3646                     "pandn\t{$src2, $dst|$dst, $src2}", []>;
3647
3648   def PANDNrm : PDI<0xDF, MRMSrcMem,
3649                     (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
3650                     "pandn\t{$src2, $dst|$dst, $src2}", []>;
3651 }
3652 } // Constraints = "$src1 = $dst"
3653
3654 let Predicates = [HasAVX] in {
3655   def : Pat<(int_x86_sse2_psll_dq VR128:$src1, imm:$src2),
3656             (v2i64 (VPSLLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
3657   def : Pat<(int_x86_sse2_psrl_dq VR128:$src1, imm:$src2),
3658             (v2i64 (VPSRLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
3659   def : Pat<(int_x86_sse2_psll_dq_bs VR128:$src1, imm:$src2),
3660             (v2i64 (VPSLLDQri VR128:$src1, imm:$src2))>;
3661   def : Pat<(int_x86_sse2_psrl_dq_bs VR128:$src1, imm:$src2),
3662             (v2i64 (VPSRLDQri VR128:$src1, imm:$src2))>;
3663   def : Pat<(v2f64 (X86fsrl VR128:$src1, i32immSExt8:$src2)),
3664             (v2f64 (VPSRLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
3665
3666   // Shift up / down and insert zero's.
3667   def : Pat<(v2i64 (X86vshl  VR128:$src, (i8 imm:$amt))),
3668             (v2i64 (VPSLLDQri VR128:$src, (BYTE_imm imm:$amt)))>;
3669   def : Pat<(v2i64 (X86vshr  VR128:$src, (i8 imm:$amt))),
3670             (v2i64 (VPSRLDQri VR128:$src, (BYTE_imm imm:$amt)))>;
3671 }
3672
3673 let Predicates = [HasSSE2] in {
3674   def : Pat<(int_x86_sse2_psll_dq VR128:$src1, imm:$src2),
3675             (v2i64 (PSLLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
3676   def : Pat<(int_x86_sse2_psrl_dq VR128:$src1, imm:$src2),
3677             (v2i64 (PSRLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
3678   def : Pat<(int_x86_sse2_psll_dq_bs VR128:$src1, imm:$src2),
3679             (v2i64 (PSLLDQri VR128:$src1, imm:$src2))>;
3680   def : Pat<(int_x86_sse2_psrl_dq_bs VR128:$src1, imm:$src2),
3681             (v2i64 (PSRLDQri VR128:$src1, imm:$src2))>;
3682   def : Pat<(v2f64 (X86fsrl VR128:$src1, i32immSExt8:$src2)),
3683             (v2f64 (PSRLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
3684
3685   // Shift up / down and insert zero's.
3686   def : Pat<(v2i64 (X86vshl  VR128:$src, (i8 imm:$amt))),
3687             (v2i64 (PSLLDQri VR128:$src, (BYTE_imm imm:$amt)))>;
3688   def : Pat<(v2i64 (X86vshr  VR128:$src, (i8 imm:$amt))),
3689             (v2i64 (PSRLDQri VR128:$src, (BYTE_imm imm:$amt)))>;
3690 }
3691
3692 //===---------------------------------------------------------------------===//
3693 // SSE2 - Packed Integer Comparison Instructions
3694 //===---------------------------------------------------------------------===//
3695
3696 let Predicates = [HasAVX] in {
3697   defm VPCMPEQB  : PDI_binop_rm_int<0x74, "vpcmpeqb", int_x86_sse2_pcmpeq_b, 1,
3698                                     0>, VEX_4V;
3699   defm VPCMPEQW  : PDI_binop_rm_int<0x75, "vpcmpeqw", int_x86_sse2_pcmpeq_w, 1,
3700                                     0>, VEX_4V;
3701   defm VPCMPEQD  : PDI_binop_rm_int<0x76, "vpcmpeqd", int_x86_sse2_pcmpeq_d, 1,
3702                                     0>, VEX_4V;
3703   defm VPCMPGTB  : PDI_binop_rm_int<0x64, "vpcmpgtb", int_x86_sse2_pcmpgt_b, 0,
3704                                     0>, VEX_4V;
3705   defm VPCMPGTW  : PDI_binop_rm_int<0x65, "vpcmpgtw", int_x86_sse2_pcmpgt_w, 0,
3706                                     0>, VEX_4V;
3707   defm VPCMPGTD  : PDI_binop_rm_int<0x66, "vpcmpgtd", int_x86_sse2_pcmpgt_d, 0,
3708                                     0>, VEX_4V;
3709
3710   def : Pat<(v16i8 (X86pcmpeqb VR128:$src1, VR128:$src2)),
3711             (VPCMPEQBrr VR128:$src1, VR128:$src2)>;
3712   def : Pat<(v16i8 (X86pcmpeqb VR128:$src1, (memop addr:$src2))),
3713             (VPCMPEQBrm VR128:$src1, addr:$src2)>;
3714   def : Pat<(v8i16 (X86pcmpeqw VR128:$src1, VR128:$src2)),
3715             (VPCMPEQWrr VR128:$src1, VR128:$src2)>;
3716   def : Pat<(v8i16 (X86pcmpeqw VR128:$src1, (memop addr:$src2))),
3717             (VPCMPEQWrm VR128:$src1, addr:$src2)>;
3718   def : Pat<(v4i32 (X86pcmpeqd VR128:$src1, VR128:$src2)),
3719             (VPCMPEQDrr VR128:$src1, VR128:$src2)>;
3720   def : Pat<(v4i32 (X86pcmpeqd VR128:$src1, (memop addr:$src2))),
3721             (VPCMPEQDrm VR128:$src1, addr:$src2)>;
3722
3723   def : Pat<(v16i8 (X86pcmpgtb VR128:$src1, VR128:$src2)),
3724             (VPCMPGTBrr VR128:$src1, VR128:$src2)>;
3725   def : Pat<(v16i8 (X86pcmpgtb VR128:$src1, (memop addr:$src2))),
3726             (VPCMPGTBrm VR128:$src1, addr:$src2)>;
3727   def : Pat<(v8i16 (X86pcmpgtw VR128:$src1, VR128:$src2)),
3728             (VPCMPGTWrr VR128:$src1, VR128:$src2)>;
3729   def : Pat<(v8i16 (X86pcmpgtw VR128:$src1, (memop addr:$src2))),
3730             (VPCMPGTWrm VR128:$src1, addr:$src2)>;
3731   def : Pat<(v4i32 (X86pcmpgtd VR128:$src1, VR128:$src2)),
3732             (VPCMPGTDrr VR128:$src1, VR128:$src2)>;
3733   def : Pat<(v4i32 (X86pcmpgtd VR128:$src1, (memop addr:$src2))),
3734             (VPCMPGTDrm VR128:$src1, addr:$src2)>;
3735 }
3736
3737 let Constraints = "$src1 = $dst" in {
3738   defm PCMPEQB  : PDI_binop_rm_int<0x74, "pcmpeqb", int_x86_sse2_pcmpeq_b, 1>;
3739   defm PCMPEQW  : PDI_binop_rm_int<0x75, "pcmpeqw", int_x86_sse2_pcmpeq_w, 1>;
3740   defm PCMPEQD  : PDI_binop_rm_int<0x76, "pcmpeqd", int_x86_sse2_pcmpeq_d, 1>;
3741   defm PCMPGTB  : PDI_binop_rm_int<0x64, "pcmpgtb", int_x86_sse2_pcmpgt_b>;
3742   defm PCMPGTW  : PDI_binop_rm_int<0x65, "pcmpgtw", int_x86_sse2_pcmpgt_w>;
3743   defm PCMPGTD  : PDI_binop_rm_int<0x66, "pcmpgtd", int_x86_sse2_pcmpgt_d>;
3744 } // Constraints = "$src1 = $dst"
3745
3746 let Predicates = [HasSSE2] in {
3747   def : Pat<(v16i8 (X86pcmpeqb VR128:$src1, VR128:$src2)),
3748             (PCMPEQBrr VR128:$src1, VR128:$src2)>;
3749   def : Pat<(v16i8 (X86pcmpeqb VR128:$src1, (memop addr:$src2))),
3750             (PCMPEQBrm VR128:$src1, addr:$src2)>;
3751   def : Pat<(v8i16 (X86pcmpeqw VR128:$src1, VR128:$src2)),
3752             (PCMPEQWrr VR128:$src1, VR128:$src2)>;
3753   def : Pat<(v8i16 (X86pcmpeqw VR128:$src1, (memop addr:$src2))),
3754             (PCMPEQWrm VR128:$src1, addr:$src2)>;
3755   def : Pat<(v4i32 (X86pcmpeqd VR128:$src1, VR128:$src2)),
3756             (PCMPEQDrr VR128:$src1, VR128:$src2)>;
3757   def : Pat<(v4i32 (X86pcmpeqd VR128:$src1, (memop addr:$src2))),
3758             (PCMPEQDrm VR128:$src1, addr:$src2)>;
3759
3760   def : Pat<(v16i8 (X86pcmpgtb VR128:$src1, VR128:$src2)),
3761             (PCMPGTBrr VR128:$src1, VR128:$src2)>;
3762   def : Pat<(v16i8 (X86pcmpgtb VR128:$src1, (memop addr:$src2))),
3763             (PCMPGTBrm VR128:$src1, addr:$src2)>;
3764   def : Pat<(v8i16 (X86pcmpgtw VR128:$src1, VR128:$src2)),
3765             (PCMPGTWrr VR128:$src1, VR128:$src2)>;
3766   def : Pat<(v8i16 (X86pcmpgtw VR128:$src1, (memop addr:$src2))),
3767             (PCMPGTWrm VR128:$src1, addr:$src2)>;
3768   def : Pat<(v4i32 (X86pcmpgtd VR128:$src1, VR128:$src2)),
3769             (PCMPGTDrr VR128:$src1, VR128:$src2)>;
3770   def : Pat<(v4i32 (X86pcmpgtd VR128:$src1, (memop addr:$src2))),
3771             (PCMPGTDrm VR128:$src1, addr:$src2)>;
3772 }
3773
3774 //===---------------------------------------------------------------------===//
3775 // SSE2 - Packed Integer Pack Instructions
3776 //===---------------------------------------------------------------------===//
3777
3778 let Predicates = [HasAVX] in {
3779 defm VPACKSSWB : PDI_binop_rm_int<0x63, "vpacksswb", int_x86_sse2_packsswb_128,
3780                                   0, 0>, VEX_4V;
3781 defm VPACKSSDW : PDI_binop_rm_int<0x6B, "vpackssdw", int_x86_sse2_packssdw_128,
3782                                   0, 0>, VEX_4V;
3783 defm VPACKUSWB : PDI_binop_rm_int<0x67, "vpackuswb", int_x86_sse2_packuswb_128,
3784                                   0, 0>, VEX_4V;
3785 }
3786
3787 let Constraints = "$src1 = $dst" in {
3788 defm PACKSSWB : PDI_binop_rm_int<0x63, "packsswb", int_x86_sse2_packsswb_128>;
3789 defm PACKSSDW : PDI_binop_rm_int<0x6B, "packssdw", int_x86_sse2_packssdw_128>;
3790 defm PACKUSWB : PDI_binop_rm_int<0x67, "packuswb", int_x86_sse2_packuswb_128>;
3791 } // Constraints = "$src1 = $dst"
3792
3793 //===---------------------------------------------------------------------===//
3794 // SSE2 - Packed Integer Shuffle Instructions
3795 //===---------------------------------------------------------------------===//
3796
3797 let ExeDomain = SSEPackedInt in {
3798 multiclass sse2_pshuffle<string OpcodeStr, ValueType vt, PatFrag pshuf_frag,
3799                          PatFrag bc_frag> {
3800 def ri : Ii8<0x70, MRMSrcReg,
3801               (outs VR128:$dst), (ins VR128:$src1, i8imm:$src2),
3802               !strconcat(OpcodeStr,
3803                          "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3804               [(set VR128:$dst, (vt (pshuf_frag:$src2 VR128:$src1,
3805                                                       (undef))))]>;
3806 def mi : Ii8<0x70, MRMSrcMem,
3807               (outs VR128:$dst), (ins i128mem:$src1, i8imm:$src2),
3808               !strconcat(OpcodeStr,
3809                          "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3810               [(set VR128:$dst, (vt (pshuf_frag:$src2
3811                                       (bc_frag (memopv2i64 addr:$src1)),
3812                                       (undef))))]>;
3813 }
3814 } // ExeDomain = SSEPackedInt
3815
3816 let Predicates = [HasAVX] in {
3817   let AddedComplexity = 5 in
3818   defm VPSHUFD : sse2_pshuffle<"vpshufd", v4i32, pshufd, bc_v4i32>, TB, OpSize,
3819                                VEX;
3820
3821   // SSE2 with ImmT == Imm8 and XS prefix.
3822   defm VPSHUFHW : sse2_pshuffle<"vpshufhw", v8i16, pshufhw, bc_v8i16>, XS,
3823                                VEX;
3824
3825   // SSE2 with ImmT == Imm8 and XD prefix.
3826   defm VPSHUFLW : sse2_pshuffle<"vpshuflw", v8i16, pshuflw, bc_v8i16>, XD,
3827                                VEX;
3828
3829   let AddedComplexity = 5 in
3830   def : Pat<(v4f32 (pshufd:$src2 VR128:$src1, (undef))),
3831             (VPSHUFDri VR128:$src1, (SHUFFLE_get_shuf_imm VR128:$src2))>;
3832   // Unary v4f32 shuffle with VPSHUF* in order to fold a load.
3833   def : Pat<(pshufd:$src2 (bc_v4i32 (memopv4f32 addr:$src1)), (undef)),
3834             (VPSHUFDmi addr:$src1, (SHUFFLE_get_shuf_imm VR128:$src2))>;
3835
3836   def : Pat<(v4i32 (X86PShufd (bc_v4i32 (memopv2i64 addr:$src1)),
3837                                    (i8 imm:$imm))),
3838             (VPSHUFDmi addr:$src1, imm:$imm)>;
3839   def : Pat<(v4i32 (X86PShufd (bc_v4i32 (memopv4f32 addr:$src1)),
3840                                    (i8 imm:$imm))),
3841             (VPSHUFDmi addr:$src1, imm:$imm)>;
3842   def : Pat<(v4f32 (X86PShufd VR128:$src1, (i8 imm:$imm))),
3843             (VPSHUFDri VR128:$src1, imm:$imm)>;
3844   def : Pat<(v4i32 (X86PShufd VR128:$src1, (i8 imm:$imm))),
3845             (VPSHUFDri VR128:$src1, imm:$imm)>;
3846   def : Pat<(v8i16 (X86PShufhw VR128:$src, (i8 imm:$imm))),
3847             (VPSHUFHWri VR128:$src, imm:$imm)>;
3848   def : Pat<(v8i16 (X86PShufhw (bc_v8i16 (memopv2i64 addr:$src)),
3849                                (i8 imm:$imm))),
3850             (VPSHUFHWmi addr:$src, imm:$imm)>;
3851   def : Pat<(v8i16 (X86PShuflw VR128:$src, (i8 imm:$imm))),
3852             (VPSHUFLWri VR128:$src, imm:$imm)>;
3853   def : Pat<(v8i16 (X86PShuflw (bc_v8i16 (memopv2i64 addr:$src)),
3854                                (i8 imm:$imm))),
3855             (VPSHUFLWmi addr:$src, imm:$imm)>;
3856 }
3857
3858 let Predicates = [HasSSE2] in {
3859   let AddedComplexity = 5 in
3860   defm PSHUFD : sse2_pshuffle<"pshufd", v4i32, pshufd, bc_v4i32>, TB, OpSize;
3861
3862   // SSE2 with ImmT == Imm8 and XS prefix.
3863   defm PSHUFHW : sse2_pshuffle<"pshufhw", v8i16, pshufhw, bc_v8i16>, XS;
3864
3865   // SSE2 with ImmT == Imm8 and XD prefix.
3866   defm PSHUFLW : sse2_pshuffle<"pshuflw", v8i16, pshuflw, bc_v8i16>, XD;
3867
3868   let AddedComplexity = 5 in
3869   def : Pat<(v4f32 (pshufd:$src2 VR128:$src1, (undef))),
3870             (PSHUFDri VR128:$src1, (SHUFFLE_get_shuf_imm VR128:$src2))>;
3871   // Unary v4f32 shuffle with PSHUF* in order to fold a load.
3872   def : Pat<(pshufd:$src2 (bc_v4i32 (memopv4f32 addr:$src1)), (undef)),
3873             (PSHUFDmi addr:$src1, (SHUFFLE_get_shuf_imm VR128:$src2))>;
3874
3875   def : Pat<(v4i32 (X86PShufd (bc_v4i32 (memopv2i64 addr:$src1)),
3876                                    (i8 imm:$imm))),
3877             (PSHUFDmi addr:$src1, imm:$imm)>;
3878   def : Pat<(v4i32 (X86PShufd (bc_v4i32 (memopv4f32 addr:$src1)),
3879                                    (i8 imm:$imm))),
3880             (PSHUFDmi addr:$src1, imm:$imm)>;
3881   def : Pat<(v4f32 (X86PShufd VR128:$src1, (i8 imm:$imm))),
3882             (PSHUFDri VR128:$src1, imm:$imm)>;
3883   def : Pat<(v4i32 (X86PShufd VR128:$src1, (i8 imm:$imm))),
3884             (PSHUFDri VR128:$src1, imm:$imm)>;
3885   def : Pat<(v8i16 (X86PShufhw VR128:$src, (i8 imm:$imm))),
3886             (PSHUFHWri VR128:$src, imm:$imm)>;
3887   def : Pat<(v8i16 (X86PShufhw (bc_v8i16 (memopv2i64 addr:$src)),
3888                                (i8 imm:$imm))),
3889             (PSHUFHWmi addr:$src, imm:$imm)>;
3890   def : Pat<(v8i16 (X86PShuflw VR128:$src, (i8 imm:$imm))),
3891             (PSHUFLWri VR128:$src, imm:$imm)>;
3892   def : Pat<(v8i16 (X86PShuflw (bc_v8i16 (memopv2i64 addr:$src)),
3893                                (i8 imm:$imm))),
3894             (PSHUFLWmi addr:$src, imm:$imm)>;
3895 }
3896
3897 //===---------------------------------------------------------------------===//
3898 // SSE2 - Packed Integer Unpack Instructions
3899 //===---------------------------------------------------------------------===//
3900
3901 let ExeDomain = SSEPackedInt in {
3902 multiclass sse2_unpack<bits<8> opc, string OpcodeStr, ValueType vt,
3903                        SDNode OpNode, PatFrag bc_frag, bit Is2Addr = 1> {
3904   def rr : PDI<opc, MRMSrcReg,
3905       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3906       !if(Is2Addr,
3907           !strconcat(OpcodeStr,"\t{$src2, $dst|$dst, $src2}"),
3908           !strconcat(OpcodeStr,"\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3909       [(set VR128:$dst, (vt (OpNode VR128:$src1, VR128:$src2)))]>;
3910   def rm : PDI<opc, MRMSrcMem,
3911       (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
3912       !if(Is2Addr,
3913           !strconcat(OpcodeStr,"\t{$src2, $dst|$dst, $src2}"),
3914           !strconcat(OpcodeStr,"\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
3915       [(set VR128:$dst, (OpNode VR128:$src1,
3916                                   (bc_frag (memopv2i64
3917                                                addr:$src2))))]>;
3918 }
3919
3920 let Predicates = [HasAVX] in {
3921   defm VPUNPCKLBW  : sse2_unpack<0x60, "vpunpcklbw", v16i8, X86Punpcklbw,
3922                                  bc_v16i8, 0>, VEX_4V;
3923   defm VPUNPCKLWD  : sse2_unpack<0x61, "vpunpcklwd", v8i16, X86Punpcklwd,
3924                                  bc_v8i16, 0>, VEX_4V;
3925   defm VPUNPCKLDQ  : sse2_unpack<0x62, "vpunpckldq", v4i32, X86Punpckldq,
3926                                  bc_v4i32, 0>, VEX_4V;
3927
3928   /// FIXME: we could eliminate this and use sse2_unpack instead if tblgen
3929   /// knew to collapse (bitconvert VT to VT) into its operand.
3930   def VPUNPCKLQDQrr : PDI<0x6C, MRMSrcReg,
3931             (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3932             "vpunpcklqdq\t{$src2, $src1, $dst|$dst, $src1, $src2}",
3933             [(set VR128:$dst, (v2i64 (X86Punpcklqdq VR128:$src1,
3934                                                     VR128:$src2)))]>, VEX_4V;
3935   def VPUNPCKLQDQrm : PDI<0x6C, MRMSrcMem,
3936             (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
3937             "vpunpcklqdq\t{$src2, $src1, $dst|$dst, $src1, $src2}",
3938             [(set VR128:$dst, (v2i64 (X86Punpcklqdq VR128:$src1,
3939                                         (memopv2i64 addr:$src2))))]>, VEX_4V;
3940
3941   defm VPUNPCKHBW  : sse2_unpack<0x68, "vpunpckhbw", v16i8, X86Punpckhbw,
3942                                  bc_v16i8, 0>, VEX_4V;
3943   defm VPUNPCKHWD  : sse2_unpack<0x69, "vpunpckhwd", v8i16, X86Punpckhwd,
3944                                  bc_v8i16, 0>, VEX_4V;
3945   defm VPUNPCKHDQ  : sse2_unpack<0x6A, "vpunpckhdq", v4i32, X86Punpckhdq,
3946                                  bc_v4i32, 0>, VEX_4V;
3947
3948   /// FIXME: we could eliminate this and use sse2_unpack instead if tblgen
3949   /// knew to collapse (bitconvert VT to VT) into its operand.
3950   def VPUNPCKHQDQrr : PDI<0x6D, MRMSrcReg,
3951              (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3952              "vpunpckhqdq\t{$src2, $src1, $dst|$dst, $src1, $src2}",
3953              [(set VR128:$dst, (v2i64 (X86Punpckhqdq VR128:$src1,
3954                                                      VR128:$src2)))]>, VEX_4V;
3955   def VPUNPCKHQDQrm : PDI<0x6D, MRMSrcMem,
3956              (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
3957              "vpunpckhqdq\t{$src2, $src1, $dst|$dst, $src1, $src2}",
3958              [(set VR128:$dst, (v2i64 (X86Punpckhqdq VR128:$src1,
3959                                         (memopv2i64 addr:$src2))))]>, VEX_4V;
3960 }
3961
3962 let Constraints = "$src1 = $dst" in {
3963   defm PUNPCKLBW  : sse2_unpack<0x60, "punpcklbw", v16i8, X86Punpcklbw, bc_v16i8>;
3964   defm PUNPCKLWD  : sse2_unpack<0x61, "punpcklwd", v8i16, X86Punpcklwd, bc_v8i16>;
3965   defm PUNPCKLDQ  : sse2_unpack<0x62, "punpckldq", v4i32, X86Punpckldq, bc_v4i32>;
3966
3967   /// FIXME: we could eliminate this and use sse2_unpack instead if tblgen
3968   /// knew to collapse (bitconvert VT to VT) into its operand.
3969   def PUNPCKLQDQrr : PDI<0x6C, MRMSrcReg,
3970                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3971                          "punpcklqdq\t{$src2, $dst|$dst, $src2}",
3972                         [(set VR128:$dst,
3973                           (v2i64 (X86Punpcklqdq VR128:$src1, VR128:$src2)))]>;
3974   def PUNPCKLQDQrm : PDI<0x6C, MRMSrcMem,
3975                          (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
3976                          "punpcklqdq\t{$src2, $dst|$dst, $src2}",
3977                         [(set VR128:$dst,
3978                           (v2i64 (X86Punpcklqdq VR128:$src1,
3979                                          (memopv2i64 addr:$src2))))]>;
3980
3981   defm PUNPCKHBW  : sse2_unpack<0x68, "punpckhbw", v16i8, X86Punpckhbw, bc_v16i8>;
3982   defm PUNPCKHWD  : sse2_unpack<0x69, "punpckhwd", v8i16, X86Punpckhwd, bc_v8i16>;
3983   defm PUNPCKHDQ  : sse2_unpack<0x6A, "punpckhdq", v4i32, X86Punpckhdq, bc_v4i32>;
3984
3985   /// FIXME: we could eliminate this and use sse2_unpack instead if tblgen
3986   /// knew to collapse (bitconvert VT to VT) into its operand.
3987   def PUNPCKHQDQrr : PDI<0x6D, MRMSrcReg,
3988                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
3989                          "punpckhqdq\t{$src2, $dst|$dst, $src2}",
3990                         [(set VR128:$dst,
3991                           (v2i64 (X86Punpckhqdq VR128:$src1, VR128:$src2)))]>;
3992   def PUNPCKHQDQrm : PDI<0x6D, MRMSrcMem,
3993                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
3994                         "punpckhqdq\t{$src2, $dst|$dst, $src2}",
3995                         [(set VR128:$dst,
3996                           (v2i64 (X86Punpckhqdq VR128:$src1,
3997                                          (memopv2i64 addr:$src2))))]>;
3998 }
3999 } // ExeDomain = SSEPackedInt
4000
4001 // Splat v2f64 / v2i64
4002 let AddedComplexity = 10 in {
4003   def : Pat<(splat_lo (v2i64 VR128:$src), (undef)),
4004             (PUNPCKLQDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
4005   def : Pat<(splat_lo (v2i64 VR128:$src), (undef)),
4006             (VPUNPCKLQDQrr VR128:$src, VR128:$src)>, Requires<[HasAVX]>;
4007 }
4008
4009 //===---------------------------------------------------------------------===//
4010 // SSE2 - Packed Integer Extract and Insert
4011 //===---------------------------------------------------------------------===//
4012
4013 let ExeDomain = SSEPackedInt in {
4014 multiclass sse2_pinsrw<bit Is2Addr = 1> {
4015   def rri : Ii8<0xC4, MRMSrcReg,
4016        (outs VR128:$dst), (ins VR128:$src1,
4017         GR32:$src2, i32i8imm:$src3),
4018        !if(Is2Addr,
4019            "pinsrw\t{$src3, $src2, $dst|$dst, $src2, $src3}",
4020            "vpinsrw\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
4021        [(set VR128:$dst,
4022          (X86pinsrw VR128:$src1, GR32:$src2, imm:$src3))]>;
4023   def rmi : Ii8<0xC4, MRMSrcMem,
4024                        (outs VR128:$dst), (ins VR128:$src1,
4025                         i16mem:$src2, i32i8imm:$src3),
4026        !if(Is2Addr,
4027            "pinsrw\t{$src3, $src2, $dst|$dst, $src2, $src3}",
4028            "vpinsrw\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
4029        [(set VR128:$dst,
4030          (X86pinsrw VR128:$src1, (extloadi16 addr:$src2),
4031                     imm:$src3))]>;
4032 }
4033
4034 // Extract
4035 let Predicates = [HasAVX] in
4036 def VPEXTRWri : Ii8<0xC5, MRMSrcReg,
4037                     (outs GR32:$dst), (ins VR128:$src1, i32i8imm:$src2),
4038                     "vpextrw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4039                     [(set GR32:$dst, (X86pextrw (v8i16 VR128:$src1),
4040                                                 imm:$src2))]>, TB, OpSize, VEX;
4041 def PEXTRWri : PDIi8<0xC5, MRMSrcReg,
4042                     (outs GR32:$dst), (ins VR128:$src1, i32i8imm:$src2),
4043                     "pextrw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
4044                     [(set GR32:$dst, (X86pextrw (v8i16 VR128:$src1),
4045                                                 imm:$src2))]>;
4046
4047 // Insert
4048 let Predicates = [HasAVX] in {
4049   defm VPINSRW : sse2_pinsrw<0>, TB, OpSize, VEX_4V;
4050   def  VPINSRWrr64i : Ii8<0xC4, MRMSrcReg, (outs VR128:$dst),
4051        (ins VR128:$src1, GR64:$src2, i32i8imm:$src3),
4052        "vpinsrw\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
4053        []>, TB, OpSize, VEX_4V;
4054 }
4055
4056 let Constraints = "$src1 = $dst" in
4057   defm PINSRW : sse2_pinsrw, TB, OpSize, Requires<[HasSSE2]>;
4058
4059 } // ExeDomain = SSEPackedInt
4060
4061 //===---------------------------------------------------------------------===//
4062 // SSE2 - Packed Mask Creation
4063 //===---------------------------------------------------------------------===//
4064
4065 let ExeDomain = SSEPackedInt in {
4066
4067 def VPMOVMSKBrr  : VPDI<0xD7, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
4068            "pmovmskb\t{$src, $dst|$dst, $src}",
4069            [(set GR32:$dst, (int_x86_sse2_pmovmskb_128 VR128:$src))]>, VEX;
4070 def VPMOVMSKBr64r : VPDI<0xD7, MRMSrcReg, (outs GR64:$dst), (ins VR128:$src),
4071            "pmovmskb\t{$src, $dst|$dst, $src}", []>, VEX;
4072 def PMOVMSKBrr : PDI<0xD7, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
4073            "pmovmskb\t{$src, $dst|$dst, $src}",
4074            [(set GR32:$dst, (int_x86_sse2_pmovmskb_128 VR128:$src))]>;
4075
4076 } // ExeDomain = SSEPackedInt
4077
4078 //===---------------------------------------------------------------------===//
4079 // SSE2 - Conditional Store
4080 //===---------------------------------------------------------------------===//
4081
4082 let ExeDomain = SSEPackedInt in {
4083
4084 let Uses = [EDI] in
4085 def VMASKMOVDQU : VPDI<0xF7, MRMSrcReg, (outs),
4086            (ins VR128:$src, VR128:$mask),
4087            "maskmovdqu\t{$mask, $src|$src, $mask}",
4088            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, EDI)]>, VEX;
4089 let Uses = [RDI] in
4090 def VMASKMOVDQU64 : VPDI<0xF7, MRMSrcReg, (outs),
4091            (ins VR128:$src, VR128:$mask),
4092            "maskmovdqu\t{$mask, $src|$src, $mask}",
4093            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, RDI)]>, VEX;
4094
4095 let Uses = [EDI] in
4096 def MASKMOVDQU : PDI<0xF7, MRMSrcReg, (outs), (ins VR128:$src, VR128:$mask),
4097            "maskmovdqu\t{$mask, $src|$src, $mask}",
4098            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, EDI)]>;
4099 let Uses = [RDI] in
4100 def MASKMOVDQU64 : PDI<0xF7, MRMSrcReg, (outs), (ins VR128:$src, VR128:$mask),
4101            "maskmovdqu\t{$mask, $src|$src, $mask}",
4102            [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, RDI)]>;
4103
4104 } // ExeDomain = SSEPackedInt
4105
4106 //===---------------------------------------------------------------------===//
4107 // SSE2 - Move Doubleword
4108 //===---------------------------------------------------------------------===//
4109
4110 //===---------------------------------------------------------------------===//
4111 // Move Int Doubleword to Packed Double Int
4112 //
4113 def VMOVDI2PDIrr : VPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
4114                       "movd\t{$src, $dst|$dst, $src}",
4115                       [(set VR128:$dst,
4116                         (v4i32 (scalar_to_vector GR32:$src)))]>, VEX;
4117 def VMOVDI2PDIrm : VPDI<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
4118                       "movd\t{$src, $dst|$dst, $src}",
4119                       [(set VR128:$dst,
4120                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))]>,
4121                       VEX;
4122 def VMOV64toPQIrr : VRPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
4123                         "mov{d|q}\t{$src, $dst|$dst, $src}",
4124                         [(set VR128:$dst,
4125                           (v2i64 (scalar_to_vector GR64:$src)))]>, VEX;
4126 def VMOV64toSDrr : VRPDI<0x6E, MRMSrcReg, (outs FR64:$dst), (ins GR64:$src),
4127                        "mov{d|q}\t{$src, $dst|$dst, $src}",
4128                        [(set FR64:$dst, (bitconvert GR64:$src))]>, VEX;
4129
4130 def MOVDI2PDIrr : PDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
4131                       "movd\t{$src, $dst|$dst, $src}",
4132                       [(set VR128:$dst,
4133                         (v4i32 (scalar_to_vector GR32:$src)))]>;
4134 def MOVDI2PDIrm : PDI<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
4135                       "movd\t{$src, $dst|$dst, $src}",
4136                       [(set VR128:$dst,
4137                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))]>;
4138 def MOV64toPQIrr : RPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
4139                         "mov{d|q}\t{$src, $dst|$dst, $src}",
4140                         [(set VR128:$dst,
4141                           (v2i64 (scalar_to_vector GR64:$src)))]>;
4142 def MOV64toSDrr : RPDI<0x6E, MRMSrcReg, (outs FR64:$dst), (ins GR64:$src),
4143                        "mov{d|q}\t{$src, $dst|$dst, $src}",
4144                        [(set FR64:$dst, (bitconvert GR64:$src))]>;
4145
4146 //===---------------------------------------------------------------------===//
4147 // Move Int Doubleword to Single Scalar
4148 //
4149 def VMOVDI2SSrr  : VPDI<0x6E, MRMSrcReg, (outs FR32:$dst), (ins GR32:$src),
4150                       "movd\t{$src, $dst|$dst, $src}",
4151                       [(set FR32:$dst, (bitconvert GR32:$src))]>, VEX;
4152
4153 def VMOVDI2SSrm  : VPDI<0x6E, MRMSrcMem, (outs FR32:$dst), (ins i32mem:$src),
4154                       "movd\t{$src, $dst|$dst, $src}",
4155                       [(set FR32:$dst, (bitconvert (loadi32 addr:$src)))]>,
4156                       VEX;
4157 def MOVDI2SSrr  : PDI<0x6E, MRMSrcReg, (outs FR32:$dst), (ins GR32:$src),
4158                       "movd\t{$src, $dst|$dst, $src}",
4159                       [(set FR32:$dst, (bitconvert GR32:$src))]>;
4160
4161 def MOVDI2SSrm  : PDI<0x6E, MRMSrcMem, (outs FR32:$dst), (ins i32mem:$src),
4162                       "movd\t{$src, $dst|$dst, $src}",
4163                       [(set FR32:$dst, (bitconvert (loadi32 addr:$src)))]>;
4164
4165 //===---------------------------------------------------------------------===//
4166 // Move Packed Doubleword Int to Packed Double Int
4167 //
4168 def VMOVPDI2DIrr  : VPDI<0x7E, MRMDestReg, (outs GR32:$dst), (ins VR128:$src),
4169                        "movd\t{$src, $dst|$dst, $src}",
4170                        [(set GR32:$dst, (vector_extract (v4i32 VR128:$src),
4171                                         (iPTR 0)))]>, VEX;
4172 def VMOVPDI2DImr  : VPDI<0x7E, MRMDestMem, (outs),
4173                        (ins i32mem:$dst, VR128:$src),
4174                        "movd\t{$src, $dst|$dst, $src}",
4175                        [(store (i32 (vector_extract (v4i32 VR128:$src),
4176                                      (iPTR 0))), addr:$dst)]>, VEX;
4177 def MOVPDI2DIrr  : PDI<0x7E, MRMDestReg, (outs GR32:$dst), (ins VR128:$src),
4178                        "movd\t{$src, $dst|$dst, $src}",
4179                        [(set GR32:$dst, (vector_extract (v4i32 VR128:$src),
4180                                         (iPTR 0)))]>;
4181 def MOVPDI2DImr  : PDI<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, VR128:$src),
4182                        "movd\t{$src, $dst|$dst, $src}",
4183                        [(store (i32 (vector_extract (v4i32 VR128:$src),
4184                                      (iPTR 0))), addr:$dst)]>;
4185
4186 //===---------------------------------------------------------------------===//
4187 // Move Packed Doubleword Int first element to Doubleword Int
4188 //
4189 let isCodeGenOnly = 1 in
4190 def VMOVPQIto64rr : VRPDI<0x7E, MRMDestReg, (outs GR64:$dst), (ins VR128:$src),
4191                           "mov{d|q}\t{$src, $dst|$dst, $src}",
4192                           [(set GR64:$dst, (vector_extract (v2i64 VR128:$src),
4193                                                            (iPTR 0)))]>;
4194
4195 def MOVPQIto64rr : RPDI<0x7E, MRMDestReg, (outs GR64:$dst), (ins VR128:$src),
4196                         "mov{d|q}\t{$src, $dst|$dst, $src}",
4197                         [(set GR64:$dst, (vector_extract (v2i64 VR128:$src),
4198                                                          (iPTR 0)))]>;
4199
4200 //===---------------------------------------------------------------------===//
4201 // Bitcast FR64 <-> GR64
4202 //
4203 let Predicates = [HasAVX] in
4204 def VMOV64toSDrm : S3SI<0x7E, MRMSrcMem, (outs FR64:$dst), (ins i64mem:$src),
4205                         "vmovq\t{$src, $dst|$dst, $src}",
4206                         [(set FR64:$dst, (bitconvert (loadi64 addr:$src)))]>,
4207                         VEX;
4208 def VMOVSDto64rr : VRPDI<0x7E, MRMDestReg, (outs GR64:$dst), (ins FR64:$src),
4209                          "mov{d|q}\t{$src, $dst|$dst, $src}",
4210                          [(set GR64:$dst, (bitconvert FR64:$src))]>;
4211 def VMOVSDto64mr : VRPDI<0x7E, MRMDestMem, (outs), (ins i64mem:$dst, FR64:$src),
4212                          "movq\t{$src, $dst|$dst, $src}",
4213                          [(store (i64 (bitconvert FR64:$src)), addr:$dst)]>;
4214
4215 def MOV64toSDrm : S3SI<0x7E, MRMSrcMem, (outs FR64:$dst), (ins i64mem:$src),
4216                        "movq\t{$src, $dst|$dst, $src}",
4217                        [(set FR64:$dst, (bitconvert (loadi64 addr:$src)))]>;
4218 def MOVSDto64rr : RPDI<0x7E, MRMDestReg, (outs GR64:$dst), (ins FR64:$src),
4219                        "mov{d|q}\t{$src, $dst|$dst, $src}",
4220                        [(set GR64:$dst, (bitconvert FR64:$src))]>;
4221 def MOVSDto64mr : RPDI<0x7E, MRMDestMem, (outs), (ins i64mem:$dst, FR64:$src),
4222                        "movq\t{$src, $dst|$dst, $src}",
4223                        [(store (i64 (bitconvert FR64:$src)), addr:$dst)]>;
4224
4225 //===---------------------------------------------------------------------===//
4226 // Move Scalar Single to Double Int
4227 //
4228 def VMOVSS2DIrr  : VPDI<0x7E, MRMDestReg, (outs GR32:$dst), (ins FR32:$src),
4229                       "movd\t{$src, $dst|$dst, $src}",
4230                       [(set GR32:$dst, (bitconvert FR32:$src))]>, VEX;
4231 def VMOVSS2DImr  : VPDI<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, FR32:$src),
4232                       "movd\t{$src, $dst|$dst, $src}",
4233                       [(store (i32 (bitconvert FR32:$src)), addr:$dst)]>, VEX;
4234 def MOVSS2DIrr  : PDI<0x7E, MRMDestReg, (outs GR32:$dst), (ins FR32:$src),
4235                       "movd\t{$src, $dst|$dst, $src}",
4236                       [(set GR32:$dst, (bitconvert FR32:$src))]>;
4237 def MOVSS2DImr  : PDI<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, FR32:$src),
4238                       "movd\t{$src, $dst|$dst, $src}",
4239                       [(store (i32 (bitconvert FR32:$src)), addr:$dst)]>;
4240
4241 //===---------------------------------------------------------------------===//
4242 // Patterns and instructions to describe movd/movq to XMM register zero-extends
4243 //
4244 let AddedComplexity = 15 in {
4245 def VMOVZDI2PDIrr : VPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
4246                        "movd\t{$src, $dst|$dst, $src}",
4247                        [(set VR128:$dst, (v4i32 (X86vzmovl
4248                                       (v4i32 (scalar_to_vector GR32:$src)))))]>,
4249                                       VEX;
4250 def VMOVZQI2PQIrr : VPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
4251                        "mov{d|q}\t{$src, $dst|$dst, $src}", // X86-64 only
4252                        [(set VR128:$dst, (v2i64 (X86vzmovl
4253                                       (v2i64 (scalar_to_vector GR64:$src)))))]>,
4254                                       VEX, VEX_W;
4255 }
4256 let AddedComplexity = 15 in {
4257 def MOVZDI2PDIrr : PDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
4258                        "movd\t{$src, $dst|$dst, $src}",
4259                        [(set VR128:$dst, (v4i32 (X86vzmovl
4260                                       (v4i32 (scalar_to_vector GR32:$src)))))]>;
4261 def MOVZQI2PQIrr : RPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
4262                        "mov{d|q}\t{$src, $dst|$dst, $src}", // X86-64 only
4263                        [(set VR128:$dst, (v2i64 (X86vzmovl
4264                                       (v2i64 (scalar_to_vector GR64:$src)))))]>;
4265 }
4266
4267 let AddedComplexity = 20 in {
4268 def VMOVZDI2PDIrm : VPDI<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
4269                        "movd\t{$src, $dst|$dst, $src}",
4270                        [(set VR128:$dst,
4271                          (v4i32 (X86vzmovl (v4i32 (scalar_to_vector
4272                                                    (loadi32 addr:$src))))))]>,
4273                                                    VEX;
4274 def MOVZDI2PDIrm : PDI<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
4275                        "movd\t{$src, $dst|$dst, $src}",
4276                        [(set VR128:$dst,
4277                          (v4i32 (X86vzmovl (v4i32 (scalar_to_vector
4278                                                    (loadi32 addr:$src))))))]>;
4279 }
4280
4281 let Predicates = [HasSSE2], AddedComplexity = 20 in {
4282   def : Pat<(v4i32 (X86vzmovl (loadv4i32 addr:$src))),
4283             (MOVZDI2PDIrm addr:$src)>;
4284   def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv4f32 addr:$src)))),
4285             (MOVZDI2PDIrm addr:$src)>;
4286   def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv2i64 addr:$src)))),
4287             (MOVZDI2PDIrm addr:$src)>;
4288 }
4289
4290 let Predicates = [HasAVX] in {
4291   // AVX 128-bit movd/movq instruction write zeros in the high 128-bit part.
4292   let AddedComplexity = 20 in {
4293     def : Pat<(v4i32 (X86vzmovl (loadv4i32 addr:$src))),
4294               (VMOVZDI2PDIrm addr:$src)>;
4295     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv4f32 addr:$src)))),
4296               (VMOVZDI2PDIrm addr:$src)>;
4297     def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv2i64 addr:$src)))),
4298               (VMOVZDI2PDIrm addr:$src)>;
4299   }
4300   // Use regular 128-bit instructions to match 256-bit scalar_to_vec+zext.
4301   def : Pat<(v8i32 (X86vzmovl (insert_subvector undef,
4302                                 (v4i32 (scalar_to_vector GR32:$src)),(i32 0)))),
4303             (SUBREG_TO_REG (i32 0), (VMOVZDI2PDIrr GR32:$src), sub_xmm)>;
4304   def : Pat<(v4i64 (X86vzmovl (insert_subvector undef,
4305                                 (v2i64 (scalar_to_vector GR64:$src)),(i32 0)))),
4306             (SUBREG_TO_REG (i64 0), (VMOVZQI2PQIrr GR64:$src), sub_xmm)>;
4307 }
4308
4309 // These are the correct encodings of the instructions so that we know how to
4310 // read correct assembly, even though we continue to emit the wrong ones for
4311 // compatibility with Darwin's buggy assembler.
4312 def : InstAlias<"movq\t{$src, $dst|$dst, $src}",
4313                 (MOV64toPQIrr VR128:$dst, GR64:$src), 0>;
4314 def : InstAlias<"movq\t{$src, $dst|$dst, $src}",
4315                 (MOV64toSDrr FR64:$dst, GR64:$src), 0>;
4316 def : InstAlias<"movq\t{$src, $dst|$dst, $src}",
4317                 (MOVPQIto64rr GR64:$dst, VR128:$src), 0>;
4318 def : InstAlias<"movq\t{$src, $dst|$dst, $src}",
4319                 (MOVSDto64rr GR64:$dst, FR64:$src), 0>;
4320 def : InstAlias<"movq\t{$src, $dst|$dst, $src}",
4321                 (VMOVZQI2PQIrr VR128:$dst, GR64:$src), 0>;
4322 def : InstAlias<"movq\t{$src, $dst|$dst, $src}",
4323                 (MOVZQI2PQIrr VR128:$dst, GR64:$src), 0>;
4324
4325 //===---------------------------------------------------------------------===//
4326 // SSE2 - Move Quadword
4327 //===---------------------------------------------------------------------===//
4328
4329 //===---------------------------------------------------------------------===//
4330 // Move Quadword Int to Packed Quadword Int
4331 //
4332 def VMOVQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4333                     "vmovq\t{$src, $dst|$dst, $src}",
4334                     [(set VR128:$dst,
4335                       (v2i64 (scalar_to_vector (loadi64 addr:$src))))]>, XS,
4336                     VEX, Requires<[HasAVX]>;
4337 def MOVQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4338                     "movq\t{$src, $dst|$dst, $src}",
4339                     [(set VR128:$dst,
4340                       (v2i64 (scalar_to_vector (loadi64 addr:$src))))]>, XS,
4341                     Requires<[HasSSE2]>; // SSE2 instruction with XS Prefix
4342
4343 //===---------------------------------------------------------------------===//
4344 // Move Packed Quadword Int to Quadword Int
4345 //
4346 def VMOVPQI2QImr : VPDI<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
4347                       "movq\t{$src, $dst|$dst, $src}",
4348                       [(store (i64 (vector_extract (v2i64 VR128:$src),
4349                                     (iPTR 0))), addr:$dst)]>, VEX;
4350 def MOVPQI2QImr : PDI<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
4351                       "movq\t{$src, $dst|$dst, $src}",
4352                       [(store (i64 (vector_extract (v2i64 VR128:$src),
4353                                     (iPTR 0))), addr:$dst)]>;
4354
4355 //===---------------------------------------------------------------------===//
4356 // Store / copy lower 64-bits of a XMM register.
4357 //
4358 def VMOVLQ128mr : VPDI<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
4359                      "movq\t{$src, $dst|$dst, $src}",
4360                      [(int_x86_sse2_storel_dq addr:$dst, VR128:$src)]>, VEX;
4361 def MOVLQ128mr : PDI<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
4362                      "movq\t{$src, $dst|$dst, $src}",
4363                      [(int_x86_sse2_storel_dq addr:$dst, VR128:$src)]>;
4364
4365 let AddedComplexity = 20 in
4366 def VMOVZQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4367                      "vmovq\t{$src, $dst|$dst, $src}",
4368                      [(set VR128:$dst,
4369                        (v2i64 (X86vzmovl (v2i64 (scalar_to_vector
4370                                                  (loadi64 addr:$src))))))]>,
4371                      XS, VEX, Requires<[HasAVX]>;
4372
4373 let AddedComplexity = 20 in
4374 def MOVZQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
4375                      "movq\t{$src, $dst|$dst, $src}",
4376                      [(set VR128:$dst,
4377                        (v2i64 (X86vzmovl (v2i64 (scalar_to_vector
4378                                                  (loadi64 addr:$src))))))]>,
4379                      XS, Requires<[HasSSE2]>;
4380
4381 let Predicates = [HasSSE2], AddedComplexity = 20 in {
4382   def : Pat<(v2i64 (X86vzmovl (loadv2i64 addr:$src))),
4383             (MOVZQI2PQIrm addr:$src)>;
4384   def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4f32 addr:$src)))),
4385             (MOVZQI2PQIrm addr:$src)>;
4386   def : Pat<(v2i64 (X86vzload addr:$src)), (MOVZQI2PQIrm addr:$src)>;
4387 }
4388
4389 let Predicates = [HasAVX], AddedComplexity = 20 in {
4390   def : Pat<(v2i64 (X86vzmovl (loadv2i64 addr:$src))),
4391             (VMOVZQI2PQIrm addr:$src)>;
4392   def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4f32 addr:$src)))),
4393             (VMOVZQI2PQIrm addr:$src)>;
4394   def : Pat<(v2i64 (X86vzload addr:$src)),
4395             (VMOVZQI2PQIrm addr:$src)>;
4396 }
4397
4398 //===---------------------------------------------------------------------===//
4399 // Moving from XMM to XMM and clear upper 64 bits. Note, there is a bug in
4400 // IA32 document. movq xmm1, xmm2 does clear the high bits.
4401 //
4402 let AddedComplexity = 15 in
4403 def VMOVZPQILo2PQIrr : I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4404                         "vmovq\t{$src, $dst|$dst, $src}",
4405                     [(set VR128:$dst, (v2i64 (X86vzmovl (v2i64 VR128:$src))))]>,
4406                       XS, VEX, Requires<[HasAVX]>;
4407 let AddedComplexity = 15 in
4408 def MOVZPQILo2PQIrr : I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4409                         "movq\t{$src, $dst|$dst, $src}",
4410                     [(set VR128:$dst, (v2i64 (X86vzmovl (v2i64 VR128:$src))))]>,
4411                       XS, Requires<[HasSSE2]>;
4412
4413 let AddedComplexity = 20 in
4414 def VMOVZPQILo2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
4415                         "vmovq\t{$src, $dst|$dst, $src}",
4416                     [(set VR128:$dst, (v2i64 (X86vzmovl
4417                                              (loadv2i64 addr:$src))))]>,
4418                       XS, VEX, Requires<[HasAVX]>;
4419 let AddedComplexity = 20 in {
4420 def MOVZPQILo2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
4421                         "movq\t{$src, $dst|$dst, $src}",
4422                     [(set VR128:$dst, (v2i64 (X86vzmovl
4423                                              (loadv2i64 addr:$src))))]>,
4424                       XS, Requires<[HasSSE2]>;
4425 }
4426
4427 let AddedComplexity = 20 in {
4428   let Predicates = [HasSSE2] in {
4429     def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4i32 addr:$src)))),
4430               (MOVZPQILo2PQIrm addr:$src)>;
4431     def : Pat<(v2f64 (X86vzmovl (v2f64 VR128:$src))),
4432               (MOVZPQILo2PQIrr VR128:$src)>;
4433   }
4434   let Predicates = [HasAVX] in {
4435     def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4i32 addr:$src)))),
4436               (VMOVZPQILo2PQIrm addr:$src)>;
4437     def : Pat<(v2f64 (X86vzmovl (v2f64 VR128:$src))),
4438               (VMOVZPQILo2PQIrr VR128:$src)>;
4439   }
4440 }
4441
4442 // Instructions to match in the assembler
4443 def VMOVQs64rr : VPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
4444                       "movq\t{$src, $dst|$dst, $src}", []>, VEX, VEX_W;
4445 def VMOVQd64rr : VPDI<0x7E, MRMDestReg, (outs GR64:$dst), (ins VR128:$src),
4446                       "movq\t{$src, $dst|$dst, $src}", []>, VEX, VEX_W;
4447 // Recognize "movd" with GR64 destination, but encode as a "movq"
4448 def VMOVQd64rr_alt : VPDI<0x7E, MRMDestReg, (outs GR64:$dst), (ins VR128:$src),
4449                           "movd\t{$src, $dst|$dst, $src}", []>, VEX, VEX_W;
4450
4451 // Instructions for the disassembler
4452 // xr = XMM register
4453 // xm = mem64
4454
4455 let Predicates = [HasAVX] in
4456 def VMOVQxrxr: I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4457                  "vmovq\t{$src, $dst|$dst, $src}", []>, VEX, XS;
4458 def MOVQxrxr : I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4459                  "movq\t{$src, $dst|$dst, $src}", []>, XS;
4460
4461 //===---------------------------------------------------------------------===//
4462 // SSE3 - Conversion Instructions
4463 //===---------------------------------------------------------------------===//
4464
4465 // Convert Packed Double FP to Packed DW Integers
4466 let Predicates = [HasAVX] in {
4467 // The assembler can recognize rr 256-bit instructions by seeing a ymm
4468 // register, but the same isn't true when using memory operands instead.
4469 // Provide other assembly rr and rm forms to address this explicitly.
4470 def VCVTPD2DQrr  : S3DI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4471                        "vcvtpd2dq\t{$src, $dst|$dst, $src}", []>, VEX;
4472 def VCVTPD2DQXrYr  : S3DI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
4473                        "vcvtpd2dq\t{$src, $dst|$dst, $src}", []>, VEX;
4474
4475 // XMM only
4476 def VCVTPD2DQXrr : S3DI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4477                       "vcvtpd2dqx\t{$src, $dst|$dst, $src}", []>, VEX;
4478 def VCVTPD2DQXrm : S3DI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
4479                       "vcvtpd2dqx\t{$src, $dst|$dst, $src}", []>, VEX;
4480
4481 // YMM only
4482 def VCVTPD2DQYrr : S3DI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
4483                       "vcvtpd2dqy\t{$src, $dst|$dst, $src}", []>, VEX;
4484 def VCVTPD2DQYrm : S3DI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
4485                       "vcvtpd2dqy\t{$src, $dst|$dst, $src}", []>, VEX, VEX_L;
4486 }
4487
4488 def CVTPD2DQrm  : S3DI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
4489                        "cvtpd2dq\t{$src, $dst|$dst, $src}", []>;
4490 def CVTPD2DQrr  : S3DI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4491                        "cvtpd2dq\t{$src, $dst|$dst, $src}", []>;
4492
4493 def : Pat<(v4i32 (fp_to_sint (v4f64 VR256:$src))),
4494           (VCVTPD2DQYrr VR256:$src)>;
4495 def : Pat<(v4i32 (fp_to_sint (memopv4f64 addr:$src))),
4496           (VCVTPD2DQYrm addr:$src)>;
4497
4498 // Convert Packed DW Integers to Packed Double FP
4499 let Predicates = [HasAVX] in {
4500 def VCVTDQ2PDrm  : S3SI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
4501                      "vcvtdq2pd\t{$src, $dst|$dst, $src}", []>, VEX;
4502 def VCVTDQ2PDrr  : S3SI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4503                      "vcvtdq2pd\t{$src, $dst|$dst, $src}", []>, VEX;
4504 def VCVTDQ2PDYrm  : S3SI<0xE6, MRMSrcMem, (outs VR256:$dst), (ins f128mem:$src),
4505                      "vcvtdq2pd\t{$src, $dst|$dst, $src}", []>, VEX;
4506 def VCVTDQ2PDYrr  : S3SI<0xE6, MRMSrcReg, (outs VR256:$dst), (ins VR128:$src),
4507                      "vcvtdq2pd\t{$src, $dst|$dst, $src}", []>, VEX;
4508 }
4509
4510 def CVTDQ2PDrm  : S3SI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
4511                        "cvtdq2pd\t{$src, $dst|$dst, $src}", []>;
4512 def CVTDQ2PDrr  : S3SI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4513                        "cvtdq2pd\t{$src, $dst|$dst, $src}", []>;
4514
4515 // AVX 256-bit register conversion intrinsics
4516 def : Pat<(int_x86_avx_cvtdq2_pd_256 VR128:$src),
4517            (VCVTDQ2PDYrr VR128:$src)>;
4518 def : Pat<(int_x86_avx_cvtdq2_pd_256 (memopv4i32 addr:$src)),
4519            (VCVTDQ2PDYrm addr:$src)>;
4520
4521 def : Pat<(int_x86_avx_cvt_pd2dq_256 VR256:$src),
4522           (VCVTPD2DQYrr VR256:$src)>;
4523 def : Pat<(int_x86_avx_cvt_pd2dq_256 (memopv4f64 addr:$src)),
4524           (VCVTPD2DQYrm addr:$src)>;
4525
4526 def : Pat<(v4f64 (sint_to_fp (v4i32 VR128:$src))),
4527           (VCVTDQ2PDYrr VR128:$src)>;
4528 def : Pat<(v4f64 (sint_to_fp (memopv4i32 addr:$src))),
4529           (VCVTDQ2PDYrm addr:$src)>;
4530
4531 //===---------------------------------------------------------------------===//
4532 // SSE3 - Replicate Single FP - MOVSHDUP and MOVSLDUP
4533 //===---------------------------------------------------------------------===//
4534 multiclass sse3_replicate_sfp<bits<8> op, SDNode OpNode, string OpcodeStr,
4535                               ValueType vt, RegisterClass RC, PatFrag mem_frag,
4536                               X86MemOperand x86memop> {
4537 def rr : S3SI<op, MRMSrcReg, (outs RC:$dst), (ins RC:$src),
4538                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4539                       [(set RC:$dst, (vt (OpNode RC:$src)))]>;
4540 def rm : S3SI<op, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
4541                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4542                       [(set RC:$dst, (OpNode (mem_frag addr:$src)))]>;
4543 }
4544
4545 let Predicates = [HasAVX] in {
4546   defm VMOVSHDUP  : sse3_replicate_sfp<0x16, X86Movshdup, "vmovshdup",
4547                                        v4f32, VR128, memopv4f32, f128mem>, VEX;
4548   defm VMOVSLDUP  : sse3_replicate_sfp<0x12, X86Movsldup, "vmovsldup",
4549                                        v4f32, VR128, memopv4f32, f128mem>, VEX;
4550   defm VMOVSHDUPY : sse3_replicate_sfp<0x16, X86Movshdup, "vmovshdup",
4551                                        v8f32, VR256, memopv8f32, f256mem>, VEX;
4552   defm VMOVSLDUPY : sse3_replicate_sfp<0x12, X86Movsldup, "vmovsldup",
4553                                        v8f32, VR256, memopv8f32, f256mem>, VEX;
4554 }
4555 defm MOVSHDUP : sse3_replicate_sfp<0x16, X86Movshdup, "movshdup", v4f32, VR128,
4556                                    memopv4f32, f128mem>;
4557 defm MOVSLDUP : sse3_replicate_sfp<0x12, X86Movsldup, "movsldup", v4f32, VR128,
4558                                    memopv4f32, f128mem>;
4559
4560 let Predicates = [HasSSE3] in {
4561   def : Pat<(v4i32 (X86Movshdup VR128:$src)),
4562             (MOVSHDUPrr VR128:$src)>;
4563   def : Pat<(v4i32 (X86Movshdup (bc_v4i32 (memopv2i64 addr:$src)))),
4564             (MOVSHDUPrm addr:$src)>;
4565   def : Pat<(v4i32 (X86Movsldup VR128:$src)),
4566             (MOVSLDUPrr VR128:$src)>;
4567   def : Pat<(v4i32 (X86Movsldup (bc_v4i32 (memopv2i64 addr:$src)))),
4568             (MOVSLDUPrm addr:$src)>;
4569 }
4570
4571 let Predicates = [HasAVX] in {
4572   def : Pat<(v4i32 (X86Movshdup VR128:$src)),
4573             (VMOVSHDUPrr VR128:$src)>;
4574   def : Pat<(v4i32 (X86Movshdup (bc_v4i32 (memopv2i64 addr:$src)))),
4575             (VMOVSHDUPrm addr:$src)>;
4576   def : Pat<(v4i32 (X86Movsldup VR128:$src)),
4577             (VMOVSLDUPrr VR128:$src)>;
4578   def : Pat<(v4i32 (X86Movsldup (bc_v4i32 (memopv2i64 addr:$src)))),
4579             (VMOVSLDUPrm addr:$src)>;
4580   def : Pat<(v8i32 (X86Movshdup VR256:$src)),
4581             (VMOVSHDUPYrr VR256:$src)>;
4582   def : Pat<(v8i32 (X86Movshdup (bc_v8i32 (memopv4i64 addr:$src)))),
4583             (VMOVSHDUPYrm addr:$src)>;
4584   def : Pat<(v8i32 (X86Movsldup VR256:$src)),
4585             (VMOVSLDUPYrr VR256:$src)>;
4586   def : Pat<(v8i32 (X86Movsldup (bc_v8i32 (memopv4i64 addr:$src)))),
4587             (VMOVSLDUPYrm addr:$src)>;
4588 }
4589
4590 //===---------------------------------------------------------------------===//
4591 // SSE3 - Replicate Double FP - MOVDDUP
4592 //===---------------------------------------------------------------------===//
4593
4594 multiclass sse3_replicate_dfp<string OpcodeStr> {
4595 def rr  : S3DI<0x12, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
4596                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4597                     [(set VR128:$dst,(v2f64 (movddup VR128:$src, (undef))))]>;
4598 def rm  : S3DI<0x12, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
4599                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4600                     [(set VR128:$dst,
4601                       (v2f64 (movddup (scalar_to_vector (loadf64 addr:$src)),
4602                                       (undef))))]>;
4603 }
4604
4605 // FIXME: Merge with above classe when there're patterns for the ymm version
4606 multiclass sse3_replicate_dfp_y<string OpcodeStr> {
4607 let Predicates = [HasAVX] in {
4608   def rr  : S3DI<0x12, MRMSrcReg, (outs VR256:$dst), (ins VR256:$src),
4609                       !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4610                       []>;
4611   def rm  : S3DI<0x12, MRMSrcMem, (outs VR256:$dst), (ins f256mem:$src),
4612                       !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4613                       []>;
4614   }
4615 }
4616
4617 defm MOVDDUP : sse3_replicate_dfp<"movddup">;
4618 defm VMOVDDUP  : sse3_replicate_dfp<"vmovddup">, VEX;
4619 defm VMOVDDUPY : sse3_replicate_dfp_y<"vmovddup">, VEX;
4620
4621 let Predicates = [HasSSE3] in {
4622   def : Pat<(movddup (bc_v2f64 (v2i64 (scalar_to_vector (loadi64 addr:$src)))),
4623                    (undef)),
4624             (MOVDDUPrm addr:$src)>;
4625   let AddedComplexity = 5 in {
4626   def : Pat<(movddup (memopv2f64 addr:$src), (undef)), (MOVDDUPrm addr:$src)>;
4627   def : Pat<(movddup (bc_v4f32 (memopv2f64 addr:$src)), (undef)),
4628             (MOVDDUPrm addr:$src)>;
4629   def : Pat<(movddup (memopv2i64 addr:$src), (undef)), (MOVDDUPrm addr:$src)>;
4630   def : Pat<(movddup (bc_v4i32 (memopv2i64 addr:$src)), (undef)),
4631             (MOVDDUPrm addr:$src)>;
4632   }
4633   def : Pat<(X86Movddup (memopv2f64 addr:$src)),
4634             (MOVDDUPrm addr:$src)>;
4635   def : Pat<(X86Movddup (bc_v2f64 (memopv4f32 addr:$src))),
4636             (MOVDDUPrm addr:$src)>;
4637   def : Pat<(X86Movddup (bc_v2f64 (memopv2i64 addr:$src))),
4638             (MOVDDUPrm addr:$src)>;
4639   def : Pat<(X86Movddup (v2f64 (scalar_to_vector (loadf64 addr:$src)))),
4640             (MOVDDUPrm addr:$src)>;
4641   def : Pat<(X86Movddup (bc_v2f64
4642                              (v2i64 (scalar_to_vector (loadi64 addr:$src))))),
4643             (MOVDDUPrm addr:$src)>;
4644 }
4645
4646 let Predicates = [HasAVX] in {
4647   def : Pat<(movddup (bc_v2f64 (v2i64 (scalar_to_vector (loadi64 addr:$src)))),
4648                    (undef)),
4649             (VMOVDDUPrm addr:$src)>;
4650   let AddedComplexity = 5 in {
4651   def : Pat<(movddup (memopv2f64 addr:$src), (undef)), (VMOVDDUPrm addr:$src)>;
4652   def : Pat<(movddup (bc_v4f32 (memopv2f64 addr:$src)), (undef)),
4653             (VMOVDDUPrm addr:$src)>;
4654   def : Pat<(movddup (memopv2i64 addr:$src), (undef)), (VMOVDDUPrm addr:$src)>;
4655   def : Pat<(movddup (bc_v4i32 (memopv2i64 addr:$src)), (undef)),
4656             (VMOVDDUPrm addr:$src)>;
4657   }
4658   def : Pat<(X86Movddup (memopv2f64 addr:$src)),
4659             (VMOVDDUPrm addr:$src)>, Requires<[HasAVX]>;
4660   def : Pat<(X86Movddup (bc_v2f64 (memopv4f32 addr:$src))),
4661             (VMOVDDUPrm addr:$src)>, Requires<[HasAVX]>;
4662   def : Pat<(X86Movddup (bc_v2f64 (memopv2i64 addr:$src))),
4663             (VMOVDDUPrm addr:$src)>, Requires<[HasAVX]>;
4664   def : Pat<(X86Movddup (v2f64 (scalar_to_vector (loadf64 addr:$src)))),
4665             (VMOVDDUPrm addr:$src)>, Requires<[HasAVX]>;
4666   def : Pat<(X86Movddup (bc_v2f64
4667                              (v2i64 (scalar_to_vector (loadi64 addr:$src))))),
4668             (VMOVDDUPrm addr:$src)>, Requires<[HasAVX]>;
4669
4670   // 256-bit version
4671   def : Pat<(X86Movddup (memopv4f64 addr:$src)),
4672             (VMOVDDUPYrm addr:$src)>;
4673   def : Pat<(X86Movddup (memopv4i64 addr:$src)),
4674             (VMOVDDUPYrm addr:$src)>;
4675   def : Pat<(X86Movddup (v4f64 (scalar_to_vector (loadf64 addr:$src)))),
4676             (VMOVDDUPYrm addr:$src)>;
4677   def : Pat<(X86Movddup (v4i64 (scalar_to_vector (loadi64 addr:$src)))),
4678             (VMOVDDUPYrm addr:$src)>;
4679   def : Pat<(X86Movddup (v4f64 VR256:$src)),
4680             (VMOVDDUPYrr VR256:$src)>;
4681   def : Pat<(X86Movddup (v4i64 VR256:$src)),
4682             (VMOVDDUPYrr VR256:$src)>;
4683 }
4684
4685 //===---------------------------------------------------------------------===//
4686 // SSE3 - Move Unaligned Integer
4687 //===---------------------------------------------------------------------===//
4688
4689 let Predicates = [HasAVX] in {
4690   def VLDDQUrm : S3DI<0xF0, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
4691                    "vlddqu\t{$src, $dst|$dst, $src}",
4692                    [(set VR128:$dst, (int_x86_sse3_ldu_dq addr:$src))]>, VEX;
4693   def VLDDQUYrm : S3DI<0xF0, MRMSrcMem, (outs VR256:$dst), (ins i256mem:$src),
4694                    "vlddqu\t{$src, $dst|$dst, $src}",
4695                    [(set VR256:$dst, (int_x86_avx_ldu_dq_256 addr:$src))]>, VEX;
4696 }
4697 def LDDQUrm : S3DI<0xF0, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
4698                    "lddqu\t{$src, $dst|$dst, $src}",
4699                    [(set VR128:$dst, (int_x86_sse3_ldu_dq addr:$src))]>;
4700
4701 //===---------------------------------------------------------------------===//
4702 // SSE3 - Arithmetic
4703 //===---------------------------------------------------------------------===//
4704
4705 multiclass sse3_addsub<Intrinsic Int, string OpcodeStr, RegisterClass RC,
4706                        X86MemOperand x86memop, bit Is2Addr = 1> {
4707   def rr : I<0xD0, MRMSrcReg,
4708        (outs RC:$dst), (ins RC:$src1, RC:$src2),
4709        !if(Is2Addr,
4710            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4711            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4712        [(set RC:$dst, (Int RC:$src1, RC:$src2))]>;
4713   def rm : I<0xD0, MRMSrcMem,
4714        (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
4715        !if(Is2Addr,
4716            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4717            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4718        [(set RC:$dst, (Int RC:$src1, (memop addr:$src2)))]>;
4719 }
4720
4721 let Predicates = [HasAVX],
4722   ExeDomain = SSEPackedDouble in {
4723   defm VADDSUBPS : sse3_addsub<int_x86_sse3_addsub_ps, "vaddsubps", VR128,
4724                                f128mem, 0>, TB, XD, VEX_4V;
4725   defm VADDSUBPD : sse3_addsub<int_x86_sse3_addsub_pd, "vaddsubpd", VR128,
4726                                f128mem, 0>, TB, OpSize, VEX_4V;
4727   defm VADDSUBPSY : sse3_addsub<int_x86_avx_addsub_ps_256, "vaddsubps", VR256,
4728                                f256mem, 0>, TB, XD, VEX_4V;
4729   defm VADDSUBPDY : sse3_addsub<int_x86_avx_addsub_pd_256, "vaddsubpd", VR256,
4730                                f256mem, 0>, TB, OpSize, VEX_4V;
4731 }
4732 let Constraints = "$src1 = $dst", Predicates = [HasSSE3],
4733     ExeDomain = SSEPackedDouble in {
4734   defm ADDSUBPS : sse3_addsub<int_x86_sse3_addsub_ps, "addsubps", VR128,
4735                               f128mem>, TB, XD;
4736   defm ADDSUBPD : sse3_addsub<int_x86_sse3_addsub_pd, "addsubpd", VR128,
4737                               f128mem>, TB, OpSize;
4738 }
4739
4740 //===---------------------------------------------------------------------===//
4741 // SSE3 Instructions
4742 //===---------------------------------------------------------------------===//
4743
4744 // Horizontal ops
4745 multiclass S3D_Int<bits<8> o, string OpcodeStr, ValueType vt, RegisterClass RC,
4746                    X86MemOperand x86memop, Intrinsic IntId, bit Is2Addr = 1> {
4747   def rr : S3DI<o, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
4748        !if(Is2Addr,
4749          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4750          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4751       [(set RC:$dst, (vt (IntId RC:$src1, RC:$src2)))]>;
4752
4753   def rm : S3DI<o, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
4754        !if(Is2Addr,
4755          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4756          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4757       [(set RC:$dst, (vt (IntId RC:$src1, (memop addr:$src2))))]>;
4758 }
4759 multiclass S3_Int<bits<8> o, string OpcodeStr, ValueType vt, RegisterClass RC,
4760                   X86MemOperand x86memop, Intrinsic IntId, bit Is2Addr = 1> {
4761   def rr : S3I<o, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
4762        !if(Is2Addr,
4763          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4764          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4765       [(set RC:$dst, (vt (IntId RC:$src1, RC:$src2)))]>;
4766
4767   def rm : S3I<o, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
4768        !if(Is2Addr,
4769          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4770          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4771       [(set RC:$dst, (vt (IntId RC:$src1, (memop addr:$src2))))]>;
4772 }
4773
4774 let Predicates = [HasAVX] in {
4775   defm VHADDPS  : S3D_Int<0x7C, "vhaddps", v4f32, VR128, f128mem,
4776                           int_x86_sse3_hadd_ps, 0>, VEX_4V;
4777   defm VHADDPD  : S3_Int <0x7C, "vhaddpd", v2f64, VR128, f128mem,
4778                           int_x86_sse3_hadd_pd, 0>, VEX_4V;
4779   defm VHSUBPS  : S3D_Int<0x7D, "vhsubps", v4f32, VR128, f128mem,
4780                           int_x86_sse3_hsub_ps, 0>, VEX_4V;
4781   defm VHSUBPD  : S3_Int <0x7D, "vhsubpd", v2f64, VR128, f128mem,
4782                           int_x86_sse3_hsub_pd, 0>, VEX_4V;
4783   defm VHADDPSY : S3D_Int<0x7C, "vhaddps", v8f32, VR256, f256mem,
4784                           int_x86_avx_hadd_ps_256, 0>, VEX_4V;
4785   defm VHADDPDY : S3_Int <0x7C, "vhaddpd", v4f64, VR256, f256mem,
4786                           int_x86_avx_hadd_pd_256, 0>, VEX_4V;
4787   defm VHSUBPSY : S3D_Int<0x7D, "vhsubps", v8f32, VR256, f256mem,
4788                           int_x86_avx_hsub_ps_256, 0>, VEX_4V;
4789   defm VHSUBPDY : S3_Int <0x7D, "vhsubpd", v4f64, VR256, f256mem,
4790                           int_x86_avx_hsub_pd_256, 0>, VEX_4V;
4791 }
4792
4793 let Constraints = "$src1 = $dst" in {
4794   defm HADDPS : S3D_Int<0x7C, "haddps", v4f32, VR128, f128mem,
4795                         int_x86_sse3_hadd_ps>;
4796   defm HADDPD : S3_Int<0x7C, "haddpd", v2f64, VR128, f128mem,
4797                        int_x86_sse3_hadd_pd>;
4798   defm HSUBPS : S3D_Int<0x7D, "hsubps", v4f32, VR128, f128mem,
4799                         int_x86_sse3_hsub_ps>;
4800   defm HSUBPD : S3_Int<0x7D, "hsubpd", v2f64, VR128, f128mem,
4801                        int_x86_sse3_hsub_pd>;
4802 }
4803
4804 //===---------------------------------------------------------------------===//
4805 // SSSE3 - Packed Absolute Instructions
4806 //===---------------------------------------------------------------------===//
4807
4808
4809 /// SS3I_unop_rm_int - Simple SSSE3 unary op whose type can be v*{i8,i16,i32}.
4810 multiclass SS3I_unop_rm_int<bits<8> opc, string OpcodeStr,
4811                             PatFrag mem_frag128, Intrinsic IntId128> {
4812   def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
4813                     (ins VR128:$src),
4814                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4815                     [(set VR128:$dst, (IntId128 VR128:$src))]>,
4816                     OpSize;
4817
4818   def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
4819                     (ins i128mem:$src),
4820                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
4821                     [(set VR128:$dst,
4822                       (IntId128
4823                        (bitconvert (mem_frag128 addr:$src))))]>, OpSize;
4824 }
4825
4826 let Predicates = [HasAVX] in {
4827   defm VPABSB  : SS3I_unop_rm_int<0x1C, "vpabsb", memopv16i8,
4828                                   int_x86_ssse3_pabs_b_128>, VEX;
4829   defm VPABSW  : SS3I_unop_rm_int<0x1D, "vpabsw", memopv8i16,
4830                                   int_x86_ssse3_pabs_w_128>, VEX;
4831   defm VPABSD  : SS3I_unop_rm_int<0x1E, "vpabsd", memopv4i32,
4832                                   int_x86_ssse3_pabs_d_128>, VEX;
4833 }
4834
4835 defm PABSB : SS3I_unop_rm_int<0x1C, "pabsb", memopv16i8,
4836                               int_x86_ssse3_pabs_b_128>;
4837 defm PABSW : SS3I_unop_rm_int<0x1D, "pabsw", memopv8i16,
4838                               int_x86_ssse3_pabs_w_128>;
4839 defm PABSD : SS3I_unop_rm_int<0x1E, "pabsd", memopv4i32,
4840                               int_x86_ssse3_pabs_d_128>;
4841
4842 //===---------------------------------------------------------------------===//
4843 // SSSE3 - Packed Binary Operator Instructions
4844 //===---------------------------------------------------------------------===//
4845
4846 /// SS3I_binop_rm_int - Simple SSSE3 bin op whose type can be v*{i8,i16,i32}.
4847 multiclass SS3I_binop_rm_int<bits<8> opc, string OpcodeStr,
4848                              PatFrag mem_frag128, Intrinsic IntId128,
4849                              bit Is2Addr = 1> {
4850   let isCommutable = 1 in
4851   def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
4852        (ins VR128:$src1, VR128:$src2),
4853        !if(Is2Addr,
4854          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4855          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4856        [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
4857        OpSize;
4858   def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
4859        (ins VR128:$src1, i128mem:$src2),
4860        !if(Is2Addr,
4861          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
4862          !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
4863        [(set VR128:$dst,
4864          (IntId128 VR128:$src1,
4865           (bitconvert (memopv16i8 addr:$src2))))]>, OpSize;
4866 }
4867
4868 let Predicates = [HasAVX] in {
4869 let isCommutable = 0 in {
4870   defm VPHADDW    : SS3I_binop_rm_int<0x01, "vphaddw", memopv8i16,
4871                                       int_x86_ssse3_phadd_w_128, 0>, VEX_4V;
4872   defm VPHADDD    : SS3I_binop_rm_int<0x02, "vphaddd", memopv4i32,
4873                                       int_x86_ssse3_phadd_d_128, 0>, VEX_4V;
4874   defm VPHADDSW   : SS3I_binop_rm_int<0x03, "vphaddsw", memopv8i16,
4875                                       int_x86_ssse3_phadd_sw_128, 0>, VEX_4V;
4876   defm VPHSUBW    : SS3I_binop_rm_int<0x05, "vphsubw", memopv8i16,
4877                                       int_x86_ssse3_phsub_w_128, 0>, VEX_4V;
4878   defm VPHSUBD    : SS3I_binop_rm_int<0x06, "vphsubd", memopv4i32,
4879                                       int_x86_ssse3_phsub_d_128, 0>, VEX_4V;
4880   defm VPHSUBSW   : SS3I_binop_rm_int<0x07, "vphsubsw", memopv8i16,
4881                                       int_x86_ssse3_phsub_sw_128, 0>, VEX_4V;
4882   defm VPMADDUBSW : SS3I_binop_rm_int<0x04, "vpmaddubsw", memopv16i8,
4883                                       int_x86_ssse3_pmadd_ub_sw_128, 0>, VEX_4V;
4884   defm VPSHUFB    : SS3I_binop_rm_int<0x00, "vpshufb", memopv16i8,
4885                                       int_x86_ssse3_pshuf_b_128, 0>, VEX_4V;
4886   defm VPSIGNB    : SS3I_binop_rm_int<0x08, "vpsignb", memopv16i8,
4887                                       int_x86_ssse3_psign_b_128, 0>, VEX_4V;
4888   defm VPSIGNW    : SS3I_binop_rm_int<0x09, "vpsignw", memopv8i16,
4889                                       int_x86_ssse3_psign_w_128, 0>, VEX_4V;
4890   defm VPSIGND    : SS3I_binop_rm_int<0x0A, "vpsignd", memopv4i32,
4891                                       int_x86_ssse3_psign_d_128, 0>, VEX_4V;
4892 }
4893 defm VPMULHRSW    : SS3I_binop_rm_int<0x0B, "vpmulhrsw", memopv8i16,
4894                                       int_x86_ssse3_pmul_hr_sw_128, 0>, VEX_4V;
4895 }
4896
4897 // None of these have i8 immediate fields.
4898 let ImmT = NoImm, Constraints = "$src1 = $dst" in {
4899 let isCommutable = 0 in {
4900   defm PHADDW    : SS3I_binop_rm_int<0x01, "phaddw", memopv8i16,
4901                                      int_x86_ssse3_phadd_w_128>;
4902   defm PHADDD    : SS3I_binop_rm_int<0x02, "phaddd", memopv4i32,
4903                                      int_x86_ssse3_phadd_d_128>;
4904   defm PHADDSW   : SS3I_binop_rm_int<0x03, "phaddsw", memopv8i16,
4905                                      int_x86_ssse3_phadd_sw_128>;
4906   defm PHSUBW    : SS3I_binop_rm_int<0x05, "phsubw", memopv8i16,
4907                                      int_x86_ssse3_phsub_w_128>;
4908   defm PHSUBD    : SS3I_binop_rm_int<0x06, "phsubd", memopv4i32,
4909                                      int_x86_ssse3_phsub_d_128>;
4910   defm PHSUBSW   : SS3I_binop_rm_int<0x07, "phsubsw", memopv8i16,
4911                                      int_x86_ssse3_phsub_sw_128>;
4912   defm PMADDUBSW : SS3I_binop_rm_int<0x04, "pmaddubsw", memopv16i8,
4913                                      int_x86_ssse3_pmadd_ub_sw_128>;
4914   defm PSHUFB    : SS3I_binop_rm_int<0x00, "pshufb", memopv16i8,
4915                                      int_x86_ssse3_pshuf_b_128>;
4916   defm PSIGNB    : SS3I_binop_rm_int<0x08, "psignb", memopv16i8,
4917                                      int_x86_ssse3_psign_b_128>;
4918   defm PSIGNW    : SS3I_binop_rm_int<0x09, "psignw", memopv8i16,
4919                                      int_x86_ssse3_psign_w_128>;
4920   defm PSIGND    : SS3I_binop_rm_int<0x0A, "psignd", memopv4i32,
4921                                        int_x86_ssse3_psign_d_128>;
4922 }
4923 defm PMULHRSW    : SS3I_binop_rm_int<0x0B, "pmulhrsw", memopv8i16,
4924                                      int_x86_ssse3_pmul_hr_sw_128>;
4925 }
4926
4927 let Predicates = [HasSSSE3] in {
4928   def : Pat<(X86pshufb VR128:$src, VR128:$mask),
4929             (PSHUFBrr128 VR128:$src, VR128:$mask)>;
4930   def : Pat<(X86pshufb VR128:$src, (bc_v16i8 (memopv2i64 addr:$mask))),
4931             (PSHUFBrm128 VR128:$src, addr:$mask)>;
4932
4933   def : Pat<(X86psignb VR128:$src1, VR128:$src2),
4934             (PSIGNBrr128 VR128:$src1, VR128:$src2)>;
4935   def : Pat<(X86psignw VR128:$src1, VR128:$src2),
4936             (PSIGNWrr128 VR128:$src1, VR128:$src2)>;
4937   def : Pat<(X86psignd VR128:$src1, VR128:$src2),
4938             (PSIGNDrr128 VR128:$src1, VR128:$src2)>;
4939 }
4940
4941 let Predicates = [HasAVX] in {
4942   def : Pat<(X86pshufb VR128:$src, VR128:$mask),
4943             (VPSHUFBrr128 VR128:$src, VR128:$mask)>;
4944   def : Pat<(X86pshufb VR128:$src, (bc_v16i8 (memopv2i64 addr:$mask))),
4945             (VPSHUFBrm128 VR128:$src, addr:$mask)>;
4946
4947   def : Pat<(X86psignb VR128:$src1, VR128:$src2),
4948             (VPSIGNBrr128 VR128:$src1, VR128:$src2)>;
4949   def : Pat<(X86psignw VR128:$src1, VR128:$src2),
4950             (VPSIGNWrr128 VR128:$src1, VR128:$src2)>;
4951   def : Pat<(X86psignd VR128:$src1, VR128:$src2),
4952             (VPSIGNDrr128 VR128:$src1, VR128:$src2)>;
4953 }
4954
4955 //===---------------------------------------------------------------------===//
4956 // SSSE3 - Packed Align Instruction Patterns
4957 //===---------------------------------------------------------------------===//
4958
4959 multiclass ssse3_palign<string asm, bit Is2Addr = 1> {
4960   def R128rr : SS3AI<0x0F, MRMSrcReg, (outs VR128:$dst),
4961       (ins VR128:$src1, VR128:$src2, i8imm:$src3),
4962       !if(Is2Addr,
4963         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
4964         !strconcat(asm,
4965                   "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
4966       []>, OpSize;
4967   def R128rm : SS3AI<0x0F, MRMSrcMem, (outs VR128:$dst),
4968       (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
4969       !if(Is2Addr,
4970         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
4971         !strconcat(asm,
4972                   "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
4973       []>, OpSize;
4974 }
4975
4976 let Predicates = [HasAVX] in
4977   defm VPALIGN : ssse3_palign<"vpalignr", 0>, VEX_4V;
4978 let Constraints = "$src1 = $dst", Predicates = [HasSSSE3] in
4979   defm PALIGN : ssse3_palign<"palignr">;
4980
4981 let Predicates = [HasSSSE3] in {
4982 def : Pat<(v4i32 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
4983           (PALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
4984 def : Pat<(v4f32 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
4985           (PALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
4986 def : Pat<(v8i16 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
4987           (PALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
4988 def : Pat<(v16i8 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
4989           (PALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
4990 }
4991
4992 let Predicates = [HasAVX] in {
4993 def : Pat<(v4i32 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
4994           (VPALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
4995 def : Pat<(v4f32 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
4996           (VPALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
4997 def : Pat<(v8i16 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
4998           (VPALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
4999 def : Pat<(v16i8 (X86PAlign VR128:$src1, VR128:$src2, (i8 imm:$imm))),
5000           (VPALIGNR128rr VR128:$src2, VR128:$src1, imm:$imm)>;
5001 }
5002
5003 //===---------------------------------------------------------------------===//
5004 // SSSE3 - Thread synchronization
5005 //===---------------------------------------------------------------------===//
5006
5007 let usesCustomInserter = 1 in {
5008 def MONITOR : PseudoI<(outs), (ins i32mem:$src1, GR32:$src2, GR32:$src3),
5009                 [(int_x86_sse3_monitor addr:$src1, GR32:$src2, GR32:$src3)]>;
5010 def MWAIT : PseudoI<(outs), (ins GR32:$src1, GR32:$src2),
5011                 [(int_x86_sse3_mwait GR32:$src1, GR32:$src2)]>;
5012 }
5013
5014 let Uses = [EAX, ECX, EDX] in
5015 def MONITORrrr : I<0x01, MRM_C8, (outs), (ins), "monitor", []>, TB,
5016                  Requires<[HasSSE3]>;
5017 let Uses = [ECX, EAX] in
5018 def MWAITrr   : I<0x01, MRM_C9, (outs), (ins), "mwait", []>, TB,
5019                 Requires<[HasSSE3]>;
5020
5021 def : InstAlias<"mwait %eax, %ecx", (MWAITrr)>, Requires<[In32BitMode]>;
5022 def : InstAlias<"mwait %rax, %rcx", (MWAITrr)>, Requires<[In64BitMode]>;
5023
5024 def : InstAlias<"monitor %eax, %ecx, %edx", (MONITORrrr)>,
5025       Requires<[In32BitMode]>;
5026 def : InstAlias<"monitor %rax, %rcx, %rdx", (MONITORrrr)>,
5027       Requires<[In64BitMode]>;
5028
5029 //===----------------------------------------------------------------------===//
5030 // SSE4.1 - Packed Move with Sign/Zero Extend
5031 //===----------------------------------------------------------------------===//
5032
5033 multiclass SS41I_binop_rm_int8<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
5034   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
5035                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5036                  [(set VR128:$dst, (IntId VR128:$src))]>, OpSize;
5037
5038   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
5039                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5040        [(set VR128:$dst,
5041          (IntId (bitconvert (v2i64 (scalar_to_vector (loadi64 addr:$src))))))]>,
5042        OpSize;
5043 }
5044
5045 let Predicates = [HasAVX] in {
5046 defm VPMOVSXBW : SS41I_binop_rm_int8<0x20, "vpmovsxbw", int_x86_sse41_pmovsxbw>,
5047                                      VEX;
5048 defm VPMOVSXWD : SS41I_binop_rm_int8<0x23, "vpmovsxwd", int_x86_sse41_pmovsxwd>,
5049                                      VEX;
5050 defm VPMOVSXDQ : SS41I_binop_rm_int8<0x25, "vpmovsxdq", int_x86_sse41_pmovsxdq>,
5051                                      VEX;
5052 defm VPMOVZXBW : SS41I_binop_rm_int8<0x30, "vpmovzxbw", int_x86_sse41_pmovzxbw>,
5053                                      VEX;
5054 defm VPMOVZXWD : SS41I_binop_rm_int8<0x33, "vpmovzxwd", int_x86_sse41_pmovzxwd>,
5055                                      VEX;
5056 defm VPMOVZXDQ : SS41I_binop_rm_int8<0x35, "vpmovzxdq", int_x86_sse41_pmovzxdq>,
5057                                      VEX;
5058 }
5059
5060 defm PMOVSXBW   : SS41I_binop_rm_int8<0x20, "pmovsxbw", int_x86_sse41_pmovsxbw>;
5061 defm PMOVSXWD   : SS41I_binop_rm_int8<0x23, "pmovsxwd", int_x86_sse41_pmovsxwd>;
5062 defm PMOVSXDQ   : SS41I_binop_rm_int8<0x25, "pmovsxdq", int_x86_sse41_pmovsxdq>;
5063 defm PMOVZXBW   : SS41I_binop_rm_int8<0x30, "pmovzxbw", int_x86_sse41_pmovzxbw>;
5064 defm PMOVZXWD   : SS41I_binop_rm_int8<0x33, "pmovzxwd", int_x86_sse41_pmovzxwd>;
5065 defm PMOVZXDQ   : SS41I_binop_rm_int8<0x35, "pmovzxdq", int_x86_sse41_pmovzxdq>;
5066
5067 let Predicates = [HasSSE41] in {
5068   // Common patterns involving scalar load.
5069   def : Pat<(int_x86_sse41_pmovsxbw (vzmovl_v2i64 addr:$src)),
5070             (PMOVSXBWrm addr:$src)>;
5071   def : Pat<(int_x86_sse41_pmovsxbw (vzload_v2i64 addr:$src)),
5072             (PMOVSXBWrm addr:$src)>;
5073
5074   def : Pat<(int_x86_sse41_pmovsxwd (vzmovl_v2i64 addr:$src)),
5075             (PMOVSXWDrm addr:$src)>;
5076   def : Pat<(int_x86_sse41_pmovsxwd (vzload_v2i64 addr:$src)),
5077             (PMOVSXWDrm addr:$src)>;
5078
5079   def : Pat<(int_x86_sse41_pmovsxdq (vzmovl_v2i64 addr:$src)),
5080             (PMOVSXDQrm addr:$src)>;
5081   def : Pat<(int_x86_sse41_pmovsxdq (vzload_v2i64 addr:$src)),
5082             (PMOVSXDQrm addr:$src)>;
5083
5084   def : Pat<(int_x86_sse41_pmovzxbw (vzmovl_v2i64 addr:$src)),
5085             (PMOVZXBWrm addr:$src)>;
5086   def : Pat<(int_x86_sse41_pmovzxbw (vzload_v2i64 addr:$src)),
5087             (PMOVZXBWrm addr:$src)>;
5088
5089   def : Pat<(int_x86_sse41_pmovzxwd (vzmovl_v2i64 addr:$src)),
5090             (PMOVZXWDrm addr:$src)>;
5091   def : Pat<(int_x86_sse41_pmovzxwd (vzload_v2i64 addr:$src)),
5092             (PMOVZXWDrm addr:$src)>;
5093
5094   def : Pat<(int_x86_sse41_pmovzxdq (vzmovl_v2i64 addr:$src)),
5095             (PMOVZXDQrm addr:$src)>;
5096   def : Pat<(int_x86_sse41_pmovzxdq (vzload_v2i64 addr:$src)),
5097             (PMOVZXDQrm addr:$src)>;
5098 }
5099
5100 let Predicates = [HasAVX] in {
5101   // Common patterns involving scalar load.
5102   def : Pat<(int_x86_sse41_pmovsxbw (vzmovl_v2i64 addr:$src)),
5103             (VPMOVSXBWrm addr:$src)>;
5104   def : Pat<(int_x86_sse41_pmovsxbw (vzload_v2i64 addr:$src)),
5105             (VPMOVSXBWrm addr:$src)>;
5106
5107   def : Pat<(int_x86_sse41_pmovsxwd (vzmovl_v2i64 addr:$src)),
5108             (VPMOVSXWDrm addr:$src)>;
5109   def : Pat<(int_x86_sse41_pmovsxwd (vzload_v2i64 addr:$src)),
5110             (VPMOVSXWDrm addr:$src)>;
5111
5112   def : Pat<(int_x86_sse41_pmovsxdq (vzmovl_v2i64 addr:$src)),
5113             (VPMOVSXDQrm addr:$src)>;
5114   def : Pat<(int_x86_sse41_pmovsxdq (vzload_v2i64 addr:$src)),
5115             (VPMOVSXDQrm addr:$src)>;
5116
5117   def : Pat<(int_x86_sse41_pmovzxbw (vzmovl_v2i64 addr:$src)),
5118             (VPMOVZXBWrm addr:$src)>;
5119   def : Pat<(int_x86_sse41_pmovzxbw (vzload_v2i64 addr:$src)),
5120             (VPMOVZXBWrm addr:$src)>;
5121
5122   def : Pat<(int_x86_sse41_pmovzxwd (vzmovl_v2i64 addr:$src)),
5123             (VPMOVZXWDrm addr:$src)>;
5124   def : Pat<(int_x86_sse41_pmovzxwd (vzload_v2i64 addr:$src)),
5125             (VPMOVZXWDrm addr:$src)>;
5126
5127   def : Pat<(int_x86_sse41_pmovzxdq (vzmovl_v2i64 addr:$src)),
5128             (VPMOVZXDQrm addr:$src)>;
5129   def : Pat<(int_x86_sse41_pmovzxdq (vzload_v2i64 addr:$src)),
5130             (VPMOVZXDQrm addr:$src)>;
5131 }
5132
5133
5134 multiclass SS41I_binop_rm_int4<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
5135   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
5136                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5137                  [(set VR128:$dst, (IntId VR128:$src))]>, OpSize;
5138
5139   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
5140                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5141        [(set VR128:$dst,
5142          (IntId (bitconvert (v4i32 (scalar_to_vector (loadi32 addr:$src))))))]>,
5143           OpSize;
5144 }
5145
5146 let Predicates = [HasAVX] in {
5147 defm VPMOVSXBD : SS41I_binop_rm_int4<0x21, "vpmovsxbd", int_x86_sse41_pmovsxbd>,
5148                                      VEX;
5149 defm VPMOVSXWQ : SS41I_binop_rm_int4<0x24, "vpmovsxwq", int_x86_sse41_pmovsxwq>,
5150                                      VEX;
5151 defm VPMOVZXBD : SS41I_binop_rm_int4<0x31, "vpmovzxbd", int_x86_sse41_pmovzxbd>,
5152                                      VEX;
5153 defm VPMOVZXWQ : SS41I_binop_rm_int4<0x34, "vpmovzxwq", int_x86_sse41_pmovzxwq>,
5154                                      VEX;
5155 }
5156
5157 defm PMOVSXBD   : SS41I_binop_rm_int4<0x21, "pmovsxbd", int_x86_sse41_pmovsxbd>;
5158 defm PMOVSXWQ   : SS41I_binop_rm_int4<0x24, "pmovsxwq", int_x86_sse41_pmovsxwq>;
5159 defm PMOVZXBD   : SS41I_binop_rm_int4<0x31, "pmovzxbd", int_x86_sse41_pmovzxbd>;
5160 defm PMOVZXWQ   : SS41I_binop_rm_int4<0x34, "pmovzxwq", int_x86_sse41_pmovzxwq>;
5161
5162 let Predicates = [HasSSE41] in {
5163   // Common patterns involving scalar load
5164   def : Pat<(int_x86_sse41_pmovsxbd (vzmovl_v4i32 addr:$src)),
5165             (PMOVSXBDrm addr:$src)>;
5166   def : Pat<(int_x86_sse41_pmovsxwq (vzmovl_v4i32 addr:$src)),
5167             (PMOVSXWQrm addr:$src)>;
5168
5169   def : Pat<(int_x86_sse41_pmovzxbd (vzmovl_v4i32 addr:$src)),
5170             (PMOVZXBDrm addr:$src)>;
5171   def : Pat<(int_x86_sse41_pmovzxwq (vzmovl_v4i32 addr:$src)),
5172             (PMOVZXWQrm addr:$src)>;
5173 }
5174
5175 let Predicates = [HasAVX] in {
5176   // Common patterns involving scalar load
5177   def : Pat<(int_x86_sse41_pmovsxbd (vzmovl_v4i32 addr:$src)),
5178             (VPMOVSXBDrm addr:$src)>;
5179   def : Pat<(int_x86_sse41_pmovsxwq (vzmovl_v4i32 addr:$src)),
5180             (VPMOVSXWQrm addr:$src)>;
5181
5182   def : Pat<(int_x86_sse41_pmovzxbd (vzmovl_v4i32 addr:$src)),
5183             (VPMOVZXBDrm addr:$src)>;
5184   def : Pat<(int_x86_sse41_pmovzxwq (vzmovl_v4i32 addr:$src)),
5185             (VPMOVZXWQrm addr:$src)>;
5186 }
5187
5188 multiclass SS41I_binop_rm_int2<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
5189   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
5190                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5191                  [(set VR128:$dst, (IntId VR128:$src))]>, OpSize;
5192
5193   // Expecting a i16 load any extended to i32 value.
5194   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst), (ins i16mem:$src),
5195                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5196                  [(set VR128:$dst, (IntId (bitconvert
5197                      (v4i32 (scalar_to_vector (loadi16_anyext addr:$src))))))]>,
5198                  OpSize;
5199 }
5200
5201 let Predicates = [HasAVX] in {
5202 defm VPMOVSXBQ : SS41I_binop_rm_int2<0x22, "vpmovsxbq", int_x86_sse41_pmovsxbq>,
5203                                      VEX;
5204 defm VPMOVZXBQ : SS41I_binop_rm_int2<0x32, "vpmovzxbq", int_x86_sse41_pmovzxbq>,
5205                                      VEX;
5206 }
5207 defm PMOVSXBQ   : SS41I_binop_rm_int2<0x22, "pmovsxbq", int_x86_sse41_pmovsxbq>;
5208 defm PMOVZXBQ   : SS41I_binop_rm_int2<0x32, "pmovzxbq", int_x86_sse41_pmovzxbq>;
5209
5210 let Predicates = [HasSSE41] in {
5211   // Common patterns involving scalar load
5212   def : Pat<(int_x86_sse41_pmovsxbq
5213               (bitconvert (v4i32 (X86vzmovl
5214                             (v4i32 (scalar_to_vector (loadi32 addr:$src))))))),
5215             (PMOVSXBQrm addr:$src)>;
5216
5217   def : Pat<(int_x86_sse41_pmovzxbq
5218               (bitconvert (v4i32 (X86vzmovl
5219                             (v4i32 (scalar_to_vector (loadi32 addr:$src))))))),
5220             (PMOVZXBQrm addr:$src)>;
5221 }
5222
5223 let Predicates = [HasAVX] in {
5224   // Common patterns involving scalar load
5225   def : Pat<(int_x86_sse41_pmovsxbq
5226               (bitconvert (v4i32 (X86vzmovl
5227                             (v4i32 (scalar_to_vector (loadi32 addr:$src))))))),
5228             (VPMOVSXBQrm addr:$src)>;
5229
5230   def : Pat<(int_x86_sse41_pmovzxbq
5231               (bitconvert (v4i32 (X86vzmovl
5232                             (v4i32 (scalar_to_vector (loadi32 addr:$src))))))),
5233             (VPMOVZXBQrm addr:$src)>;
5234 }
5235
5236 //===----------------------------------------------------------------------===//
5237 // SSE4.1 - Extract Instructions
5238 //===----------------------------------------------------------------------===//
5239
5240 /// SS41I_binop_ext8 - SSE 4.1 extract 8 bits to 32 bit reg or 8 bit mem
5241 multiclass SS41I_extract8<bits<8> opc, string OpcodeStr> {
5242   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32:$dst),
5243                  (ins VR128:$src1, i32i8imm:$src2),
5244                  !strconcat(OpcodeStr,
5245                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5246                  [(set GR32:$dst, (X86pextrb (v16i8 VR128:$src1), imm:$src2))]>,
5247                  OpSize;
5248   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5249                  (ins i8mem:$dst, VR128:$src1, i32i8imm:$src2),
5250                  !strconcat(OpcodeStr,
5251                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5252                  []>, OpSize;
5253 // FIXME:
5254 // There's an AssertZext in the way of writing the store pattern
5255 // (store (i8 (trunc (X86pextrb (v16i8 VR128:$src1), imm:$src2))), addr:$dst)
5256 }
5257
5258 let Predicates = [HasAVX] in {
5259   defm VPEXTRB : SS41I_extract8<0x14, "vpextrb">, VEX;
5260   def  VPEXTRBrr64 : SS4AIi8<0x14, MRMDestReg, (outs GR64:$dst),
5261          (ins VR128:$src1, i32i8imm:$src2),
5262          "vpextrb\t{$src2, $src1, $dst|$dst, $src1, $src2}", []>, OpSize, VEX;
5263 }
5264
5265 defm PEXTRB      : SS41I_extract8<0x14, "pextrb">;
5266
5267
5268 /// SS41I_extract16 - SSE 4.1 extract 16 bits to memory destination
5269 multiclass SS41I_extract16<bits<8> opc, string OpcodeStr> {
5270   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5271                  (ins i16mem:$dst, VR128:$src1, i32i8imm:$src2),
5272                  !strconcat(OpcodeStr,
5273                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5274                  []>, OpSize;
5275 // FIXME:
5276 // There's an AssertZext in the way of writing the store pattern
5277 // (store (i16 (trunc (X86pextrw (v16i8 VR128:$src1), imm:$src2))), addr:$dst)
5278 }
5279
5280 let Predicates = [HasAVX] in
5281   defm VPEXTRW : SS41I_extract16<0x15, "vpextrw">, VEX;
5282
5283 defm PEXTRW      : SS41I_extract16<0x15, "pextrw">;
5284
5285
5286 /// SS41I_extract32 - SSE 4.1 extract 32 bits to int reg or memory destination
5287 multiclass SS41I_extract32<bits<8> opc, string OpcodeStr> {
5288   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32:$dst),
5289                  (ins VR128:$src1, i32i8imm:$src2),
5290                  !strconcat(OpcodeStr,
5291                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5292                  [(set GR32:$dst,
5293                   (extractelt (v4i32 VR128:$src1), imm:$src2))]>, OpSize;
5294   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5295                  (ins i32mem:$dst, VR128:$src1, i32i8imm:$src2),
5296                  !strconcat(OpcodeStr,
5297                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5298                  [(store (extractelt (v4i32 VR128:$src1), imm:$src2),
5299                           addr:$dst)]>, OpSize;
5300 }
5301
5302 let Predicates = [HasAVX] in
5303   defm VPEXTRD : SS41I_extract32<0x16, "vpextrd">, VEX;
5304
5305 defm PEXTRD      : SS41I_extract32<0x16, "pextrd">;
5306
5307 /// SS41I_extract32 - SSE 4.1 extract 32 bits to int reg or memory destination
5308 multiclass SS41I_extract64<bits<8> opc, string OpcodeStr> {
5309   def rr : SS4AIi8<opc, MRMDestReg, (outs GR64:$dst),
5310                  (ins VR128:$src1, i32i8imm:$src2),
5311                  !strconcat(OpcodeStr,
5312                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5313                  [(set GR64:$dst,
5314                   (extractelt (v2i64 VR128:$src1), imm:$src2))]>, OpSize, REX_W;
5315   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5316                  (ins i64mem:$dst, VR128:$src1, i32i8imm:$src2),
5317                  !strconcat(OpcodeStr,
5318                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5319                  [(store (extractelt (v2i64 VR128:$src1), imm:$src2),
5320                           addr:$dst)]>, OpSize, REX_W;
5321 }
5322
5323 let Predicates = [HasAVX] in
5324   defm VPEXTRQ : SS41I_extract64<0x16, "vpextrq">, VEX, VEX_W;
5325
5326 defm PEXTRQ      : SS41I_extract64<0x16, "pextrq">;
5327
5328 /// SS41I_extractf32 - SSE 4.1 extract 32 bits fp value to int reg or memory
5329 /// destination
5330 multiclass SS41I_extractf32<bits<8> opc, string OpcodeStr> {
5331   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32:$dst),
5332                  (ins VR128:$src1, i32i8imm:$src2),
5333                  !strconcat(OpcodeStr,
5334                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5335                  [(set GR32:$dst,
5336                     (extractelt (bc_v4i32 (v4f32 VR128:$src1)), imm:$src2))]>,
5337            OpSize;
5338   def mr : SS4AIi8<opc, MRMDestMem, (outs),
5339                  (ins f32mem:$dst, VR128:$src1, i32i8imm:$src2),
5340                  !strconcat(OpcodeStr,
5341                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5342                  [(store (extractelt (bc_v4i32 (v4f32 VR128:$src1)), imm:$src2),
5343                           addr:$dst)]>, OpSize;
5344 }
5345
5346 let Predicates = [HasAVX] in {
5347   defm VEXTRACTPS : SS41I_extractf32<0x17, "vextractps">, VEX;
5348   def VEXTRACTPSrr64 : SS4AIi8<0x17, MRMDestReg, (outs GR64:$dst),
5349                   (ins VR128:$src1, i32i8imm:$src2),
5350                   "vextractps \t{$src2, $src1, $dst|$dst, $src1, $src2}",
5351                   []>, OpSize, VEX;
5352 }
5353 defm EXTRACTPS   : SS41I_extractf32<0x17, "extractps">;
5354
5355 // Also match an EXTRACTPS store when the store is done as f32 instead of i32.
5356 def : Pat<(store (f32 (bitconvert (extractelt (bc_v4i32 (v4f32 VR128:$src1)),
5357                                               imm:$src2))),
5358                  addr:$dst),
5359           (EXTRACTPSmr addr:$dst, VR128:$src1, imm:$src2)>,
5360           Requires<[HasSSE41]>;
5361 def : Pat<(store (f32 (bitconvert (extractelt (bc_v4i32 (v4f32 VR128:$src1)),
5362                                               imm:$src2))),
5363                  addr:$dst),
5364           (VEXTRACTPSmr addr:$dst, VR128:$src1, imm:$src2)>,
5365           Requires<[HasAVX]>;
5366
5367 //===----------------------------------------------------------------------===//
5368 // SSE4.1 - Insert Instructions
5369 //===----------------------------------------------------------------------===//
5370
5371 multiclass SS41I_insert8<bits<8> opc, string asm, bit Is2Addr = 1> {
5372   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
5373       (ins VR128:$src1, GR32:$src2, i32i8imm:$src3),
5374       !if(Is2Addr,
5375         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5376         !strconcat(asm,
5377                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5378       [(set VR128:$dst,
5379         (X86pinsrb VR128:$src1, GR32:$src2, imm:$src3))]>, OpSize;
5380   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
5381       (ins VR128:$src1, i8mem:$src2, i32i8imm:$src3),
5382       !if(Is2Addr,
5383         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5384         !strconcat(asm,
5385                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5386       [(set VR128:$dst,
5387         (X86pinsrb VR128:$src1, (extloadi8 addr:$src2),
5388                    imm:$src3))]>, OpSize;
5389 }
5390
5391 let Predicates = [HasAVX] in
5392   defm VPINSRB : SS41I_insert8<0x20, "vpinsrb", 0>, VEX_4V;
5393 let Constraints = "$src1 = $dst" in
5394   defm PINSRB  : SS41I_insert8<0x20, "pinsrb">;
5395
5396 multiclass SS41I_insert32<bits<8> opc, string asm, bit Is2Addr = 1> {
5397   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
5398       (ins VR128:$src1, GR32:$src2, i32i8imm:$src3),
5399       !if(Is2Addr,
5400         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5401         !strconcat(asm,
5402                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5403       [(set VR128:$dst,
5404         (v4i32 (insertelt VR128:$src1, GR32:$src2, imm:$src3)))]>,
5405       OpSize;
5406   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
5407       (ins VR128:$src1, i32mem:$src2, i32i8imm:$src3),
5408       !if(Is2Addr,
5409         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5410         !strconcat(asm,
5411                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5412       [(set VR128:$dst,
5413         (v4i32 (insertelt VR128:$src1, (loadi32 addr:$src2),
5414                           imm:$src3)))]>, OpSize;
5415 }
5416
5417 let Predicates = [HasAVX] in
5418   defm VPINSRD : SS41I_insert32<0x22, "vpinsrd", 0>, VEX_4V;
5419 let Constraints = "$src1 = $dst" in
5420   defm PINSRD : SS41I_insert32<0x22, "pinsrd">;
5421
5422 multiclass SS41I_insert64<bits<8> opc, string asm, bit Is2Addr = 1> {
5423   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
5424       (ins VR128:$src1, GR64:$src2, i32i8imm:$src3),
5425       !if(Is2Addr,
5426         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5427         !strconcat(asm,
5428                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5429       [(set VR128:$dst,
5430         (v2i64 (insertelt VR128:$src1, GR64:$src2, imm:$src3)))]>,
5431       OpSize;
5432   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
5433       (ins VR128:$src1, i64mem:$src2, i32i8imm:$src3),
5434       !if(Is2Addr,
5435         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5436         !strconcat(asm,
5437                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5438       [(set VR128:$dst,
5439         (v2i64 (insertelt VR128:$src1, (loadi64 addr:$src2),
5440                           imm:$src3)))]>, OpSize;
5441 }
5442
5443 let Predicates = [HasAVX] in
5444   defm VPINSRQ : SS41I_insert64<0x22, "vpinsrq", 0>, VEX_4V, VEX_W;
5445 let Constraints = "$src1 = $dst" in
5446   defm PINSRQ : SS41I_insert64<0x22, "pinsrq">, REX_W;
5447
5448 // insertps has a few different modes, there's the first two here below which
5449 // are optimized inserts that won't zero arbitrary elements in the destination
5450 // vector. The next one matches the intrinsic and could zero arbitrary elements
5451 // in the target vector.
5452 multiclass SS41I_insertf32<bits<8> opc, string asm, bit Is2Addr = 1> {
5453   def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
5454       (ins VR128:$src1, VR128:$src2, u32u8imm:$src3),
5455       !if(Is2Addr,
5456         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5457         !strconcat(asm,
5458                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5459       [(set VR128:$dst,
5460         (X86insrtps VR128:$src1, VR128:$src2, imm:$src3))]>,
5461       OpSize;
5462   def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
5463       (ins VR128:$src1, f32mem:$src2, u32u8imm:$src3),
5464       !if(Is2Addr,
5465         !strconcat(asm, "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5466         !strconcat(asm,
5467                    "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5468       [(set VR128:$dst,
5469         (X86insrtps VR128:$src1,
5470                    (v4f32 (scalar_to_vector (loadf32 addr:$src2))),
5471                     imm:$src3))]>, OpSize;
5472 }
5473
5474 let Constraints = "$src1 = $dst" in
5475   defm INSERTPS : SS41I_insertf32<0x21, "insertps">;
5476 let Predicates = [HasAVX] in
5477   defm VINSERTPS : SS41I_insertf32<0x21, "vinsertps", 0>, VEX_4V;
5478
5479 def : Pat<(int_x86_sse41_insertps VR128:$src1, VR128:$src2, imm:$src3),
5480           (VINSERTPSrr VR128:$src1, VR128:$src2, imm:$src3)>,
5481           Requires<[HasAVX]>;
5482 def : Pat<(int_x86_sse41_insertps VR128:$src1, VR128:$src2, imm:$src3),
5483           (INSERTPSrr VR128:$src1, VR128:$src2, imm:$src3)>,
5484           Requires<[HasSSE41]>;
5485
5486 //===----------------------------------------------------------------------===//
5487 // SSE4.1 - Round Instructions
5488 //===----------------------------------------------------------------------===//
5489
5490 multiclass sse41_fp_unop_rm<bits<8> opcps, bits<8> opcpd, string OpcodeStr,
5491                             X86MemOperand x86memop, RegisterClass RC,
5492                             PatFrag mem_frag32, PatFrag mem_frag64,
5493                             Intrinsic V4F32Int, Intrinsic V2F64Int> {
5494   // Intrinsic operation, reg.
5495   // Vector intrinsic operation, reg
5496   def PSr : SS4AIi8<opcps, MRMSrcReg,
5497                     (outs RC:$dst), (ins RC:$src1, i32i8imm:$src2),
5498                     !strconcat(OpcodeStr,
5499                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5500                     [(set RC:$dst, (V4F32Int RC:$src1, imm:$src2))]>,
5501                     OpSize;
5502
5503   // Vector intrinsic operation, mem
5504   def PSm : Ii8<opcps, MRMSrcMem,
5505                     (outs RC:$dst), (ins x86memop:$src1, i32i8imm:$src2),
5506                     !strconcat(OpcodeStr,
5507                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5508                     [(set RC:$dst,
5509                           (V4F32Int (mem_frag32 addr:$src1),imm:$src2))]>,
5510                     TA, OpSize,
5511                 Requires<[HasSSE41]>;
5512
5513   // Vector intrinsic operation, reg
5514   def PDr : SS4AIi8<opcpd, MRMSrcReg,
5515                     (outs RC:$dst), (ins RC:$src1, i32i8imm:$src2),
5516                     !strconcat(OpcodeStr,
5517                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5518                     [(set RC:$dst, (V2F64Int RC:$src1, imm:$src2))]>,
5519                     OpSize;
5520
5521   // Vector intrinsic operation, mem
5522   def PDm : SS4AIi8<opcpd, MRMSrcMem,
5523                     (outs RC:$dst), (ins x86memop:$src1, i32i8imm:$src2),
5524                     !strconcat(OpcodeStr,
5525                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5526                     [(set RC:$dst,
5527                           (V2F64Int (mem_frag64 addr:$src1),imm:$src2))]>,
5528                     OpSize;
5529 }
5530
5531 multiclass sse41_fp_unop_rm_avx_p<bits<8> opcps, bits<8> opcpd,
5532                    RegisterClass RC, X86MemOperand x86memop, string OpcodeStr> {
5533   // Intrinsic operation, reg.
5534   // Vector intrinsic operation, reg
5535   def PSr_AVX : SS4AIi8<opcps, MRMSrcReg,
5536                     (outs RC:$dst), (ins RC:$src1, i32i8imm:$src2),
5537                     !strconcat(OpcodeStr,
5538                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5539                     []>, OpSize;
5540
5541   // Vector intrinsic operation, mem
5542   def PSm_AVX : Ii8<opcps, MRMSrcMem,
5543                     (outs RC:$dst), (ins x86memop:$src1, i32i8imm:$src2),
5544                     !strconcat(OpcodeStr,
5545                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5546                     []>, TA, OpSize, Requires<[HasSSE41]>;
5547
5548   // Vector intrinsic operation, reg
5549   def PDr_AVX : SS4AIi8<opcpd, MRMSrcReg,
5550                     (outs RC:$dst), (ins RC:$src1, i32i8imm:$src2),
5551                     !strconcat(OpcodeStr,
5552                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5553                     []>, OpSize;
5554
5555   // Vector intrinsic operation, mem
5556   def PDm_AVX : SS4AIi8<opcpd, MRMSrcMem,
5557                     (outs RC:$dst), (ins x86memop:$src1, i32i8imm:$src2),
5558                     !strconcat(OpcodeStr,
5559                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
5560                     []>, OpSize;
5561 }
5562
5563 multiclass sse41_fp_binop_rm<bits<8> opcss, bits<8> opcsd,
5564                             string OpcodeStr,
5565                             Intrinsic F32Int,
5566                             Intrinsic F64Int, bit Is2Addr = 1> {
5567   // Intrinsic operation, reg.
5568   def SSr : SS4AIi8<opcss, MRMSrcReg,
5569         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
5570         !if(Is2Addr,
5571             !strconcat(OpcodeStr,
5572                 "ss\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5573             !strconcat(OpcodeStr,
5574                 "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5575         [(set VR128:$dst, (F32Int VR128:$src1, VR128:$src2, imm:$src3))]>,
5576         OpSize;
5577
5578   // Intrinsic operation, mem.
5579   def SSm : SS4AIi8<opcss, MRMSrcMem,
5580         (outs VR128:$dst), (ins VR128:$src1, ssmem:$src2, i32i8imm:$src3),
5581         !if(Is2Addr,
5582             !strconcat(OpcodeStr,
5583                 "ss\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5584             !strconcat(OpcodeStr,
5585                 "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5586         [(set VR128:$dst,
5587              (F32Int VR128:$src1, sse_load_f32:$src2, imm:$src3))]>,
5588         OpSize;
5589
5590   // Intrinsic operation, reg.
5591   def SDr : SS4AIi8<opcsd, MRMSrcReg,
5592         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
5593         !if(Is2Addr,
5594             !strconcat(OpcodeStr,
5595                 "sd\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5596             !strconcat(OpcodeStr,
5597                 "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5598         [(set VR128:$dst, (F64Int VR128:$src1, VR128:$src2, imm:$src3))]>,
5599         OpSize;
5600
5601   // Intrinsic operation, mem.
5602   def SDm : SS4AIi8<opcsd, MRMSrcMem,
5603         (outs VR128:$dst), (ins VR128:$src1, sdmem:$src2, i32i8imm:$src3),
5604         !if(Is2Addr,
5605             !strconcat(OpcodeStr,
5606                 "sd\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5607             !strconcat(OpcodeStr,
5608                 "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5609         [(set VR128:$dst,
5610               (F64Int VR128:$src1, sse_load_f64:$src2, imm:$src3))]>,
5611         OpSize;
5612 }
5613
5614 multiclass sse41_fp_binop_rm_avx_s<bits<8> opcss, bits<8> opcsd,
5615                                    string OpcodeStr> {
5616   // Intrinsic operation, reg.
5617   def SSr_AVX : SS4AIi8<opcss, MRMSrcReg,
5618         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
5619         !strconcat(OpcodeStr,
5620                 "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5621         []>, OpSize;
5622
5623   // Intrinsic operation, mem.
5624   def SSm_AVX : SS4AIi8<opcss, MRMSrcMem,
5625         (outs VR128:$dst), (ins VR128:$src1, ssmem:$src2, i32i8imm:$src3),
5626         !strconcat(OpcodeStr,
5627                 "ss\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5628         []>, OpSize;
5629
5630   // Intrinsic operation, reg.
5631   def SDr_AVX : SS4AIi8<opcsd, MRMSrcReg,
5632         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
5633             !strconcat(OpcodeStr,
5634                 "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5635         []>, OpSize;
5636
5637   // Intrinsic operation, mem.
5638   def SDm_AVX : SS4AIi8<opcsd, MRMSrcMem,
5639         (outs VR128:$dst), (ins VR128:$src1, sdmem:$src2, i32i8imm:$src3),
5640             !strconcat(OpcodeStr,
5641                 "sd\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5642         []>, OpSize;
5643 }
5644
5645 // FP round - roundss, roundps, roundsd, roundpd
5646 let Predicates = [HasAVX] in {
5647   // Intrinsic form
5648   defm VROUND  : sse41_fp_unop_rm<0x08, 0x09, "vround", f128mem, VR128,
5649                                   memopv4f32, memopv2f64,
5650                                   int_x86_sse41_round_ps,
5651                                   int_x86_sse41_round_pd>, VEX;
5652   defm VROUNDY : sse41_fp_unop_rm<0x08, 0x09, "vround", f256mem, VR256,
5653                                   memopv8f32, memopv4f64,
5654                                   int_x86_avx_round_ps_256,
5655                                   int_x86_avx_round_pd_256>, VEX;
5656   defm VROUND  : sse41_fp_binop_rm<0x0A, 0x0B, "vround",
5657                                   int_x86_sse41_round_ss,
5658                                   int_x86_sse41_round_sd, 0>, VEX_4V;
5659
5660   // Instructions for the assembler
5661   defm VROUND  : sse41_fp_unop_rm_avx_p<0x08, 0x09, VR128, f128mem, "vround">,
5662                                         VEX;
5663   defm VROUNDY : sse41_fp_unop_rm_avx_p<0x08, 0x09, VR256, f256mem, "vround">,
5664                                         VEX;
5665   defm VROUND  : sse41_fp_binop_rm_avx_s<0x0A, 0x0B, "vround">, VEX_4V;
5666 }
5667
5668 defm ROUND  : sse41_fp_unop_rm<0x08, 0x09, "round", f128mem, VR128,
5669                                memopv4f32, memopv2f64,
5670                                int_x86_sse41_round_ps, int_x86_sse41_round_pd>;
5671 let Constraints = "$src1 = $dst" in
5672 defm ROUND  : sse41_fp_binop_rm<0x0A, 0x0B, "round",
5673                                int_x86_sse41_round_ss, int_x86_sse41_round_sd>;
5674
5675 //===----------------------------------------------------------------------===//
5676 // SSE4.1 - Packed Bit Test
5677 //===----------------------------------------------------------------------===//
5678
5679 // ptest instruction we'll lower to this in X86ISelLowering primarily from
5680 // the intel intrinsic that corresponds to this.
5681 let Defs = [EFLAGS], Predicates = [HasAVX] in {
5682 def VPTESTrr  : SS48I<0x17, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
5683                 "vptest\t{$src2, $src1|$src1, $src2}",
5684                 [(set EFLAGS, (X86ptest VR128:$src1, (v4f32 VR128:$src2)))]>,
5685                 OpSize, VEX;
5686 def VPTESTrm  : SS48I<0x17, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
5687                 "vptest\t{$src2, $src1|$src1, $src2}",
5688                 [(set EFLAGS,(X86ptest VR128:$src1, (memopv4f32 addr:$src2)))]>,
5689                 OpSize, VEX;
5690
5691 def VPTESTYrr : SS48I<0x17, MRMSrcReg, (outs), (ins VR256:$src1, VR256:$src2),
5692                 "vptest\t{$src2, $src1|$src1, $src2}",
5693                 [(set EFLAGS, (X86ptest VR256:$src1, (v4i64 VR256:$src2)))]>,
5694                 OpSize, VEX;
5695 def VPTESTYrm : SS48I<0x17, MRMSrcMem, (outs), (ins VR256:$src1, i256mem:$src2),
5696                 "vptest\t{$src2, $src1|$src1, $src2}",
5697                 [(set EFLAGS,(X86ptest VR256:$src1, (memopv4i64 addr:$src2)))]>,
5698                 OpSize, VEX;
5699 }
5700
5701 let Defs = [EFLAGS] in {
5702 def PTESTrr : SS48I<0x17, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
5703               "ptest \t{$src2, $src1|$src1, $src2}",
5704               [(set EFLAGS, (X86ptest VR128:$src1, (v4f32 VR128:$src2)))]>,
5705               OpSize;
5706 def PTESTrm : SS48I<0x17, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
5707               "ptest \t{$src2, $src1|$src1, $src2}",
5708               [(set EFLAGS, (X86ptest VR128:$src1, (memopv4f32 addr:$src2)))]>,
5709               OpSize;
5710 }
5711
5712 // The bit test instructions below are AVX only
5713 multiclass avx_bittest<bits<8> opc, string OpcodeStr, RegisterClass RC,
5714                        X86MemOperand x86memop, PatFrag mem_frag, ValueType vt> {
5715   def rr : SS48I<opc, MRMSrcReg, (outs), (ins RC:$src1, RC:$src2),
5716             !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
5717             [(set EFLAGS, (X86testp RC:$src1, (vt RC:$src2)))]>, OpSize, VEX;
5718   def rm : SS48I<opc, MRMSrcMem, (outs), (ins RC:$src1, x86memop:$src2),
5719             !strconcat(OpcodeStr, "\t{$src2, $src1|$src1, $src2}"),
5720             [(set EFLAGS, (X86testp RC:$src1, (mem_frag addr:$src2)))]>,
5721             OpSize, VEX;
5722 }
5723
5724 let Defs = [EFLAGS], Predicates = [HasAVX] in {
5725 defm VTESTPS  : avx_bittest<0x0E, "vtestps", VR128, f128mem, memopv4f32, v4f32>;
5726 defm VTESTPSY : avx_bittest<0x0E, "vtestps", VR256, f256mem, memopv8f32, v8f32>;
5727 defm VTESTPD  : avx_bittest<0x0F, "vtestpd", VR128, f128mem, memopv2f64, v2f64>;
5728 defm VTESTPDY : avx_bittest<0x0F, "vtestpd", VR256, f256mem, memopv4f64, v4f64>;
5729 }
5730
5731 //===----------------------------------------------------------------------===//
5732 // SSE4.1 - Misc Instructions
5733 //===----------------------------------------------------------------------===//
5734
5735 def POPCNT16rr : I<0xB8, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
5736                    "popcnt{w}\t{$src, $dst|$dst, $src}",
5737                    [(set GR16:$dst, (ctpop GR16:$src))]>, OpSize, XS;
5738 def POPCNT16rm : I<0xB8, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
5739                    "popcnt{w}\t{$src, $dst|$dst, $src}",
5740                    [(set GR16:$dst, (ctpop (loadi16 addr:$src)))]>, OpSize, XS;
5741
5742 def POPCNT32rr : I<0xB8, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
5743                    "popcnt{l}\t{$src, $dst|$dst, $src}",
5744                    [(set GR32:$dst, (ctpop GR32:$src))]>, XS;
5745 def POPCNT32rm : I<0xB8, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
5746                    "popcnt{l}\t{$src, $dst|$dst, $src}",
5747                    [(set GR32:$dst, (ctpop (loadi32 addr:$src)))]>, XS;
5748
5749 def POPCNT64rr : RI<0xB8, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
5750                     "popcnt{q}\t{$src, $dst|$dst, $src}",
5751                     [(set GR64:$dst, (ctpop GR64:$src))]>, XS;
5752 def POPCNT64rm : RI<0xB8, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
5753                     "popcnt{q}\t{$src, $dst|$dst, $src}",
5754                     [(set GR64:$dst, (ctpop (loadi64 addr:$src)))]>, XS;
5755
5756
5757
5758 // SS41I_unop_rm_int_v16 - SSE 4.1 unary operator whose type is v8i16.
5759 multiclass SS41I_unop_rm_int_v16<bits<8> opc, string OpcodeStr,
5760                                  Intrinsic IntId128> {
5761   def rr128 : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
5762                     (ins VR128:$src),
5763                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5764                     [(set VR128:$dst, (IntId128 VR128:$src))]>, OpSize;
5765   def rm128 : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
5766                      (ins i128mem:$src),
5767                      !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
5768                      [(set VR128:$dst,
5769                        (IntId128
5770                        (bitconvert (memopv8i16 addr:$src))))]>, OpSize;
5771 }
5772
5773 let Predicates = [HasAVX] in
5774 defm VPHMINPOSUW : SS41I_unop_rm_int_v16 <0x41, "vphminposuw",
5775                                          int_x86_sse41_phminposuw>, VEX;
5776 defm PHMINPOSUW : SS41I_unop_rm_int_v16 <0x41, "phminposuw",
5777                                          int_x86_sse41_phminposuw>;
5778
5779 /// SS41I_binop_rm_int - Simple SSE 4.1 binary operator
5780 multiclass SS41I_binop_rm_int<bits<8> opc, string OpcodeStr,
5781                               Intrinsic IntId128, bit Is2Addr = 1> {
5782   let isCommutable = 1 in
5783   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
5784        (ins VR128:$src1, VR128:$src2),
5785        !if(Is2Addr,
5786            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5787            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5788        [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>, OpSize;
5789   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
5790        (ins VR128:$src1, i128mem:$src2),
5791        !if(Is2Addr,
5792            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5793            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5794        [(set VR128:$dst,
5795          (IntId128 VR128:$src1,
5796           (bitconvert (memopv16i8 addr:$src2))))]>, OpSize;
5797 }
5798
5799 let Predicates = [HasAVX] in {
5800   let isCommutable = 0 in
5801   defm VPACKUSDW : SS41I_binop_rm_int<0x2B, "vpackusdw", int_x86_sse41_packusdw,
5802                                                          0>, VEX_4V;
5803   defm VPCMPEQQ  : SS41I_binop_rm_int<0x29, "vpcmpeqq",  int_x86_sse41_pcmpeqq,
5804                                                          0>, VEX_4V;
5805   defm VPMINSB   : SS41I_binop_rm_int<0x38, "vpminsb",   int_x86_sse41_pminsb,
5806                                                          0>, VEX_4V;
5807   defm VPMINSD   : SS41I_binop_rm_int<0x39, "vpminsd",   int_x86_sse41_pminsd,
5808                                                          0>, VEX_4V;
5809   defm VPMINUD   : SS41I_binop_rm_int<0x3B, "vpminud",   int_x86_sse41_pminud,
5810                                                          0>, VEX_4V;
5811   defm VPMINUW   : SS41I_binop_rm_int<0x3A, "vpminuw",   int_x86_sse41_pminuw,
5812                                                          0>, VEX_4V;
5813   defm VPMAXSB   : SS41I_binop_rm_int<0x3C, "vpmaxsb",   int_x86_sse41_pmaxsb,
5814                                                          0>, VEX_4V;
5815   defm VPMAXSD   : SS41I_binop_rm_int<0x3D, "vpmaxsd",   int_x86_sse41_pmaxsd,
5816                                                          0>, VEX_4V;
5817   defm VPMAXUD   : SS41I_binop_rm_int<0x3F, "vpmaxud",   int_x86_sse41_pmaxud,
5818                                                          0>, VEX_4V;
5819   defm VPMAXUW   : SS41I_binop_rm_int<0x3E, "vpmaxuw",   int_x86_sse41_pmaxuw,
5820                                                          0>, VEX_4V;
5821   defm VPMULDQ   : SS41I_binop_rm_int<0x28, "vpmuldq",   int_x86_sse41_pmuldq,
5822                                                          0>, VEX_4V;
5823
5824   def : Pat<(v2i64 (X86pcmpeqq VR128:$src1, VR128:$src2)),
5825             (VPCMPEQQrr VR128:$src1, VR128:$src2)>;
5826   def : Pat<(v2i64 (X86pcmpeqq VR128:$src1, (memop addr:$src2))),
5827             (VPCMPEQQrm VR128:$src1, addr:$src2)>;
5828 }
5829
5830 let Constraints = "$src1 = $dst" in {
5831   let isCommutable = 0 in
5832   defm PACKUSDW : SS41I_binop_rm_int<0x2B, "packusdw", int_x86_sse41_packusdw>;
5833   defm PCMPEQQ  : SS41I_binop_rm_int<0x29, "pcmpeqq",  int_x86_sse41_pcmpeqq>;
5834   defm PMINSB   : SS41I_binop_rm_int<0x38, "pminsb",   int_x86_sse41_pminsb>;
5835   defm PMINSD   : SS41I_binop_rm_int<0x39, "pminsd",   int_x86_sse41_pminsd>;
5836   defm PMINUD   : SS41I_binop_rm_int<0x3B, "pminud",   int_x86_sse41_pminud>;
5837   defm PMINUW   : SS41I_binop_rm_int<0x3A, "pminuw",   int_x86_sse41_pminuw>;
5838   defm PMAXSB   : SS41I_binop_rm_int<0x3C, "pmaxsb",   int_x86_sse41_pmaxsb>;
5839   defm PMAXSD   : SS41I_binop_rm_int<0x3D, "pmaxsd",   int_x86_sse41_pmaxsd>;
5840   defm PMAXUD   : SS41I_binop_rm_int<0x3F, "pmaxud",   int_x86_sse41_pmaxud>;
5841   defm PMAXUW   : SS41I_binop_rm_int<0x3E, "pmaxuw",   int_x86_sse41_pmaxuw>;
5842   defm PMULDQ   : SS41I_binop_rm_int<0x28, "pmuldq",   int_x86_sse41_pmuldq>;
5843 }
5844
5845 def : Pat<(v2i64 (X86pcmpeqq VR128:$src1, VR128:$src2)),
5846           (PCMPEQQrr VR128:$src1, VR128:$src2)>;
5847 def : Pat<(v2i64 (X86pcmpeqq VR128:$src1, (memop addr:$src2))),
5848           (PCMPEQQrm VR128:$src1, addr:$src2)>;
5849
5850 /// SS48I_binop_rm - Simple SSE41 binary operator.
5851 multiclass SS48I_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
5852                         ValueType OpVT, bit Is2Addr = 1> {
5853   let isCommutable = 1 in
5854   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
5855        (ins VR128:$src1, VR128:$src2),
5856        !if(Is2Addr,
5857            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5858            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5859        [(set VR128:$dst, (OpVT (OpNode VR128:$src1, VR128:$src2)))]>,
5860        OpSize;
5861   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
5862        (ins VR128:$src1, i128mem:$src2),
5863        !if(Is2Addr,
5864            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
5865            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
5866        [(set VR128:$dst, (OpNode VR128:$src1,
5867                                   (bc_v4i32 (memopv2i64 addr:$src2))))]>,
5868        OpSize;
5869 }
5870
5871 let Predicates = [HasAVX] in
5872   defm VPMULLD : SS48I_binop_rm<0x40, "vpmulld", mul, v4i32, 0>, VEX_4V;
5873 let Constraints = "$src1 = $dst" in
5874   defm PMULLD : SS48I_binop_rm<0x40, "pmulld", mul, v4i32>;
5875
5876 /// SS41I_binop_rmi_int - SSE 4.1 binary operator with 8-bit immediate
5877 multiclass SS41I_binop_rmi_int<bits<8> opc, string OpcodeStr,
5878                  Intrinsic IntId, RegisterClass RC, PatFrag memop_frag,
5879                  X86MemOperand x86memop, bit Is2Addr = 1> {
5880   let isCommutable = 1 in
5881   def rri : SS4AIi8<opc, MRMSrcReg, (outs RC:$dst),
5882         (ins RC:$src1, RC:$src2, u32u8imm:$src3),
5883         !if(Is2Addr,
5884             !strconcat(OpcodeStr,
5885                 "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5886             !strconcat(OpcodeStr,
5887                 "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5888         [(set RC:$dst, (IntId RC:$src1, RC:$src2, imm:$src3))]>,
5889         OpSize;
5890   def rmi : SS4AIi8<opc, MRMSrcMem, (outs RC:$dst),
5891         (ins RC:$src1, x86memop:$src2, u32u8imm:$src3),
5892         !if(Is2Addr,
5893             !strconcat(OpcodeStr,
5894                 "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
5895             !strconcat(OpcodeStr,
5896                 "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}")),
5897         [(set RC:$dst,
5898           (IntId RC:$src1,
5899            (bitconvert (memop_frag addr:$src2)), imm:$src3))]>,
5900         OpSize;
5901 }
5902
5903 let Predicates = [HasAVX] in {
5904   let isCommutable = 0 in {
5905   defm VBLENDPS : SS41I_binop_rmi_int<0x0C, "vblendps", int_x86_sse41_blendps,
5906                                       VR128, memopv16i8, i128mem, 0>, VEX_4V;
5907   defm VBLENDPD : SS41I_binop_rmi_int<0x0D, "vblendpd", int_x86_sse41_blendpd,
5908                                       VR128, memopv16i8, i128mem, 0>, VEX_4V;
5909   defm VBLENDPSY : SS41I_binop_rmi_int<0x0C, "vblendps",
5910             int_x86_avx_blend_ps_256, VR256, memopv32i8, i256mem, 0>, VEX_4V;
5911   defm VBLENDPDY : SS41I_binop_rmi_int<0x0D, "vblendpd",
5912             int_x86_avx_blend_pd_256, VR256, memopv32i8, i256mem, 0>, VEX_4V;
5913   defm VPBLENDW : SS41I_binop_rmi_int<0x0E, "vpblendw", int_x86_sse41_pblendw,
5914                                       VR128, memopv16i8, i128mem, 0>, VEX_4V;
5915   defm VMPSADBW : SS41I_binop_rmi_int<0x42, "vmpsadbw", int_x86_sse41_mpsadbw,
5916                                       VR128, memopv16i8, i128mem, 0>, VEX_4V;
5917   }
5918   defm VDPPS : SS41I_binop_rmi_int<0x40, "vdpps", int_x86_sse41_dpps,
5919                                    VR128, memopv16i8, i128mem, 0>, VEX_4V;
5920   defm VDPPD : SS41I_binop_rmi_int<0x41, "vdppd", int_x86_sse41_dppd,
5921                                    VR128, memopv16i8, i128mem, 0>, VEX_4V;
5922   defm VDPPSY : SS41I_binop_rmi_int<0x40, "vdpps", int_x86_avx_dp_ps_256,
5923                                    VR256, memopv32i8, i256mem, 0>, VEX_4V;
5924 }
5925
5926 let Constraints = "$src1 = $dst" in {
5927   let isCommutable = 0 in {
5928   defm BLENDPS : SS41I_binop_rmi_int<0x0C, "blendps", int_x86_sse41_blendps,
5929                                      VR128, memopv16i8, i128mem>;
5930   defm BLENDPD : SS41I_binop_rmi_int<0x0D, "blendpd", int_x86_sse41_blendpd,
5931                                      VR128, memopv16i8, i128mem>;
5932   defm PBLENDW : SS41I_binop_rmi_int<0x0E, "pblendw", int_x86_sse41_pblendw,
5933                                      VR128, memopv16i8, i128mem>;
5934   defm MPSADBW : SS41I_binop_rmi_int<0x42, "mpsadbw", int_x86_sse41_mpsadbw,
5935                                      VR128, memopv16i8, i128mem>;
5936   }
5937   defm DPPS : SS41I_binop_rmi_int<0x40, "dpps", int_x86_sse41_dpps,
5938                                   VR128, memopv16i8, i128mem>;
5939   defm DPPD : SS41I_binop_rmi_int<0x41, "dppd", int_x86_sse41_dppd,
5940                                   VR128, memopv16i8, i128mem>;
5941 }
5942
5943 /// SS41I_quaternary_int_avx - AVX SSE 4.1 with 4 operators
5944 let Predicates = [HasAVX] in {
5945 multiclass SS41I_quaternary_int_avx<bits<8> opc, string OpcodeStr,
5946                                     RegisterClass RC, X86MemOperand x86memop,
5947                                     PatFrag mem_frag, Intrinsic IntId> {
5948   def rr : I<opc, MRMSrcReg, (outs RC:$dst),
5949                   (ins RC:$src1, RC:$src2, RC:$src3),
5950                   !strconcat(OpcodeStr,
5951                     "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5952                   [(set RC:$dst, (IntId RC:$src1, RC:$src2, RC:$src3))],
5953                   SSEPackedInt>, OpSize, TA, VEX_4V, VEX_I8IMM;
5954
5955   def rm : I<opc, MRMSrcMem, (outs RC:$dst),
5956                   (ins RC:$src1, x86memop:$src2, RC:$src3),
5957                   !strconcat(OpcodeStr,
5958                     "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
5959                   [(set RC:$dst,
5960                         (IntId RC:$src1, (bitconvert (mem_frag addr:$src2)),
5961                                RC:$src3))],
5962                   SSEPackedInt>, OpSize, TA, VEX_4V, VEX_I8IMM;
5963 }
5964 }
5965
5966 defm VBLENDVPD  : SS41I_quaternary_int_avx<0x4B, "vblendvpd", VR128, i128mem,
5967                                            memopv16i8, int_x86_sse41_blendvpd>;
5968 defm VBLENDVPS  : SS41I_quaternary_int_avx<0x4A, "vblendvps", VR128, i128mem,
5969                                            memopv16i8, int_x86_sse41_blendvps>;
5970 defm VPBLENDVB  : SS41I_quaternary_int_avx<0x4C, "vpblendvb", VR128, i128mem,
5971                                            memopv16i8, int_x86_sse41_pblendvb>;
5972 defm VBLENDVPDY : SS41I_quaternary_int_avx<0x4B, "vblendvpd", VR256, i256mem,
5973                                          memopv32i8, int_x86_avx_blendv_pd_256>;
5974 defm VBLENDVPSY : SS41I_quaternary_int_avx<0x4A, "vblendvps", VR256, i256mem,
5975                                          memopv32i8, int_x86_avx_blendv_ps_256>;
5976
5977 let Predicates = [HasAVX] in {
5978   def : Pat<(v16i8 (vselect (v16i8 VR128:$mask), (v16i8 VR128:$src1),
5979                             (v16i8 VR128:$src2))),
5980             (VPBLENDVBrr VR128:$src2, VR128:$src1, VR128:$mask)>;
5981   def : Pat<(v4i32 (vselect (v4i32 VR128:$mask), (v4i32 VR128:$src1),
5982                             (v4i32 VR128:$src2))),
5983             (VBLENDVPSrr VR128:$src2, VR128:$src1, VR128:$mask)>;
5984   def : Pat<(v4f32 (vselect (v4i32 VR128:$mask), (v4f32 VR128:$src1),
5985                             (v4f32 VR128:$src2))),
5986             (VBLENDVPSrr VR128:$src2, VR128:$src1, VR128:$mask)>;
5987   def : Pat<(v2i64 (vselect (v2i64 VR128:$mask), (v2i64 VR128:$src1),
5988                             (v2i64 VR128:$src2))),
5989             (VBLENDVPDrr VR128:$src2, VR128:$src1, VR128:$mask)>;
5990   def : Pat<(v2f64 (vselect (v2i64 VR128:$mask), (v2f64 VR128:$src1),
5991                             (v2f64 VR128:$src2))),
5992             (VBLENDVPDrr VR128:$src2, VR128:$src1, VR128:$mask)>;
5993   def : Pat<(v8i32 (vselect (v8i32 VR256:$mask), (v8i32 VR256:$src1),
5994                             (v8i32 VR256:$src2))),
5995             (VBLENDVPSYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
5996   def : Pat<(v8f32 (vselect (v8i32 VR256:$mask), (v8f32 VR256:$src1),
5997                             (v8f32 VR256:$src2))),
5998             (VBLENDVPSYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
5999   def : Pat<(v4i64 (vselect (v4i64 VR256:$mask), (v4i64 VR256:$src1),
6000                             (v4i64 VR256:$src2))),
6001             (VBLENDVPDYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
6002   def : Pat<(v4f64 (vselect (v4i64 VR256:$mask), (v4f64 VR256:$src1),
6003                             (v4f64 VR256:$src2))),
6004             (VBLENDVPDYrr VR256:$src2, VR256:$src1, VR256:$mask)>;
6005 }
6006
6007 /// SS41I_ternary_int - SSE 4.1 ternary operator
6008 let Uses = [XMM0], Constraints = "$src1 = $dst" in {
6009   multiclass SS41I_ternary_int<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
6010     def rr0 : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
6011                     (ins VR128:$src1, VR128:$src2),
6012                     !strconcat(OpcodeStr,
6013                      "\t{$src2, $dst|$dst, $src2}"),
6014                     [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2, XMM0))]>,
6015                     OpSize;
6016
6017     def rm0 : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
6018                     (ins VR128:$src1, i128mem:$src2),
6019                     !strconcat(OpcodeStr,
6020                      "\t{$src2, $dst|$dst, $src2}"),
6021                     [(set VR128:$dst,
6022                       (IntId VR128:$src1,
6023                        (bitconvert (memopv16i8 addr:$src2)), XMM0))]>, OpSize;
6024   }
6025 }
6026
6027 defm BLENDVPD : SS41I_ternary_int<0x15, "blendvpd", int_x86_sse41_blendvpd>;
6028 defm BLENDVPS : SS41I_ternary_int<0x14, "blendvps", int_x86_sse41_blendvps>;
6029 defm PBLENDVB : SS41I_ternary_int<0x10, "pblendvb", int_x86_sse41_pblendvb>;
6030
6031 let Predicates = [HasSSE41] in {
6032   def : Pat<(v16i8 (vselect (v16i8 XMM0), (v16i8 VR128:$src1),
6033                             (v16i8 VR128:$src2))),
6034             (PBLENDVBrr0 VR128:$src2, VR128:$src1)>;
6035   def : Pat<(v4i32 (vselect (v4i32 XMM0), (v4i32 VR128:$src1),
6036                             (v4i32 VR128:$src2))),
6037             (BLENDVPSrr0 VR128:$src2, VR128:$src1)>;
6038   def : Pat<(v4f32 (vselect (v4i32 XMM0), (v4f32 VR128:$src1),
6039                             (v4f32 VR128:$src2))),
6040             (BLENDVPSrr0 VR128:$src2, VR128:$src1)>;
6041   def : Pat<(v2i64 (vselect (v2i64 XMM0), (v2i64 VR128:$src1),
6042                             (v2i64 VR128:$src2))),
6043             (BLENDVPDrr0 VR128:$src2, VR128:$src1)>;
6044   def : Pat<(v2f64 (vselect (v2i64 XMM0), (v2f64 VR128:$src1),
6045                             (v2f64 VR128:$src2))),
6046             (BLENDVPDrr0 VR128:$src2, VR128:$src1)>;
6047 }
6048
6049 let Predicates = [HasAVX] in
6050 def VMOVNTDQArm : SS48I<0x2A, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
6051                        "vmovntdqa\t{$src, $dst|$dst, $src}",
6052                        [(set VR128:$dst, (int_x86_sse41_movntdqa addr:$src))]>,
6053                        OpSize, VEX;
6054 def MOVNTDQArm : SS48I<0x2A, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
6055                        "movntdqa\t{$src, $dst|$dst, $src}",
6056                        [(set VR128:$dst, (int_x86_sse41_movntdqa addr:$src))]>,
6057                        OpSize;
6058
6059 //===----------------------------------------------------------------------===//
6060 // SSE4.2 - Compare Instructions
6061 //===----------------------------------------------------------------------===//
6062
6063 /// SS42I_binop_rm_int - Simple SSE 4.2 binary operator
6064 multiclass SS42I_binop_rm_int<bits<8> opc, string OpcodeStr,
6065                               Intrinsic IntId128, bit Is2Addr = 1> {
6066   def rr : SS428I<opc, MRMSrcReg, (outs VR128:$dst),
6067        (ins VR128:$src1, VR128:$src2),
6068        !if(Is2Addr,
6069            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6070            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6071        [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
6072        OpSize;
6073   def rm : SS428I<opc, MRMSrcMem, (outs VR128:$dst),
6074        (ins VR128:$src1, i128mem:$src2),
6075        !if(Is2Addr,
6076            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6077            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6078        [(set VR128:$dst,
6079          (IntId128 VR128:$src1,
6080           (bitconvert (memopv16i8 addr:$src2))))]>, OpSize;
6081 }
6082
6083 let Predicates = [HasAVX] in {
6084   defm VPCMPGTQ : SS42I_binop_rm_int<0x37, "vpcmpgtq", int_x86_sse42_pcmpgtq,
6085                                      0>, VEX_4V;
6086
6087   def : Pat<(v2i64 (X86pcmpgtq VR128:$src1, VR128:$src2)),
6088             (VPCMPGTQrr VR128:$src1, VR128:$src2)>;
6089   def : Pat<(v2i64 (X86pcmpgtq VR128:$src1, (memop addr:$src2))),
6090             (VPCMPGTQrm VR128:$src1, addr:$src2)>;
6091 }
6092
6093 let Constraints = "$src1 = $dst" in
6094   defm PCMPGTQ : SS42I_binop_rm_int<0x37, "pcmpgtq", int_x86_sse42_pcmpgtq>;
6095
6096 def : Pat<(v2i64 (X86pcmpgtq VR128:$src1, VR128:$src2)),
6097           (PCMPGTQrr VR128:$src1, VR128:$src2)>;
6098 def : Pat<(v2i64 (X86pcmpgtq VR128:$src1, (memop addr:$src2))),
6099           (PCMPGTQrm VR128:$src1, addr:$src2)>;
6100
6101 //===----------------------------------------------------------------------===//
6102 // SSE4.2 - String/text Processing Instructions
6103 //===----------------------------------------------------------------------===//
6104
6105 // Packed Compare Implicit Length Strings, Return Mask
6106 multiclass pseudo_pcmpistrm<string asm> {
6107   def REG : PseudoI<(outs VR128:$dst),
6108                     (ins VR128:$src1, VR128:$src2, i8imm:$src3),
6109     [(set VR128:$dst, (int_x86_sse42_pcmpistrm128 VR128:$src1, VR128:$src2,
6110                                                   imm:$src3))]>;
6111   def MEM : PseudoI<(outs VR128:$dst),
6112                     (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
6113     [(set VR128:$dst, (int_x86_sse42_pcmpistrm128
6114                        VR128:$src1, (load addr:$src2), imm:$src3))]>;
6115 }
6116
6117 let Defs = [EFLAGS], usesCustomInserter = 1 in {
6118   defm PCMPISTRM128 : pseudo_pcmpistrm<"#PCMPISTRM128">, Requires<[HasSSE42]>;
6119   defm VPCMPISTRM128 : pseudo_pcmpistrm<"#VPCMPISTRM128">, Requires<[HasAVX]>;
6120 }
6121
6122 let Defs = [XMM0, EFLAGS], Predicates = [HasAVX] in {
6123   def VPCMPISTRM128rr : SS42AI<0x62, MRMSrcReg, (outs),
6124       (ins VR128:$src1, VR128:$src2, i8imm:$src3),
6125       "vpcmpistrm\t{$src3, $src2, $src1|$src1, $src2, $src3}", []>, OpSize, VEX;
6126   def VPCMPISTRM128rm : SS42AI<0x62, MRMSrcMem, (outs),
6127       (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
6128       "vpcmpistrm\t{$src3, $src2, $src1|$src1, $src2, $src3}", []>, OpSize, VEX;
6129 }
6130
6131 let Defs = [XMM0, EFLAGS] in {
6132   def PCMPISTRM128rr : SS42AI<0x62, MRMSrcReg, (outs),
6133       (ins VR128:$src1, VR128:$src2, i8imm:$src3),
6134       "pcmpistrm\t{$src3, $src2, $src1|$src1, $src2, $src3}", []>, OpSize;
6135   def PCMPISTRM128rm : SS42AI<0x62, MRMSrcMem, (outs),
6136       (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
6137       "pcmpistrm\t{$src3, $src2, $src1|$src1, $src2, $src3}", []>, OpSize;
6138 }
6139
6140 // Packed Compare Explicit Length Strings, Return Mask
6141 multiclass pseudo_pcmpestrm<string asm> {
6142   def REG : PseudoI<(outs VR128:$dst),
6143                     (ins VR128:$src1, VR128:$src3, i8imm:$src5),
6144     [(set VR128:$dst, (int_x86_sse42_pcmpestrm128
6145                        VR128:$src1, EAX, VR128:$src3, EDX, imm:$src5))]>;
6146   def MEM : PseudoI<(outs VR128:$dst),
6147                     (ins VR128:$src1, i128mem:$src3, i8imm:$src5),
6148     [(set VR128:$dst, (int_x86_sse42_pcmpestrm128
6149                        VR128:$src1, EAX, (load addr:$src3), EDX, imm:$src5))]>;
6150 }
6151
6152 let Defs = [EFLAGS], Uses = [EAX, EDX], usesCustomInserter = 1 in {
6153   defm PCMPESTRM128 : pseudo_pcmpestrm<"#PCMPESTRM128">, Requires<[HasSSE42]>;
6154   defm VPCMPESTRM128 : pseudo_pcmpestrm<"#VPCMPESTRM128">, Requires<[HasAVX]>;
6155 }
6156
6157 let Predicates = [HasAVX],
6158     Defs = [XMM0, EFLAGS], Uses = [EAX, EDX] in {
6159   def VPCMPESTRM128rr : SS42AI<0x60, MRMSrcReg, (outs),
6160       (ins VR128:$src1, VR128:$src3, i8imm:$src5),
6161       "vpcmpestrm\t{$src5, $src3, $src1|$src1, $src3, $src5}", []>, OpSize, VEX;
6162   def VPCMPESTRM128rm : SS42AI<0x60, MRMSrcMem, (outs),
6163       (ins VR128:$src1, i128mem:$src3, i8imm:$src5),
6164       "vpcmpestrm\t{$src5, $src3, $src1|$src1, $src3, $src5}", []>, OpSize, VEX;
6165 }
6166
6167 let Defs = [XMM0, EFLAGS], Uses = [EAX, EDX] in {
6168   def PCMPESTRM128rr : SS42AI<0x60, MRMSrcReg, (outs),
6169       (ins VR128:$src1, VR128:$src3, i8imm:$src5),
6170       "pcmpestrm\t{$src5, $src3, $src1|$src1, $src3, $src5}", []>, OpSize;
6171   def PCMPESTRM128rm : SS42AI<0x60, MRMSrcMem, (outs),
6172       (ins VR128:$src1, i128mem:$src3, i8imm:$src5),
6173       "pcmpestrm\t{$src5, $src3, $src1|$src1, $src3, $src5}", []>, OpSize;
6174 }
6175
6176 // Packed Compare Implicit Length Strings, Return Index
6177 let Defs = [ECX, EFLAGS] in {
6178   multiclass SS42AI_pcmpistri<Intrinsic IntId128, string asm = "pcmpistri"> {
6179     def rr : SS42AI<0x63, MRMSrcReg, (outs),
6180       (ins VR128:$src1, VR128:$src2, i8imm:$src3),
6181       !strconcat(asm, "\t{$src3, $src2, $src1|$src1, $src2, $src3}"),
6182       [(set ECX, (IntId128 VR128:$src1, VR128:$src2, imm:$src3)),
6183        (implicit EFLAGS)]>, OpSize;
6184     def rm : SS42AI<0x63, MRMSrcMem, (outs),
6185       (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
6186       !strconcat(asm, "\t{$src3, $src2, $src1|$src1, $src2, $src3}"),
6187       [(set ECX, (IntId128 VR128:$src1, (load addr:$src2), imm:$src3)),
6188        (implicit EFLAGS)]>, OpSize;
6189   }
6190 }
6191
6192 let Predicates = [HasAVX] in {
6193 defm VPCMPISTRI  : SS42AI_pcmpistri<int_x86_sse42_pcmpistri128, "vpcmpistri">,
6194                                     VEX;
6195 defm VPCMPISTRIA : SS42AI_pcmpistri<int_x86_sse42_pcmpistria128, "vpcmpistri">,
6196                                     VEX;
6197 defm VPCMPISTRIC : SS42AI_pcmpistri<int_x86_sse42_pcmpistric128, "vpcmpistri">,
6198                                     VEX;
6199 defm VPCMPISTRIO : SS42AI_pcmpistri<int_x86_sse42_pcmpistrio128, "vpcmpistri">,
6200                                     VEX;
6201 defm VPCMPISTRIS : SS42AI_pcmpistri<int_x86_sse42_pcmpistris128, "vpcmpistri">,
6202                                     VEX;
6203 defm VPCMPISTRIZ : SS42AI_pcmpistri<int_x86_sse42_pcmpistriz128, "vpcmpistri">,
6204                                     VEX;
6205 }
6206
6207 defm PCMPISTRI  : SS42AI_pcmpistri<int_x86_sse42_pcmpistri128>;
6208 defm PCMPISTRIA : SS42AI_pcmpistri<int_x86_sse42_pcmpistria128>;
6209 defm PCMPISTRIC : SS42AI_pcmpistri<int_x86_sse42_pcmpistric128>;
6210 defm PCMPISTRIO : SS42AI_pcmpistri<int_x86_sse42_pcmpistrio128>;
6211 defm PCMPISTRIS : SS42AI_pcmpistri<int_x86_sse42_pcmpistris128>;
6212 defm PCMPISTRIZ : SS42AI_pcmpistri<int_x86_sse42_pcmpistriz128>;
6213
6214 // Packed Compare Explicit Length Strings, Return Index
6215 let Defs = [ECX, EFLAGS], Uses = [EAX, EDX] in {
6216   multiclass SS42AI_pcmpestri<Intrinsic IntId128, string asm = "pcmpestri"> {
6217     def rr : SS42AI<0x61, MRMSrcReg, (outs),
6218       (ins VR128:$src1, VR128:$src3, i8imm:$src5),
6219       !strconcat(asm, "\t{$src5, $src3, $src1|$src1, $src3, $src5}"),
6220       [(set ECX, (IntId128 VR128:$src1, EAX, VR128:$src3, EDX, imm:$src5)),
6221        (implicit EFLAGS)]>, OpSize;
6222     def rm : SS42AI<0x61, MRMSrcMem, (outs),
6223       (ins VR128:$src1, i128mem:$src3, i8imm:$src5),
6224       !strconcat(asm, "\t{$src5, $src3, $src1|$src1, $src3, $src5}"),
6225        [(set ECX,
6226              (IntId128 VR128:$src1, EAX, (load addr:$src3), EDX, imm:$src5)),
6227         (implicit EFLAGS)]>, OpSize;
6228   }
6229 }
6230
6231 let Predicates = [HasAVX] in {
6232 defm VPCMPESTRI  : SS42AI_pcmpestri<int_x86_sse42_pcmpestri128, "vpcmpestri">,
6233                                     VEX;
6234 defm VPCMPESTRIA : SS42AI_pcmpestri<int_x86_sse42_pcmpestria128, "vpcmpestri">,
6235                                     VEX;
6236 defm VPCMPESTRIC : SS42AI_pcmpestri<int_x86_sse42_pcmpestric128, "vpcmpestri">,
6237                                     VEX;
6238 defm VPCMPESTRIO : SS42AI_pcmpestri<int_x86_sse42_pcmpestrio128, "vpcmpestri">,
6239                                     VEX;
6240 defm VPCMPESTRIS : SS42AI_pcmpestri<int_x86_sse42_pcmpestris128, "vpcmpestri">,
6241                                     VEX;
6242 defm VPCMPESTRIZ : SS42AI_pcmpestri<int_x86_sse42_pcmpestriz128, "vpcmpestri">,
6243                                     VEX;
6244 }
6245
6246 defm PCMPESTRI  : SS42AI_pcmpestri<int_x86_sse42_pcmpestri128>;
6247 defm PCMPESTRIA : SS42AI_pcmpestri<int_x86_sse42_pcmpestria128>;
6248 defm PCMPESTRIC : SS42AI_pcmpestri<int_x86_sse42_pcmpestric128>;
6249 defm PCMPESTRIO : SS42AI_pcmpestri<int_x86_sse42_pcmpestrio128>;
6250 defm PCMPESTRIS : SS42AI_pcmpestri<int_x86_sse42_pcmpestris128>;
6251 defm PCMPESTRIZ : SS42AI_pcmpestri<int_x86_sse42_pcmpestriz128>;
6252
6253 //===----------------------------------------------------------------------===//
6254 // SSE4.2 - CRC Instructions
6255 //===----------------------------------------------------------------------===//
6256
6257 // No CRC instructions have AVX equivalents
6258
6259 // crc intrinsic instruction
6260 // This set of instructions are only rm, the only difference is the size
6261 // of r and m.
6262 let Constraints = "$src1 = $dst" in {
6263   def CRC32r32m8  : SS42FI<0xF0, MRMSrcMem, (outs GR32:$dst),
6264                       (ins GR32:$src1, i8mem:$src2),
6265                       "crc32{b} \t{$src2, $src1|$src1, $src2}",
6266                        [(set GR32:$dst,
6267                          (int_x86_sse42_crc32_32_8 GR32:$src1,
6268                          (load addr:$src2)))]>;
6269   def CRC32r32r8  : SS42FI<0xF0, MRMSrcReg, (outs GR32:$dst),
6270                       (ins GR32:$src1, GR8:$src2),
6271                       "crc32{b} \t{$src2, $src1|$src1, $src2}",
6272                        [(set GR32:$dst,
6273                          (int_x86_sse42_crc32_32_8 GR32:$src1, GR8:$src2))]>;
6274   def CRC32r32m16  : SS42FI<0xF1, MRMSrcMem, (outs GR32:$dst),
6275                       (ins GR32:$src1, i16mem:$src2),
6276                       "crc32{w} \t{$src2, $src1|$src1, $src2}",
6277                        [(set GR32:$dst,
6278                          (int_x86_sse42_crc32_32_16 GR32:$src1,
6279                          (load addr:$src2)))]>,
6280                          OpSize;
6281   def CRC32r32r16  : SS42FI<0xF1, MRMSrcReg, (outs GR32:$dst),
6282                       (ins GR32:$src1, GR16:$src2),
6283                       "crc32{w} \t{$src2, $src1|$src1, $src2}",
6284                        [(set GR32:$dst,
6285                          (int_x86_sse42_crc32_32_16 GR32:$src1, GR16:$src2))]>,
6286                          OpSize;
6287   def CRC32r32m32  : SS42FI<0xF1, MRMSrcMem, (outs GR32:$dst),
6288                       (ins GR32:$src1, i32mem:$src2),
6289                       "crc32{l} \t{$src2, $src1|$src1, $src2}",
6290                        [(set GR32:$dst,
6291                          (int_x86_sse42_crc32_32_32 GR32:$src1,
6292                          (load addr:$src2)))]>;
6293   def CRC32r32r32  : SS42FI<0xF1, MRMSrcReg, (outs GR32:$dst),
6294                       (ins GR32:$src1, GR32:$src2),
6295                       "crc32{l} \t{$src2, $src1|$src1, $src2}",
6296                        [(set GR32:$dst,
6297                          (int_x86_sse42_crc32_32_32 GR32:$src1, GR32:$src2))]>;
6298   def CRC32r64m8  : SS42FI<0xF0, MRMSrcMem, (outs GR64:$dst),
6299                       (ins GR64:$src1, i8mem:$src2),
6300                       "crc32{b} \t{$src2, $src1|$src1, $src2}",
6301                        [(set GR64:$dst,
6302                          (int_x86_sse42_crc32_64_8 GR64:$src1,
6303                          (load addr:$src2)))]>,
6304                          REX_W;
6305   def CRC32r64r8  : SS42FI<0xF0, MRMSrcReg, (outs GR64:$dst),
6306                       (ins GR64:$src1, GR8:$src2),
6307                       "crc32{b} \t{$src2, $src1|$src1, $src2}",
6308                        [(set GR64:$dst,
6309                          (int_x86_sse42_crc32_64_8 GR64:$src1, GR8:$src2))]>,
6310                          REX_W;
6311   def CRC32r64m64  : SS42FI<0xF1, MRMSrcMem, (outs GR64:$dst),
6312                       (ins GR64:$src1, i64mem:$src2),
6313                       "crc32{q} \t{$src2, $src1|$src1, $src2}",
6314                        [(set GR64:$dst,
6315                          (int_x86_sse42_crc32_64_64 GR64:$src1,
6316                          (load addr:$src2)))]>,
6317                          REX_W;
6318   def CRC32r64r64  : SS42FI<0xF1, MRMSrcReg, (outs GR64:$dst),
6319                       (ins GR64:$src1, GR64:$src2),
6320                       "crc32{q} \t{$src2, $src1|$src1, $src2}",
6321                        [(set GR64:$dst,
6322                          (int_x86_sse42_crc32_64_64 GR64:$src1, GR64:$src2))]>,
6323                          REX_W;
6324 }
6325
6326 //===----------------------------------------------------------------------===//
6327 // AES-NI Instructions
6328 //===----------------------------------------------------------------------===//
6329
6330 multiclass AESI_binop_rm_int<bits<8> opc, string OpcodeStr,
6331                               Intrinsic IntId128, bit Is2Addr = 1> {
6332   def rr : AES8I<opc, MRMSrcReg, (outs VR128:$dst),
6333        (ins VR128:$src1, VR128:$src2),
6334        !if(Is2Addr,
6335            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6336            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6337        [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
6338        OpSize;
6339   def rm : AES8I<opc, MRMSrcMem, (outs VR128:$dst),
6340        (ins VR128:$src1, i128mem:$src2),
6341        !if(Is2Addr,
6342            !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
6343            !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
6344        [(set VR128:$dst,
6345          (IntId128 VR128:$src1,
6346           (bitconvert (memopv16i8 addr:$src2))))]>, OpSize;
6347 }
6348
6349 // Perform One Round of an AES Encryption/Decryption Flow
6350 let Predicates = [HasAVX, HasAES] in {
6351   defm VAESENC          : AESI_binop_rm_int<0xDC, "vaesenc",
6352                          int_x86_aesni_aesenc, 0>, VEX_4V;
6353   defm VAESENCLAST      : AESI_binop_rm_int<0xDD, "vaesenclast",
6354                          int_x86_aesni_aesenclast, 0>, VEX_4V;
6355   defm VAESDEC          : AESI_binop_rm_int<0xDE, "vaesdec",
6356                          int_x86_aesni_aesdec, 0>, VEX_4V;
6357   defm VAESDECLAST      : AESI_binop_rm_int<0xDF, "vaesdeclast",
6358                          int_x86_aesni_aesdeclast, 0>, VEX_4V;
6359 }
6360
6361 let Constraints = "$src1 = $dst" in {
6362   defm AESENC          : AESI_binop_rm_int<0xDC, "aesenc",
6363                          int_x86_aesni_aesenc>;
6364   defm AESENCLAST      : AESI_binop_rm_int<0xDD, "aesenclast",
6365                          int_x86_aesni_aesenclast>;
6366   defm AESDEC          : AESI_binop_rm_int<0xDE, "aesdec",
6367                          int_x86_aesni_aesdec>;
6368   defm AESDECLAST      : AESI_binop_rm_int<0xDF, "aesdeclast",
6369                          int_x86_aesni_aesdeclast>;
6370 }
6371
6372 let Predicates = [HasAES] in {
6373   def : Pat<(v2i64 (int_x86_aesni_aesenc VR128:$src1, VR128:$src2)),
6374             (AESENCrr VR128:$src1, VR128:$src2)>;
6375   def : Pat<(v2i64 (int_x86_aesni_aesenc VR128:$src1, (memop addr:$src2))),
6376             (AESENCrm VR128:$src1, addr:$src2)>;
6377   def : Pat<(v2i64 (int_x86_aesni_aesenclast VR128:$src1, VR128:$src2)),
6378             (AESENCLASTrr VR128:$src1, VR128:$src2)>;
6379   def : Pat<(v2i64 (int_x86_aesni_aesenclast VR128:$src1, (memop addr:$src2))),
6380             (AESENCLASTrm VR128:$src1, addr:$src2)>;
6381   def : Pat<(v2i64 (int_x86_aesni_aesdec VR128:$src1, VR128:$src2)),
6382             (AESDECrr VR128:$src1, VR128:$src2)>;
6383   def : Pat<(v2i64 (int_x86_aesni_aesdec VR128:$src1, (memop addr:$src2))),
6384             (AESDECrm VR128:$src1, addr:$src2)>;
6385   def : Pat<(v2i64 (int_x86_aesni_aesdeclast VR128:$src1, VR128:$src2)),
6386             (AESDECLASTrr VR128:$src1, VR128:$src2)>;
6387   def : Pat<(v2i64 (int_x86_aesni_aesdeclast VR128:$src1, (memop addr:$src2))),
6388             (AESDECLASTrm VR128:$src1, addr:$src2)>;
6389 }
6390
6391 let Predicates = [HasAVX, HasAES], AddedComplexity = 20 in {
6392   def : Pat<(v2i64 (int_x86_aesni_aesenc VR128:$src1, VR128:$src2)),
6393             (VAESENCrr VR128:$src1, VR128:$src2)>;
6394   def : Pat<(v2i64 (int_x86_aesni_aesenc VR128:$src1, (memop addr:$src2))),
6395             (VAESENCrm VR128:$src1, addr:$src2)>;
6396   def : Pat<(v2i64 (int_x86_aesni_aesenclast VR128:$src1, VR128:$src2)),
6397             (VAESENCLASTrr VR128:$src1, VR128:$src2)>;
6398   def : Pat<(v2i64 (int_x86_aesni_aesenclast VR128:$src1, (memop addr:$src2))),
6399             (VAESENCLASTrm VR128:$src1, addr:$src2)>;
6400   def : Pat<(v2i64 (int_x86_aesni_aesdec VR128:$src1, VR128:$src2)),
6401             (VAESDECrr VR128:$src1, VR128:$src2)>;
6402   def : Pat<(v2i64 (int_x86_aesni_aesdec VR128:$src1, (memop addr:$src2))),
6403             (VAESDECrm VR128:$src1, addr:$src2)>;
6404   def : Pat<(v2i64 (int_x86_aesni_aesdeclast VR128:$src1, VR128:$src2)),
6405             (VAESDECLASTrr VR128:$src1, VR128:$src2)>;
6406   def : Pat<(v2i64 (int_x86_aesni_aesdeclast VR128:$src1, (memop addr:$src2))),
6407             (VAESDECLASTrm VR128:$src1, addr:$src2)>;
6408 }
6409
6410 // Perform the AES InvMixColumn Transformation
6411 let Predicates = [HasAVX, HasAES] in {
6412   def VAESIMCrr : AES8I<0xDB, MRMSrcReg, (outs VR128:$dst),
6413       (ins VR128:$src1),
6414       "vaesimc\t{$src1, $dst|$dst, $src1}",
6415       [(set VR128:$dst,
6416         (int_x86_aesni_aesimc VR128:$src1))]>,
6417       OpSize, VEX;
6418   def VAESIMCrm : AES8I<0xDB, MRMSrcMem, (outs VR128:$dst),
6419       (ins i128mem:$src1),
6420       "vaesimc\t{$src1, $dst|$dst, $src1}",
6421       [(set VR128:$dst,
6422         (int_x86_aesni_aesimc (bitconvert (memopv2i64 addr:$src1))))]>,
6423       OpSize, VEX;
6424 }
6425 def AESIMCrr : AES8I<0xDB, MRMSrcReg, (outs VR128:$dst),
6426   (ins VR128:$src1),
6427   "aesimc\t{$src1, $dst|$dst, $src1}",
6428   [(set VR128:$dst,
6429     (int_x86_aesni_aesimc VR128:$src1))]>,
6430   OpSize;
6431 def AESIMCrm : AES8I<0xDB, MRMSrcMem, (outs VR128:$dst),
6432   (ins i128mem:$src1),
6433   "aesimc\t{$src1, $dst|$dst, $src1}",
6434   [(set VR128:$dst,
6435     (int_x86_aesni_aesimc (bitconvert (memopv2i64 addr:$src1))))]>,
6436   OpSize;
6437
6438 // AES Round Key Generation Assist
6439 let Predicates = [HasAVX, HasAES] in {
6440   def VAESKEYGENASSIST128rr : AESAI<0xDF, MRMSrcReg, (outs VR128:$dst),
6441       (ins VR128:$src1, i8imm:$src2),
6442       "vaeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
6443       [(set VR128:$dst,
6444         (int_x86_aesni_aeskeygenassist VR128:$src1, imm:$src2))]>,
6445       OpSize, VEX;
6446   def VAESKEYGENASSIST128rm : AESAI<0xDF, MRMSrcMem, (outs VR128:$dst),
6447       (ins i128mem:$src1, i8imm:$src2),
6448       "vaeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
6449       [(set VR128:$dst,
6450         (int_x86_aesni_aeskeygenassist (bitconvert (memopv2i64 addr:$src1)),
6451                                         imm:$src2))]>,
6452       OpSize, VEX;
6453 }
6454 def AESKEYGENASSIST128rr : AESAI<0xDF, MRMSrcReg, (outs VR128:$dst),
6455   (ins VR128:$src1, i8imm:$src2),
6456   "aeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
6457   [(set VR128:$dst,
6458     (int_x86_aesni_aeskeygenassist VR128:$src1, imm:$src2))]>,
6459   OpSize;
6460 def AESKEYGENASSIST128rm : AESAI<0xDF, MRMSrcMem, (outs VR128:$dst),
6461   (ins i128mem:$src1, i8imm:$src2),
6462   "aeskeygenassist\t{$src2, $src1, $dst|$dst, $src1, $src2}",
6463   [(set VR128:$dst,
6464     (int_x86_aesni_aeskeygenassist (bitconvert (memopv2i64 addr:$src1)),
6465                                     imm:$src2))]>,
6466   OpSize;
6467
6468 //===----------------------------------------------------------------------===//
6469 // CLMUL Instructions
6470 //===----------------------------------------------------------------------===//
6471
6472 // Carry-less Multiplication instructions
6473 let Constraints = "$src1 = $dst" in {
6474 def PCLMULQDQrr : CLMULIi8<0x44, MRMSrcReg, (outs VR128:$dst),
6475            (ins VR128:$src1, VR128:$src2, i8imm:$src3),
6476            "pclmulqdq\t{$src3, $src2, $dst|$dst, $src2, $src3}",
6477            []>;
6478
6479 def PCLMULQDQrm : CLMULIi8<0x44, MRMSrcMem, (outs VR128:$dst),
6480            (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
6481            "pclmulqdq\t{$src3, $src2, $dst|$dst, $src2, $src3}",
6482            []>;
6483 }
6484
6485 // AVX carry-less Multiplication instructions
6486 def VPCLMULQDQrr : AVXCLMULIi8<0x44, MRMSrcReg, (outs VR128:$dst),
6487            (ins VR128:$src1, VR128:$src2, i8imm:$src3),
6488            "vpclmulqdq\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
6489            []>;
6490
6491 def VPCLMULQDQrm : AVXCLMULIi8<0x44, MRMSrcMem, (outs VR128:$dst),
6492            (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
6493            "vpclmulqdq\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
6494            []>;
6495
6496
6497 multiclass pclmul_alias<string asm, int immop> {
6498   def : InstAlias<!strconcat("pclmul", asm,
6499                            "dq {$src, $dst|$dst, $src}"),
6500                   (PCLMULQDQrr VR128:$dst, VR128:$src, immop)>;
6501
6502   def : InstAlias<!strconcat("pclmul", asm,
6503                              "dq {$src, $dst|$dst, $src}"),
6504                   (PCLMULQDQrm VR128:$dst, i128mem:$src, immop)>;
6505
6506   def : InstAlias<!strconcat("vpclmul", asm,
6507                              "dq {$src2, $src1, $dst|$dst, $src1, $src2}"),
6508                   (VPCLMULQDQrr VR128:$dst, VR128:$src1, VR128:$src2, immop)>;
6509
6510   def : InstAlias<!strconcat("vpclmul", asm,
6511                              "dq {$src2, $src1, $dst|$dst, $src1, $src2}"),
6512                   (VPCLMULQDQrm VR128:$dst, VR128:$src1, i128mem:$src2, immop)>;
6513 }
6514 defm : pclmul_alias<"hqhq", 0x11>;
6515 defm : pclmul_alias<"hqlq", 0x01>;
6516 defm : pclmul_alias<"lqhq", 0x10>;
6517 defm : pclmul_alias<"lqlq", 0x00>;
6518
6519 //===----------------------------------------------------------------------===//
6520 // AVX Instructions
6521 //===----------------------------------------------------------------------===//
6522
6523 //===----------------------------------------------------------------------===//
6524 // VBROADCAST - Load from memory and broadcast to all elements of the
6525 //              destination operand
6526 //
6527 class avx_broadcast<bits<8> opc, string OpcodeStr, RegisterClass RC,
6528                     X86MemOperand x86memop, Intrinsic Int> :
6529   AVX8I<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
6530         !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
6531         [(set RC:$dst, (Int addr:$src))]>, VEX;
6532
6533 def VBROADCASTSS   : avx_broadcast<0x18, "vbroadcastss", VR128, f32mem,
6534                                    int_x86_avx_vbroadcastss>;
6535 def VBROADCASTSSY  : avx_broadcast<0x18, "vbroadcastss", VR256, f32mem,
6536                                    int_x86_avx_vbroadcastss_256>;
6537 def VBROADCASTSD   : avx_broadcast<0x19, "vbroadcastsd", VR256, f64mem,
6538                                    int_x86_avx_vbroadcast_sd_256>;
6539 def VBROADCASTF128 : avx_broadcast<0x1A, "vbroadcastf128", VR256, f128mem,
6540                                    int_x86_avx_vbroadcastf128_pd_256>;
6541
6542 def : Pat<(int_x86_avx_vbroadcastf128_ps_256 addr:$src),
6543           (VBROADCASTF128 addr:$src)>;
6544
6545 def : Pat<(v8i32 (X86VBroadcast (loadi32 addr:$src))),
6546           (VBROADCASTSSY addr:$src)>;
6547 def : Pat<(v4i64 (X86VBroadcast (loadi64 addr:$src))),
6548           (VBROADCASTSD addr:$src)>;
6549 def : Pat<(v8f32 (X86VBroadcast (loadf32 addr:$src))),
6550           (VBROADCASTSSY addr:$src)>;
6551 def : Pat<(v4f64 (X86VBroadcast (loadf64 addr:$src))),
6552           (VBROADCASTSD addr:$src)>;
6553
6554 def : Pat<(v4f32 (X86VBroadcast (loadf32 addr:$src))),
6555           (VBROADCASTSS addr:$src)>;
6556 def : Pat<(v4i32 (X86VBroadcast (loadi32 addr:$src))),
6557           (VBROADCASTSS addr:$src)>;
6558
6559 //===----------------------------------------------------------------------===//
6560 // VINSERTF128 - Insert packed floating-point values
6561 //
6562 def VINSERTF128rr : AVXAIi8<0x18, MRMSrcReg, (outs VR256:$dst),
6563           (ins VR256:$src1, VR128:$src2, i8imm:$src3),
6564           "vinsertf128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
6565           []>, VEX_4V;
6566 def VINSERTF128rm : AVXAIi8<0x18, MRMSrcMem, (outs VR256:$dst),
6567           (ins VR256:$src1, f128mem:$src2, i8imm:$src3),
6568           "vinsertf128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
6569           []>, VEX_4V;
6570
6571 def : Pat<(int_x86_avx_vinsertf128_pd_256 VR256:$src1, VR128:$src2, imm:$src3),
6572           (VINSERTF128rr VR256:$src1, VR128:$src2, imm:$src3)>;
6573 def : Pat<(int_x86_avx_vinsertf128_ps_256 VR256:$src1, VR128:$src2, imm:$src3),
6574           (VINSERTF128rr VR256:$src1, VR128:$src2, imm:$src3)>;
6575 def : Pat<(int_x86_avx_vinsertf128_si_256 VR256:$src1, VR128:$src2, imm:$src3),
6576           (VINSERTF128rr VR256:$src1, VR128:$src2, imm:$src3)>;
6577
6578 def : Pat<(vinsertf128_insert:$ins (v8f32 VR256:$src1), (v4f32 VR128:$src2),
6579                                    (i32 imm)),
6580           (VINSERTF128rr VR256:$src1, VR128:$src2,
6581                          (INSERT_get_vinsertf128_imm VR256:$ins))>;
6582 def : Pat<(vinsertf128_insert:$ins (v4f64 VR256:$src1), (v2f64 VR128:$src2),
6583                                    (i32 imm)),
6584           (VINSERTF128rr VR256:$src1, VR128:$src2,
6585                          (INSERT_get_vinsertf128_imm VR256:$ins))>;
6586 def : Pat<(vinsertf128_insert:$ins (v8i32 VR256:$src1), (v4i32 VR128:$src2),
6587                                    (i32 imm)),
6588           (VINSERTF128rr VR256:$src1, VR128:$src2,
6589                          (INSERT_get_vinsertf128_imm VR256:$ins))>;
6590 def : Pat<(vinsertf128_insert:$ins (v4i64 VR256:$src1), (v2i64 VR128:$src2),
6591                                    (i32 imm)),
6592           (VINSERTF128rr VR256:$src1, VR128:$src2,
6593                          (INSERT_get_vinsertf128_imm VR256:$ins))>;
6594 def : Pat<(vinsertf128_insert:$ins (v32i8 VR256:$src1), (v16i8 VR128:$src2),
6595                                    (i32 imm)),
6596           (VINSERTF128rr VR256:$src1, VR128:$src2,
6597                          (INSERT_get_vinsertf128_imm VR256:$ins))>;
6598 def : Pat<(vinsertf128_insert:$ins (v16i16 VR256:$src1), (v8i16 VR128:$src2),
6599                                    (i32 imm)),
6600           (VINSERTF128rr VR256:$src1, VR128:$src2,
6601                          (INSERT_get_vinsertf128_imm VR256:$ins))>;
6602
6603 //===----------------------------------------------------------------------===//
6604 // VEXTRACTF128 - Extract packed floating-point values
6605 //
6606 def VEXTRACTF128rr : AVXAIi8<0x19, MRMDestReg, (outs VR128:$dst),
6607           (ins VR256:$src1, i8imm:$src2),
6608           "vextractf128\t{$src2, $src1, $dst|$dst, $src1, $src2}",
6609           []>, VEX;
6610 def VEXTRACTF128mr : AVXAIi8<0x19, MRMDestMem, (outs),
6611           (ins f128mem:$dst, VR256:$src1, i8imm:$src2),
6612           "vextractf128\t{$src2, $src1, $dst|$dst, $src1, $src2}",
6613           []>, VEX;
6614
6615 def : Pat<(int_x86_avx_vextractf128_pd_256 VR256:$src1, imm:$src2),
6616           (VEXTRACTF128rr VR256:$src1, imm:$src2)>;
6617 def : Pat<(int_x86_avx_vextractf128_ps_256 VR256:$src1, imm:$src2),
6618           (VEXTRACTF128rr VR256:$src1, imm:$src2)>;
6619 def : Pat<(int_x86_avx_vextractf128_si_256 VR256:$src1, imm:$src2),
6620           (VEXTRACTF128rr VR256:$src1, imm:$src2)>;
6621
6622 def : Pat<(vextractf128_extract:$ext VR256:$src1, (i32 imm)),
6623           (v4f32 (VEXTRACTF128rr
6624                     (v8f32 VR256:$src1),
6625                     (EXTRACT_get_vextractf128_imm VR128:$ext)))>;
6626 def : Pat<(vextractf128_extract:$ext VR256:$src1, (i32 imm)),
6627           (v2f64 (VEXTRACTF128rr
6628                     (v4f64 VR256:$src1),
6629                     (EXTRACT_get_vextractf128_imm VR128:$ext)))>;
6630 def : Pat<(vextractf128_extract:$ext VR256:$src1, (i32 imm)),
6631           (v4i32 (VEXTRACTF128rr
6632                     (v8i32 VR256:$src1),
6633                     (EXTRACT_get_vextractf128_imm VR128:$ext)))>;
6634 def : Pat<(vextractf128_extract:$ext VR256:$src1, (i32 imm)),
6635           (v2i64 (VEXTRACTF128rr
6636                     (v4i64 VR256:$src1),
6637                     (EXTRACT_get_vextractf128_imm VR128:$ext)))>;
6638 def : Pat<(vextractf128_extract:$ext VR256:$src1, (i32 imm)),
6639           (v8i16 (VEXTRACTF128rr
6640                     (v16i16 VR256:$src1),
6641                     (EXTRACT_get_vextractf128_imm VR128:$ext)))>;
6642 def : Pat<(vextractf128_extract:$ext VR256:$src1, (i32 imm)),
6643           (v16i8 (VEXTRACTF128rr
6644                     (v32i8 VR256:$src1),
6645                     (EXTRACT_get_vextractf128_imm VR128:$ext)))>;
6646
6647 //===----------------------------------------------------------------------===//
6648 // VMASKMOV - Conditional SIMD Packed Loads and Stores
6649 //
6650 multiclass avx_movmask_rm<bits<8> opc_rm, bits<8> opc_mr, string OpcodeStr,
6651                           Intrinsic IntLd, Intrinsic IntLd256,
6652                           Intrinsic IntSt, Intrinsic IntSt256,
6653                           PatFrag pf128, PatFrag pf256> {
6654   def rm  : AVX8I<opc_rm, MRMSrcMem, (outs VR128:$dst),
6655              (ins VR128:$src1, f128mem:$src2),
6656              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6657              [(set VR128:$dst, (IntLd addr:$src2, VR128:$src1))]>,
6658              VEX_4V;
6659   def Yrm : AVX8I<opc_rm, MRMSrcMem, (outs VR256:$dst),
6660              (ins VR256:$src1, f256mem:$src2),
6661              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6662              [(set VR256:$dst, (IntLd256 addr:$src2, VR256:$src1))]>,
6663              VEX_4V;
6664   def mr  : AVX8I<opc_mr, MRMDestMem, (outs),
6665              (ins f128mem:$dst, VR128:$src1, VR128:$src2),
6666              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6667              [(IntSt addr:$dst, VR128:$src1, VR128:$src2)]>, VEX_4V;
6668   def Ymr : AVX8I<opc_mr, MRMDestMem, (outs),
6669              (ins f256mem:$dst, VR256:$src1, VR256:$src2),
6670              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6671              [(IntSt256 addr:$dst, VR256:$src1, VR256:$src2)]>, VEX_4V;
6672 }
6673
6674 defm VMASKMOVPS : avx_movmask_rm<0x2C, 0x2E, "vmaskmovps",
6675                                  int_x86_avx_maskload_ps,
6676                                  int_x86_avx_maskload_ps_256,
6677                                  int_x86_avx_maskstore_ps,
6678                                  int_x86_avx_maskstore_ps_256,
6679                                  memopv4f32, memopv8f32>;
6680 defm VMASKMOVPD : avx_movmask_rm<0x2D, 0x2F, "vmaskmovpd",
6681                                  int_x86_avx_maskload_pd,
6682                                  int_x86_avx_maskload_pd_256,
6683                                  int_x86_avx_maskstore_pd,
6684                                  int_x86_avx_maskstore_pd_256,
6685                                  memopv2f64, memopv4f64>;
6686
6687 //===----------------------------------------------------------------------===//
6688 // VPERMIL - Permute Single and Double Floating-Point Values
6689 //
6690 multiclass avx_permil<bits<8> opc_rm, bits<8> opc_rmi, string OpcodeStr,
6691                       RegisterClass RC, X86MemOperand x86memop_f,
6692                       X86MemOperand x86memop_i, PatFrag f_frag, PatFrag i_frag,
6693                       Intrinsic IntVar, Intrinsic IntImm> {
6694   def rr  : AVX8I<opc_rm, MRMSrcReg, (outs RC:$dst),
6695              (ins RC:$src1, RC:$src2),
6696              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6697              [(set RC:$dst, (IntVar RC:$src1, RC:$src2))]>, VEX_4V;
6698   def rm  : AVX8I<opc_rm, MRMSrcMem, (outs RC:$dst),
6699              (ins RC:$src1, x86memop_i:$src2),
6700              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6701              [(set RC:$dst, (IntVar RC:$src1, (i_frag addr:$src2)))]>, VEX_4V;
6702
6703   def ri  : AVXAIi8<opc_rmi, MRMSrcReg, (outs RC:$dst),
6704              (ins RC:$src1, i8imm:$src2),
6705              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6706              [(set RC:$dst, (IntImm RC:$src1, imm:$src2))]>, VEX;
6707   def mi  : AVXAIi8<opc_rmi, MRMSrcMem, (outs RC:$dst),
6708              (ins x86memop_f:$src1, i8imm:$src2),
6709              !strconcat(OpcodeStr, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
6710              [(set RC:$dst, (IntImm (f_frag addr:$src1), imm:$src2))]>, VEX;
6711 }
6712
6713 defm VPERMILPS  : avx_permil<0x0C, 0x04, "vpermilps", VR128, f128mem, i128mem,
6714                              memopv4f32, memopv4i32,
6715                              int_x86_avx_vpermilvar_ps,
6716                              int_x86_avx_vpermil_ps>;
6717 defm VPERMILPSY : avx_permil<0x0C, 0x04, "vpermilps", VR256, f256mem, i256mem,
6718                              memopv8f32, memopv8i32,
6719                              int_x86_avx_vpermilvar_ps_256,
6720                              int_x86_avx_vpermil_ps_256>;
6721 defm VPERMILPD  : avx_permil<0x0D, 0x05, "vpermilpd", VR128, f128mem, i128mem,
6722                              memopv2f64, memopv2i64,
6723                              int_x86_avx_vpermilvar_pd,
6724                              int_x86_avx_vpermil_pd>;
6725 defm VPERMILPDY : avx_permil<0x0D, 0x05, "vpermilpd", VR256, f256mem, i256mem,
6726                              memopv4f64, memopv4i64,
6727                              int_x86_avx_vpermilvar_pd_256,
6728                              int_x86_avx_vpermil_pd_256>;
6729
6730 def : Pat<(v8f32 (X86VPermilpsy VR256:$src1, (i8 imm:$imm))),
6731           (VPERMILPSYri VR256:$src1, imm:$imm)>;
6732 def : Pat<(v4f64 (X86VPermilpdy VR256:$src1, (i8 imm:$imm))),
6733           (VPERMILPDYri VR256:$src1, imm:$imm)>;
6734 def : Pat<(v8i32 (X86VPermilpsy VR256:$src1, (i8 imm:$imm))),
6735           (VPERMILPSYri VR256:$src1, imm:$imm)>;
6736 def : Pat<(v4i64 (X86VPermilpdy VR256:$src1, (i8 imm:$imm))),
6737           (VPERMILPDYri VR256:$src1, imm:$imm)>;
6738
6739 //===----------------------------------------------------------------------===//
6740 // VPERM2F128 - Permute Floating-Point Values in 128-bit chunks
6741 //
6742 def VPERM2F128rr : AVXAIi8<0x06, MRMSrcReg, (outs VR256:$dst),
6743           (ins VR256:$src1, VR256:$src2, i8imm:$src3),
6744           "vperm2f128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
6745           []>, VEX_4V;
6746 def VPERM2F128rm : AVXAIi8<0x06, MRMSrcMem, (outs VR256:$dst),
6747           (ins VR256:$src1, f256mem:$src2, i8imm:$src3),
6748           "vperm2f128\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}",
6749           []>, VEX_4V;
6750
6751 def : Pat<(int_x86_avx_vperm2f128_ps_256 VR256:$src1, VR256:$src2, imm:$src3),
6752           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$src3)>;
6753 def : Pat<(int_x86_avx_vperm2f128_pd_256 VR256:$src1, VR256:$src2, imm:$src3),
6754           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$src3)>;
6755 def : Pat<(int_x86_avx_vperm2f128_si_256 VR256:$src1, VR256:$src2, imm:$src3),
6756           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$src3)>;
6757
6758 def : Pat<(int_x86_avx_vperm2f128_ps_256
6759                   VR256:$src1, (memopv8f32 addr:$src2), imm:$src3),
6760           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$src3)>;
6761 def : Pat<(int_x86_avx_vperm2f128_pd_256
6762                   VR256:$src1, (memopv4f64 addr:$src2), imm:$src3),
6763           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$src3)>;
6764 def : Pat<(int_x86_avx_vperm2f128_si_256
6765                   VR256:$src1, (memopv8i32 addr:$src2), imm:$src3),
6766           (VPERM2F128rm VR256:$src1, addr:$src2, imm:$src3)>;
6767
6768 def : Pat<(v8f32 (X86VPerm2f128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
6769           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
6770 def : Pat<(v8i32 (X86VPerm2f128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
6771           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
6772 def : Pat<(v4i64 (X86VPerm2f128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
6773           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
6774 def : Pat<(v4f64 (X86VPerm2f128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
6775           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
6776 def : Pat<(v32i8 (X86VPerm2f128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
6777           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
6778 def : Pat<(v16i16 (X86VPerm2f128 VR256:$src1, VR256:$src2, (i8 imm:$imm))),
6779           (VPERM2F128rr VR256:$src1, VR256:$src2, imm:$imm)>;
6780
6781 //===----------------------------------------------------------------------===//
6782 // VZERO - Zero YMM registers
6783 //
6784 let Defs = [YMM0, YMM1, YMM2, YMM3, YMM4, YMM5, YMM6, YMM7,
6785             YMM8, YMM9, YMM10, YMM11, YMM12, YMM13, YMM14, YMM15] in {
6786   // Zero All YMM registers
6787   def VZEROALL : I<0x77, RawFrm, (outs), (ins), "vzeroall",
6788                    [(int_x86_avx_vzeroall)]>, TB, VEX, VEX_L, Requires<[HasAVX]>;
6789
6790   // Zero Upper bits of YMM registers
6791   def VZEROUPPER : I<0x77, RawFrm, (outs), (ins), "vzeroupper",
6792                      [(int_x86_avx_vzeroupper)]>, TB, VEX, Requires<[HasAVX]>;
6793 }
6794