lib/Target/X86/X86InstrSSE.td

   1 //====- X86InstrSSE.td - Describe the X86 Instruction Set -------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the Evan Cheng and is distributed under
   6 // the University of Illinois Open Source 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 // SSE specific DAG Nodes.
  18 //===----------------------------------------------------------------------===//
  19
  20 def X86loadp   : SDNode<"X86ISD::LOAD_PACK", SDTLoad,
  21                         [SDNPHasChain]>;
  22 def X86fand    : SDNode<"X86ISD::FAND",      SDTFPBinOp,
  23                         [SDNPCommutative, SDNPAssociative]>;
  24 def X86fxor    : SDNode<"X86ISD::FXOR",      SDTFPBinOp,
  25                         [SDNPCommutative, SDNPAssociative]>;
  26 def X86comi    : SDNode<"X86ISD::COMI",      SDTX86CmpTest,
  27                         [SDNPOutFlag]>;
  28 def X86ucomi   : SDNode<"X86ISD::UCOMI",     SDTX86CmpTest,
  29                         [SDNPOutFlag]>;
  30 def X86s2vec   : SDNode<"X86ISD::S2VEC",
  31                         SDTypeProfile<1, 1, []>, []>;
  32 def X86zexts2vec : SDNode<"X86ISD::ZEXT_S2VEC",
  33                           SDTypeProfile<1, 1, []>, []>;
  34 def X86pextrw  : SDNode<"X86ISD::PEXTRW",
  35                         SDTypeProfile<1, 2, []>, []>;
  36 def X86pinsrw  : SDNode<"X86ISD::PINSRW",
  37                         SDTypeProfile<1, 3, []>, []>;
  38
  39 //===----------------------------------------------------------------------===//
  40 // SSE pattern fragments
  41 //===----------------------------------------------------------------------===//
  42
  43 def X86loadpf32  : PatFrag<(ops node:$ptr), (f32   (X86loadp node:$ptr))>;
  44 def X86loadpf64  : PatFrag<(ops node:$ptr), (f64   (X86loadp node:$ptr))>;
  45
  46 def loadv4f32    : PatFrag<(ops node:$ptr), (v4f32 (load node:$ptr))>;
  47 def loadv2f64    : PatFrag<(ops node:$ptr), (v2f64 (load node:$ptr))>;
  48 def loadv16i8    : PatFrag<(ops node:$ptr), (v16i8 (load node:$ptr))>;
  49 def loadv8i16    : PatFrag<(ops node:$ptr), (v8i16 (load node:$ptr))>;
  50 def loadv4i32    : PatFrag<(ops node:$ptr), (v4i32 (load node:$ptr))>;
  51 def loadv2i64    : PatFrag<(ops node:$ptr), (v2i64 (load node:$ptr))>;
  52
  53 def bc_v4f32 : PatFrag<(ops node:$in), (v4f32 (bitconvert node:$in))>;
  54 def bc_v2f64 : PatFrag<(ops node:$in), (v2f64 (bitconvert node:$in))>;
  55 def bc_v16i8 : PatFrag<(ops node:$in), (v16i8 (bitconvert node:$in))>;
  56 def bc_v8i16 : PatFrag<(ops node:$in), (v8i16 (bitconvert node:$in))>;
  57 def bc_v4i32 : PatFrag<(ops node:$in), (v4i32 (bitconvert node:$in))>;
  58 def bc_v2i64 : PatFrag<(ops node:$in), (v2i64 (bitconvert node:$in))>;
  59
  60 def fp32imm0 : PatLeaf<(f32 fpimm), [{
  61   return N->isExactlyValue(+0.0);
  62 }]>;
  63
  64 def PSxLDQ_imm  : SDNodeXForm<imm, [{
  65   // Transformation function: imm >> 3
  66   return getI32Imm(N->getValue() >> 3);
  67 }]>;
  68
  69 // SHUFFLE_get_shuf_imm xform function: convert vector_shuffle mask to PSHUF*,
  70 // SHUFP* etc. imm.
  71 def SHUFFLE_get_shuf_imm : SDNodeXForm<build_vector, [{
  72   return getI8Imm(X86::getShuffleSHUFImmediate(N));
  73 }]>;
  74
  75 // SHUFFLE_get_pshufhw_imm xform function: convert vector_shuffle mask to
  76 // PSHUFHW imm.
  77 def SHUFFLE_get_pshufhw_imm : SDNodeXForm<build_vector, [{
  78   return getI8Imm(X86::getShufflePSHUFHWImmediate(N));
  79 }]>;
  80
  81 // SHUFFLE_get_pshuflw_imm xform function: convert vector_shuffle mask to
  82 // PSHUFLW imm.
  83 def SHUFFLE_get_pshuflw_imm : SDNodeXForm<build_vector, [{
  84   return getI8Imm(X86::getShufflePSHUFLWImmediate(N));
  85 }]>;
  86
  87 def SSE_splat_mask : PatLeaf<(build_vector), [{
  88   return X86::isSplatMask(N);
  89 }], SHUFFLE_get_shuf_imm>;
  90
  91 def MOVLHPS_shuffle_mask : PatLeaf<(build_vector), [{
  92   return X86::isMOVLHPSMask(N);
  93 }]>;
  94
  95 def MOVHLPS_shuffle_mask : PatLeaf<(build_vector), [{
  96   return X86::isMOVHLPSMask(N);
  97 }]>;
  98
  99 def MOVHP_shuffle_mask : PatLeaf<(build_vector), [{
 100   return X86::isMOVHPMask(N);
 101 }]>;
 102
 103 def MOVLP_shuffle_mask : PatLeaf<(build_vector), [{
 104   return X86::isMOVLPMask(N);
 105 }]>;
 106
 107 def UNPCKL_shuffle_mask : PatLeaf<(build_vector), [{
 108   return X86::isUNPCKLMask(N);
 109 }]>;
 110
 111 def UNPCKH_shuffle_mask : PatLeaf<(build_vector), [{
 112   return X86::isUNPCKHMask(N);
 113 }]>;
 114
 115 def UNPCKL_v_undef_shuffle_mask : PatLeaf<(build_vector), [{
 116   return X86::isUNPCKL_v_undef_Mask(N);
 117 }]>;
 118
 119 def PSHUFD_shuffle_mask : PatLeaf<(build_vector), [{
 120   return X86::isPSHUFDMask(N);
 121 }], SHUFFLE_get_shuf_imm>;
 122
 123 def PSHUFHW_shuffle_mask : PatLeaf<(build_vector), [{
 124   return X86::isPSHUFHWMask(N);
 125 }], SHUFFLE_get_pshufhw_imm>;
 126
 127 def PSHUFLW_shuffle_mask : PatLeaf<(build_vector), [{
 128   return X86::isPSHUFLWMask(N);
 129 }], SHUFFLE_get_pshuflw_imm>;
 130
 131 // Only use PSHUF* for v4f32 if SHUFP does not match.
 132 def PSHUFD_fp_shuffle_mask : PatLeaf<(build_vector), [{
 133   return !X86::isSHUFPMask(N) &&
 134           X86::isPSHUFDMask(N);
 135 }], SHUFFLE_get_shuf_imm>;
 136
 137 def PSHUFHW_fp_shuffle_mask : PatLeaf<(build_vector), [{
 138   return !X86::isSHUFPMask(N) &&
 139           X86::isPSHUFHWMask(N);
 140 }], SHUFFLE_get_pshufhw_imm>;
 141
 142 def PSHUFLW_fp_shuffle_mask : PatLeaf<(build_vector), [{
 143   return !X86::isSHUFPMask(N) &&
 144           X86::isPSHUFLWMask(N);
 145 }], SHUFFLE_get_pshuflw_imm>;
 146
 147 def SHUFP_shuffle_mask : PatLeaf<(build_vector), [{
 148   return X86::isSHUFPMask(N);
 149 }], SHUFFLE_get_shuf_imm>;
 150
 151 // Only use SHUFP for v4i32 if PSHUF* do not match.
 152 def SHUFP_int_shuffle_mask : PatLeaf<(build_vector), [{
 153   return !X86::isPSHUFDMask(N) &&
 154          !X86::isPSHUFHWMask(N) &&
 155          !X86::isPSHUFLWMask(N) &&
 156           X86::isSHUFPMask(N);
 157 }], SHUFFLE_get_shuf_imm>;
 158
 159 //===----------------------------------------------------------------------===//
 160 // SSE scalar FP Instructions
 161 //===----------------------------------------------------------------------===//
 162
 163 // Instruction templates
 164 // SSI - SSE1 instructions with XS prefix.
 165 // SDI - SSE2 instructions with XD prefix.
 166 // PSI - SSE1 instructions with TB prefix.
 167 // PDI - SSE2 instructions with TB and OpSize prefixes.
 168 // PSIi8 - SSE1 instructions with ImmT == Imm8 and TB prefix.
 169 // PDIi8 - SSE2 instructions with ImmT == Imm8 and TB and OpSize prefixes.
 170 // S3SI - SSE3 instructions with XD prefix.
 171 // S3DI - SSE3 instructions with TB and OpSize prefixes.
 172 class SSI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 173       : I<o, F, ops, asm, pattern>, XS, Requires<[HasSSE1]>;
 174 class SDI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 175       : I<o, F, ops, asm, pattern>, XD, Requires<[HasSSE2]>;
 176 class PSI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 177       : I<o, F, ops, asm, pattern>, TB, Requires<[HasSSE1]>;
 178 class PDI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 179       : I<o, F, ops, asm, pattern>, TB, OpSize, Requires<[HasSSE2]>;
 180 class PSIi8<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 181       : X86Inst<o, F, Imm8, ops, asm>, TB, Requires<[HasSSE1]> {
 182   let Pattern = pattern;
 183 }
 184 class PDIi8<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 185       : X86Inst<o, F, Imm8, ops, asm>, TB, OpSize, Requires<[HasSSE2]> {
 186   let Pattern = pattern;
 187 }
 188 class S3SI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 189       : I<o, F, ops, asm, pattern>, XD, Requires<[HasSSE3]>;
 190 class S3DI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 191       : I<o, F, ops, asm, pattern>, TB, OpSize, Requires<[HasSSE3]>;
 192
 193 //===----------------------------------------------------------------------===//
 194 // Helpers for defining instructions that directly correspond to intrinsics.
 195 class SS_Intr<bits<8> o, string asm, Intrinsic IntId>
 196   : SSI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src), asm,
 197         [(set VR128:$dst, (v4f32 (IntId VR128:$src)))]>;
 198 class SS_Intm<bits<8> o, string asm, Intrinsic IntId>
 199   : SSI<o, MRMSrcMem, (ops VR128:$dst, f32mem:$src), asm,
 200         [(set VR128:$dst, (v4f32 (IntId (load addr:$src))))]>;
 201 class SD_Intr<bits<8> o, string asm, Intrinsic IntId>
 202   : SDI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src), asm,
 203         [(set VR128:$dst, (v2f64 (IntId VR128:$src)))]>;
 204 class SD_Intm<bits<8> o, string asm, Intrinsic IntId>
 205   : SDI<o, MRMSrcMem, (ops VR128:$dst, f64mem:$src), asm,
 206         [(set VR128:$dst, (v2f64 (IntId (load addr:$src))))]>;
 207
 208 class SS_Intrr<bits<8> o, string asm, Intrinsic IntId>
 209   : SSI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2), asm,
 210         [(set VR128:$dst, (v4f32 (IntId VR128:$src1, VR128:$src2)))]>;
 211 class SS_Intrm<bits<8> o, string asm, Intrinsic IntId>
 212   : SSI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f32mem:$src2), asm,
 213         [(set VR128:$dst, (v4f32 (IntId VR128:$src1, (load addr:$src2))))]>;
 214 class SD_Intrr<bits<8> o, string asm, Intrinsic IntId>
 215   : SDI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2), asm,
 216         [(set VR128:$dst, (v2f64 (IntId VR128:$src1, VR128:$src2)))]>;
 217 class SD_Intrm<bits<8> o, string asm, Intrinsic IntId>
 218   : SDI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f64mem:$src2), asm,
 219         [(set VR128:$dst, (v2f64 (IntId VR128:$src1, (load addr:$src2))))]>;
 220
 221 class PS_Intr<bits<8> o, string asm, Intrinsic IntId>
 222   : PSI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src), asm,
 223         [(set VR128:$dst, (IntId VR128:$src))]>;
 224 class PS_Intm<bits<8> o, string asm, Intrinsic IntId>
 225   : PSI<o, MRMSrcMem, (ops VR128:$dst, f32mem:$src), asm,
 226         [(set VR128:$dst, (IntId (loadv4f32 addr:$src)))]>;
 227 class PD_Intr<bits<8> o, string asm, Intrinsic IntId>
 228   : PDI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src), asm,
 229         [(set VR128:$dst, (IntId VR128:$src))]>;
 230 class PD_Intm<bits<8> o, string asm, Intrinsic IntId>
 231   : PDI<o, MRMSrcMem, (ops VR128:$dst, f64mem:$src), asm,
 232         [(set VR128:$dst, (IntId (loadv2f64 addr:$src)))]>;
 233
 234 class PS_Intrr<bits<8> o, string asm, Intrinsic IntId>
 235   : PSI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2), asm,
 236         [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
 237 class PS_Intrm<bits<8> o, string asm, Intrinsic IntId>
 238   : PSI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f32mem:$src2), asm,
 239         [(set VR128:$dst, (IntId VR128:$src1, (loadv4f32 addr:$src2)))]>;
 240 class PD_Intrr<bits<8> o, string asm, Intrinsic IntId>
 241   : PDI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2), asm,
 242         [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
 243 class PD_Intrm<bits<8> o, string asm, Intrinsic IntId>
 244   : PDI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f64mem:$src2), asm,
 245         [(set VR128:$dst, (IntId VR128:$src1, (loadv2f64 addr:$src2)))]>;
 246
 247 class S3S_Intrr<bits<8> o, string asm, Intrinsic IntId>
 248   : S3SI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2), asm,
 249          [(set VR128:$dst, (v4f32 (IntId VR128:$src1, VR128:$src2)))]>;
 250 class S3S_Intrm<bits<8> o, string asm, Intrinsic IntId>
 251   : S3SI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2), asm,
 252          [(set VR128:$dst, (v4f32 (IntId VR128:$src1,
 253                                    (loadv4f32 addr:$src2))))]>;
 254 class S3D_Intrr<bits<8> o, string asm, Intrinsic IntId>
 255   : S3DI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2), asm,
 256          [(set VR128:$dst, (v2f64 (IntId VR128:$src1, VR128:$src2)))]>;
 257 class S3D_Intrm<bits<8> o, string asm, Intrinsic IntId>
 258   : S3DI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2), asm,
 259          [(set VR128:$dst, (v2f64 (IntId VR128:$src1,
 260                                    (loadv2f64 addr:$src2))))]>;
 261
 262 // Some 'special' instructions
 263 def IMPLICIT_DEF_FR32 : I<0, Pseudo, (ops FR32:$dst),
 264                          "#IMPLICIT_DEF $dst",
 265                          [(set FR32:$dst, (undef))]>, Requires<[HasSSE2]>;
 266 def IMPLICIT_DEF_FR64 : I<0, Pseudo, (ops FR64:$dst),
 267                          "#IMPLICIT_DEF $dst",
 268                          [(set FR64:$dst, (undef))]>, Requires<[HasSSE2]>;
 269
 270 // CMOV* - Used to implement the SSE SELECT DAG operation.  Expanded by the
 271 // scheduler into a branch sequence.
 272 let usesCustomDAGSchedInserter = 1 in {  // Expanded by the scheduler.
 273   def CMOV_FR32 : I<0, Pseudo,
 274                     (ops FR32:$dst, FR32:$t, FR32:$f, i8imm:$cond),
 275                     "#CMOV_FR32 PSEUDO!",
 276                     [(set FR32:$dst, (X86cmov FR32:$t, FR32:$f, imm:$cond))]>;
 277   def CMOV_FR64 : I<0, Pseudo,
 278                     (ops FR64:$dst, FR64:$t, FR64:$f, i8imm:$cond),
 279                     "#CMOV_FR64 PSEUDO!",
 280                     [(set FR64:$dst, (X86cmov FR64:$t, FR64:$f, imm:$cond))]>;
 281 }
 282
 283 // Move Instructions
 284 def MOVSSrr : SSI<0x10, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 285                 "movss {$src, $dst|$dst, $src}", []>;
 286 def MOVSSrm : SSI<0x10, MRMSrcMem, (ops FR32:$dst, f32mem:$src),
 287                 "movss {$src, $dst|$dst, $src}",
 288                 [(set FR32:$dst, (loadf32 addr:$src))]>;
 289 def MOVSDrr : SDI<0x10, MRMSrcReg, (ops FR64:$dst, FR64:$src),
 290                 "movsd {$src, $dst|$dst, $src}", []>;
 291 def MOVSDrm : SDI<0x10, MRMSrcMem, (ops FR64:$dst, f64mem:$src),
 292                 "movsd {$src, $dst|$dst, $src}",
 293                 [(set FR64:$dst, (loadf64 addr:$src))]>;
 294
 295 def MOVSSmr : SSI<0x11, MRMDestMem, (ops f32mem:$dst, FR32:$src),
 296                 "movss {$src, $dst|$dst, $src}",
 297                 [(store FR32:$src, addr:$dst)]>;
 298 def MOVSDmr : SDI<0x11, MRMDestMem, (ops f64mem:$dst, FR64:$src),
 299                 "movsd {$src, $dst|$dst, $src}",
 300                 [(store FR64:$src, addr:$dst)]>;
 301
 302 // Arithmetic instructions
 303 let isTwoAddress = 1 in {
 304 let isCommutable = 1 in {
 305 def ADDSSrr : SSI<0x58, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 306                 "addss {$src2, $dst|$dst, $src2}",
 307                 [(set FR32:$dst, (fadd FR32:$src1, FR32:$src2))]>;
 308 def ADDSDrr : SDI<0x58, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 309                 "addsd {$src2, $dst|$dst, $src2}",
 310                 [(set FR64:$dst, (fadd FR64:$src1, FR64:$src2))]>;
 311 def MULSSrr : SSI<0x59, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 312                 "mulss {$src2, $dst|$dst, $src2}",
 313                 [(set FR32:$dst, (fmul FR32:$src1, FR32:$src2))]>;
 314 def MULSDrr : SDI<0x59, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 315                 "mulsd {$src2, $dst|$dst, $src2}",
 316                 [(set FR64:$dst, (fmul FR64:$src1, FR64:$src2))]>;
 317 }
 318
 319 def ADDSSrm : SSI<0x58, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f32mem:$src2),
 320                 "addss {$src2, $dst|$dst, $src2}",
 321                 [(set FR32:$dst, (fadd FR32:$src1, (loadf32 addr:$src2)))]>;
 322 def ADDSDrm : SDI<0x58, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f64mem:$src2),
 323                 "addsd {$src2, $dst|$dst, $src2}",
 324                 [(set FR64:$dst, (fadd FR64:$src1, (loadf64 addr:$src2)))]>;
 325 def MULSSrm : SSI<0x59, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f32mem:$src2),
 326                 "mulss {$src2, $dst|$dst, $src2}",
 327                 [(set FR32:$dst, (fmul FR32:$src1, (loadf32 addr:$src2)))]>;
 328 def MULSDrm : SDI<0x59, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f64mem:$src2),
 329                 "mulsd {$src2, $dst|$dst, $src2}",
 330                 [(set FR64:$dst, (fmul FR64:$src1, (loadf64 addr:$src2)))]>;
 331
 332 def DIVSSrr : SSI<0x5E, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 333                 "divss {$src2, $dst|$dst, $src2}",
 334                 [(set FR32:$dst, (fdiv FR32:$src1, FR32:$src2))]>;
 335 def DIVSSrm : SSI<0x5E, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f32mem:$src2),
 336                 "divss {$src2, $dst|$dst, $src2}",
 337                 [(set FR32:$dst, (fdiv FR32:$src1, (loadf32 addr:$src2)))]>;
 338 def DIVSDrr : SDI<0x5E, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 339                 "divsd {$src2, $dst|$dst, $src2}",
 340                 [(set FR64:$dst, (fdiv FR64:$src1, FR64:$src2))]>;
 341 def DIVSDrm : SDI<0x5E, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f64mem:$src2),
 342                 "divsd {$src2, $dst|$dst, $src2}",
 343                 [(set FR64:$dst, (fdiv FR64:$src1, (loadf64 addr:$src2)))]>;
 344
 345 def SUBSSrr : SSI<0x5C, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 346                 "subss {$src2, $dst|$dst, $src2}",
 347                 [(set FR32:$dst, (fsub FR32:$src1, FR32:$src2))]>;
 348 def SUBSSrm : SSI<0x5C, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f32mem:$src2),
 349                 "subss {$src2, $dst|$dst, $src2}",
 350                 [(set FR32:$dst, (fsub FR32:$src1, (loadf32 addr:$src2)))]>;
 351 def SUBSDrr : SDI<0x5C, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 352                 "subsd {$src2, $dst|$dst, $src2}",
 353                 [(set FR64:$dst, (fsub FR64:$src1, FR64:$src2))]>;
 354 def SUBSDrm : SDI<0x5C, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f64mem:$src2),
 355                 "subsd {$src2, $dst|$dst, $src2}",
 356                 [(set FR64:$dst, (fsub FR64:$src1, (loadf64 addr:$src2)))]>;
 357 }
 358
 359 def SQRTSSr : SSI<0x51, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 360                 "sqrtss {$src, $dst|$dst, $src}",
 361                 [(set FR32:$dst, (fsqrt FR32:$src))]>;
 362 def SQRTSSm : SSI<0x51, MRMSrcMem, (ops FR32:$dst, f32mem:$src),
 363                  "sqrtss {$src, $dst|$dst, $src}",
 364                  [(set FR32:$dst, (fsqrt (loadf32 addr:$src)))]>;
 365 def SQRTSDr : SDI<0x51, MRMSrcReg, (ops FR64:$dst, FR64:$src),
 366                  "sqrtsd {$src, $dst|$dst, $src}",
 367                  [(set FR64:$dst, (fsqrt FR64:$src))]>;
 368 def SQRTSDm : SDI<0x51, MRMSrcMem, (ops FR64:$dst, f64mem:$src),
 369                  "sqrtsd {$src, $dst|$dst, $src}",
 370                  [(set FR64:$dst, (fsqrt (loadf64 addr:$src)))]>;
 371
 372 def RSQRTSSr : SSI<0x52, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 373                    "rsqrtss {$src, $dst|$dst, $src}", []>;
 374 def RSQRTSSm : SSI<0x52, MRMSrcMem, (ops FR32:$dst, f32mem:$src),
 375                    "rsqrtss {$src, $dst|$dst, $src}", []>;
 376 def RCPSSr : SSI<0x53, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 377                  "rcpss {$src, $dst|$dst, $src}", []>;
 378 def RCPSSm : SSI<0x53, MRMSrcMem, (ops FR32:$dst, f32mem:$src),
 379                  "rcpss {$src, $dst|$dst, $src}", []>;
 380
 381 let isTwoAddress = 1 in {
 382 def MAXSSrr : SSI<0x5F, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 383                   "maxss {$src2, $dst|$dst, $src2}", []>;
 384 def MAXSSrm : SSI<0x5F, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f32mem:$src2),
 385                   "maxss {$src2, $dst|$dst, $src2}", []>;
 386 def MAXSDrr : SDI<0x5F, MRMSrcReg, (ops FR64:$dst, FR32:$src1, FR64:$src2),
 387                   "maxsd {$src2, $dst|$dst, $src2}", []>;
 388 def MAXSDrm : SDI<0x5F, MRMSrcMem, (ops FR64:$dst, FR32:$src1, f64mem:$src2),
 389                   "maxsd {$src2, $dst|$dst, $src2}", []>;
 390 def MINSSrr : SSI<0x5D, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 391                   "minss {$src2, $dst|$dst, $src2}", []>;
 392 def MINSSrm : SSI<0x5D, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f32mem:$src2),
 393                   "minss {$src2, $dst|$dst, $src2}", []>;
 394 def MINSDrr : SDI<0x5D, MRMSrcReg, (ops FR64:$dst, FR32:$src1, FR64:$src2),
 395                   "minsd {$src2, $dst|$dst, $src2}", []>;
 396 def MINSDrm : SDI<0x5D, MRMSrcMem, (ops FR64:$dst, FR32:$src1, f64mem:$src2),
 397                   "minsd {$src2, $dst|$dst, $src2}", []>;
 398 }
 399
 400 // Aliases to match intrinsics which expect XMM operand(s).
 401 let isTwoAddress = 1 in {
 402 let isCommutable = 1 in {
 403 def Int_ADDSSrr : SS_Intrr<0x58, "addss {$src2, $dst|$dst, $src2}",
 404                            int_x86_sse_add_ss>;
 405 def Int_ADDSDrr : SD_Intrr<0x58, "addsd {$src2, $dst|$dst, $src2}",
 406                            int_x86_sse2_add_sd>;
 407 def Int_MULSSrr : SS_Intrr<0x59, "mulss {$src2, $dst|$dst, $src2}",
 408                            int_x86_sse_mul_ss>;
 409 def Int_MULSDrr : SD_Intrr<0x59, "mulsd {$src2, $dst|$dst, $src2}",
 410                            int_x86_sse2_mul_sd>;
 411 }
 412
 413 def Int_ADDSSrm : SS_Intrm<0x58, "addss {$src2, $dst|$dst, $src2}",
 414                            int_x86_sse_add_ss>;
 415 def Int_ADDSDrm : SD_Intrm<0x58, "addsd {$src2, $dst|$dst, $src2}",
 416                            int_x86_sse2_add_sd>;
 417 def Int_MULSSrm : SS_Intrm<0x59, "mulss {$src2, $dst|$dst, $src2}",
 418                            int_x86_sse_mul_ss>;
 419 def Int_MULSDrm : SD_Intrm<0x59, "mulsd {$src2, $dst|$dst, $src2}",
 420                            int_x86_sse2_mul_sd>;
 421
 422 def Int_DIVSSrr : SS_Intrr<0x5E, "divss {$src2, $dst|$dst, $src2}",
 423                            int_x86_sse_div_ss>;
 424 def Int_DIVSSrm : SS_Intrm<0x5E, "divss {$src2, $dst|$dst, $src2}",
 425                            int_x86_sse_div_ss>;
 426 def Int_DIVSDrr : SD_Intrr<0x5E, "divsd {$src2, $dst|$dst, $src2}",
 427                            int_x86_sse2_div_sd>;
 428 def Int_DIVSDrm : SD_Intrm<0x5E, "divsd {$src2, $dst|$dst, $src2}",
 429                            int_x86_sse2_div_sd>;
 430
 431 def Int_SUBSSrr : SS_Intrr<0x5C, "subss {$src2, $dst|$dst, $src2}",
 432                            int_x86_sse_sub_ss>;
 433 def Int_SUBSSrm : SS_Intrm<0x5C, "subss {$src2, $dst|$dst, $src2}",
 434                            int_x86_sse_sub_ss>;
 435 def Int_SUBSDrr : SD_Intrr<0x5C, "subsd {$src2, $dst|$dst, $src2}",
 436                            int_x86_sse2_sub_sd>;
 437 def Int_SUBSDrm : SD_Intrm<0x5C, "subsd {$src2, $dst|$dst, $src2}",
 438                            int_x86_sse2_sub_sd>;
 439 }
 440
 441 def Int_SQRTSSr : SS_Intr<0x51, "sqrtss {$src, $dst|$dst, $src}",
 442                           int_x86_sse_sqrt_ss>;
 443 def Int_SQRTSSm : SS_Intm<0x51, "sqrtss {$src, $dst|$dst, $src}",
 444                           int_x86_sse_sqrt_ss>;
 445 def Int_SQRTSDr : SD_Intr<0x51, "sqrtsd {$src, $dst|$dst, $src}",
 446                           int_x86_sse2_sqrt_sd>;
 447 def Int_SQRTSDm : SD_Intm<0x51, "sqrtsd {$src, $dst|$dst, $src}",
 448                           int_x86_sse2_sqrt_sd>;
 449
 450 def Int_RSQRTSSr : SS_Intr<0x52, "rsqrtss {$src, $dst|$dst, $src}",
 451                            int_x86_sse_rsqrt_ss>;
 452 def Int_RSQRTSSm : SS_Intm<0x52, "rsqrtss {$src, $dst|$dst, $src}",
 453                            int_x86_sse_rsqrt_ss>;
 454 def Int_RCPSSr   : SS_Intr<0x53, "rcpss {$src, $dst|$dst, $src}",
 455                            int_x86_sse_rcp_ss>;
 456 def Int_RCPSSm   : SS_Intm<0x53, "rcpss {$src, $dst|$dst, $src}",
 457                            int_x86_sse_rcp_ss>;
 458
 459 let isTwoAddress = 1 in {
 460 def Int_MAXSSrr : SS_Intrr<0x5F, "maxss {$src2, $dst|$dst, $src2}",
 461                            int_x86_sse_max_ss>;
 462 def Int_MAXSSrm : SS_Intrm<0x5F, "maxss {$src2, $dst|$dst, $src2}",
 463                            int_x86_sse_max_ss>;
 464 def Int_MAXSDrr : SD_Intrr<0x5F, "maxsd {$src2, $dst|$dst, $src2}",
 465                            int_x86_sse2_max_sd>;
 466 def Int_MAXSDrm : SD_Intrm<0x5F, "maxsd {$src2, $dst|$dst, $src2}",
 467                            int_x86_sse2_max_sd>;
 468 def Int_MINSSrr : SS_Intrr<0x5D, "minss {$src2, $dst|$dst, $src2}",
 469                            int_x86_sse_min_ss>;
 470 def Int_MINSSrm : SS_Intrm<0x5D, "minss {$src2, $dst|$dst, $src2}",
 471                            int_x86_sse_min_ss>;
 472 def Int_MINSDrr : SD_Intrr<0x5D, "minsd {$src2, $dst|$dst, $src2}",
 473                            int_x86_sse2_min_sd>;
 474 def Int_MINSDrm : SD_Intrm<0x5D, "minsd {$src2, $dst|$dst, $src2}",
 475                            int_x86_sse2_min_sd>;
 476 }
 477
 478 // Conversion instructions
 479 def CVTSS2SIrr: SSI<0x2D, MRMSrcReg, (ops R32:$dst, FR32:$src),
 480                    "cvtss2si {$src, $dst|$dst, $src}", []>;
 481 def CVTSS2SIrm: SSI<0x2D, MRMSrcMem, (ops R32:$dst, f32mem:$src),
 482                    "cvtss2si {$src, $dst|$dst, $src}", []>;
 483
 484 def CVTTSS2SIrr: SSI<0x2C, MRMSrcReg, (ops R32:$dst, FR32:$src),
 485                     "cvttss2si {$src, $dst|$dst, $src}",
 486                     [(set R32:$dst, (fp_to_sint FR32:$src))]>;
 487 def CVTTSS2SIrm: SSI<0x2C, MRMSrcMem, (ops R32:$dst, f32mem:$src),
 488                     "cvttss2si {$src, $dst|$dst, $src}",
 489                     [(set R32:$dst, (fp_to_sint (loadf32 addr:$src)))]>;
 490 def CVTTSD2SIrr: SDI<0x2C, MRMSrcReg, (ops R32:$dst, FR64:$src),
 491                     "cvttsd2si {$src, $dst|$dst, $src}",
 492                     [(set R32:$dst, (fp_to_sint FR64:$src))]>;
 493 def CVTTSD2SIrm: SDI<0x2C, MRMSrcMem, (ops R32:$dst, f64mem:$src),
 494                     "cvttsd2si {$src, $dst|$dst, $src}",
 495                     [(set R32:$dst, (fp_to_sint (loadf64 addr:$src)))]>;
 496 def CVTSD2SSrr: SDI<0x5A, MRMSrcReg, (ops FR32:$dst, FR64:$src),
 497                    "cvtsd2ss {$src, $dst|$dst, $src}",
 498                    [(set FR32:$dst, (fround FR64:$src))]>;
 499 def CVTSD2SSrm: SDI<0x5A, MRMSrcMem, (ops FR32:$dst, f64mem:$src),
 500                    "cvtsd2ss {$src, $dst|$dst, $src}",
 501                    [(set FR32:$dst, (fround (loadf64 addr:$src)))]>;
 502 def CVTSI2SSrr: SSI<0x2A, MRMSrcReg, (ops FR32:$dst, R32:$src),
 503                   "cvtsi2ss {$src, $dst|$dst, $src}",
 504                   [(set FR32:$dst, (sint_to_fp R32:$src))]>;
 505 def CVTSI2SSrm: SSI<0x2A, MRMSrcMem, (ops FR32:$dst, i32mem:$src),
 506                    "cvtsi2ss {$src, $dst|$dst, $src}",
 507                    [(set FR32:$dst, (sint_to_fp (loadi32 addr:$src)))]>;
 508 def CVTSI2SDrr: SDI<0x2A, MRMSrcReg, (ops FR64:$dst, R32:$src),
 509                    "cvtsi2sd {$src, $dst|$dst, $src}",
 510                    [(set FR64:$dst, (sint_to_fp R32:$src))]>;
 511 def CVTSI2SDrm: SDI<0x2A, MRMSrcMem, (ops FR64:$dst, i32mem:$src),
 512                    "cvtsi2sd {$src, $dst|$dst, $src}",
 513                    [(set FR64:$dst, (sint_to_fp (loadi32 addr:$src)))]>;
 514 // SSE2 instructions with XS prefix
 515 def CVTSS2SDrr: I<0x5A, MRMSrcReg, (ops FR64:$dst, FR32:$src),
 516                  "cvtss2sd {$src, $dst|$dst, $src}",
 517                  [(set FR64:$dst, (fextend FR32:$src))]>, XS,
 518                 Requires<[HasSSE2]>;
 519 def CVTSS2SDrm: I<0x5A, MRMSrcMem, (ops FR64:$dst, f32mem:$src),
 520                  "cvtss2sd {$src, $dst|$dst, $src}",
 521                  [(set FR64:$dst, (fextend (loadf32 addr:$src)))]>, XS,
 522                 Requires<[HasSSE2]>;
 523
 524 // Comparison instructions
 525 let isTwoAddress = 1 in {
 526 def CMPSSrr : SSI<0xC2, MRMSrcReg,
 527                 (ops FR32:$dst, FR32:$src1, FR32:$src, SSECC:$cc),
 528                 "cmp${cc}ss {$src, $dst|$dst, $src}",
 529                  []>;
 530 def CMPSSrm : SSI<0xC2, MRMSrcMem,
 531                 (ops FR32:$dst, FR32:$src1, f32mem:$src, SSECC:$cc),
 532                 "cmp${cc}ss {$src, $dst|$dst, $src}", []>;
 533 def CMPSDrr : SDI<0xC2, MRMSrcReg,
 534                 (ops FR64:$dst, FR64:$src1, FR64:$src, SSECC:$cc),
 535                 "cmp${cc}sd {$src, $dst|$dst, $src}", []>;
 536 def CMPSDrm : SDI<0xC2, MRMSrcMem,
 537                 (ops FR64:$dst, FR64:$src1, f64mem:$src, SSECC:$cc),
 538                 "cmp${cc}sd {$src, $dst|$dst, $src}", []>;
 539 }
 540
 541 def UCOMISSrr: PSI<0x2E, MRMSrcReg, (ops FR32:$src1, FR32:$src2),
 542                  "ucomiss {$src2, $src1|$src1, $src2}",
 543                  [(X86cmp FR32:$src1, FR32:$src2)]>;
 544 def UCOMISSrm: PSI<0x2E, MRMSrcMem, (ops FR32:$src1, f32mem:$src2),
 545                  "ucomiss {$src2, $src1|$src1, $src2}",
 546                  [(X86cmp FR32:$src1, (loadf32 addr:$src2))]>;
 547 def UCOMISDrr: PDI<0x2E, MRMSrcReg, (ops FR64:$src1, FR64:$src2),
 548                  "ucomisd {$src2, $src1|$src1, $src2}",
 549                  [(X86cmp FR64:$src1, FR64:$src2)]>;
 550 def UCOMISDrm: PDI<0x2E, MRMSrcMem, (ops FR64:$src1, f64mem:$src2),
 551                  "ucomisd {$src2, $src1|$src1, $src2}",
 552                  [(X86cmp FR64:$src1, (loadf64 addr:$src2))]>;
 553
 554 // Aliases to match intrinsics which expect XMM operand(s).
 555 let isTwoAddress = 1 in {
 556 def Int_CMPSSrr : SSI<0xC2, MRMSrcReg,
 557                       (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
 558                       "cmp${cc}ss {$src, $dst|$dst, $src}",
 559                       [(set VR128:$dst, (int_x86_sse_cmp_ss VR128:$src1,
 560                                          VR128:$src, imm:$cc))]>;
 561 def Int_CMPSSrm : SSI<0xC2, MRMSrcMem,
 562                       (ops VR128:$dst, VR128:$src1, f32mem:$src, SSECC:$cc),
 563                       "cmp${cc}ss {$src, $dst|$dst, $src}",
 564                       [(set VR128:$dst, (int_x86_sse_cmp_ss VR128:$src1,
 565                                          (load addr:$src), imm:$cc))]>;
 566 def Int_CMPSDrr : SDI<0xC2, MRMSrcReg,
 567                       (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
 568                       "cmp${cc}sd {$src, $dst|$dst, $src}", []>;
 569 def Int_CMPSDrm : SDI<0xC2, MRMSrcMem,
 570                       (ops VR128:$dst, VR128:$src1, f64mem:$src, SSECC:$cc),
 571                       "cmp${cc}sd {$src, $dst|$dst, $src}", []>;
 572 }
 573
 574 def Int_UCOMISSrr: PSI<0x2E, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 575                        "ucomiss {$src2, $src1|$src1, $src2}",
 576                        [(X86ucomi (v4f32 VR128:$src1), VR128:$src2)]>;
 577 def Int_UCOMISSrm: PSI<0x2E, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 578                        "ucomiss {$src2, $src1|$src1, $src2}",
 579                       [(X86ucomi (v4f32 VR128:$src1), (loadv4f32 addr:$src2))]>;
 580 def Int_UCOMISDrr: PDI<0x2E, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 581                        "ucomisd {$src2, $src1|$src1, $src2}",
 582                        [(X86ucomi (v2f64 VR128:$src1), (v2f64 VR128:$src2))]>;
 583 def Int_UCOMISDrm: PDI<0x2E, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 584                        "ucomisd {$src2, $src1|$src1, $src2}",
 585                       [(X86ucomi (v2f64 VR128:$src1), (loadv2f64 addr:$src2))]>;
 586
 587 def Int_COMISSrr: PSI<0x2F, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 588                       "comiss {$src2, $src1|$src1, $src2}",
 589                       [(X86comi (v4f32 VR128:$src1), VR128:$src2)]>;
 590 def Int_COMISSrm: PSI<0x2F, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 591                       "comiss {$src2, $src1|$src1, $src2}",
 592                       [(X86comi (v4f32 VR128:$src1), (loadv4f32 addr:$src2))]>;
 593 def Int_COMISDrr: PDI<0x2F, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 594                       "comisd {$src2, $src1|$src1, $src2}",
 595                       [(X86comi (v2f64 VR128:$src1), (v2f64 VR128:$src2))]>;
 596 def Int_COMISDrm: PDI<0x2F, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 597                       "comisd {$src2, $src1|$src1, $src2}",
 598                       [(X86comi (v2f64 VR128:$src1), (loadv2f64 addr:$src2))]>;
 599
 600 // Aliases of packed instructions for scalar use. These all have names that
 601 // start with 'Fs'.
 602
 603 // Alias instructions that map fld0 to pxor for sse.
 604 // FIXME: remove when we can teach regalloc that xor reg, reg is ok.
 605 def FsFLD0SS : I<0xEF, MRMInitReg, (ops FR32:$dst),
 606                  "pxor $dst, $dst", [(set FR32:$dst, fp32imm0)]>,
 607                Requires<[HasSSE1]>, TB, OpSize;
 608 def FsFLD0SD : I<0xEF, MRMInitReg, (ops FR64:$dst),
 609                  "pxor $dst, $dst", [(set FR64:$dst, fp64imm0)]>,
 610                Requires<[HasSSE2]>, TB, OpSize;
 611
 612 // Alias instructions to do FR32 / FR64 reg-to-reg copy using movaps / movapd.
 613 // Upper bits are disregarded.
 614 def FsMOVAPSrr : PSI<0x28, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 615                    "movaps {$src, $dst|$dst, $src}", []>;
 616 def FsMOVAPDrr : PDI<0x28, MRMSrcReg, (ops FR64:$dst, FR64:$src),
 617                    "movapd {$src, $dst|$dst, $src}", []>;
 618
 619 // Alias instructions to load FR32 / FR64 from f128mem using movaps / movapd.
 620 // Upper bits are disregarded.
 621 def FsMOVAPSrm : PSI<0x28, MRMSrcMem, (ops FR32:$dst, f128mem:$src),
 622                    "movaps {$src, $dst|$dst, $src}",
 623                    [(set FR32:$dst, (X86loadpf32 addr:$src))]>;
 624 def FsMOVAPDrm : PDI<0x28, MRMSrcMem, (ops FR64:$dst, f128mem:$src),
 625                   "movapd {$src, $dst|$dst, $src}",
 626                   [(set FR64:$dst, (X86loadpf64 addr:$src))]>;
 627
 628 // Alias bitwise logical operations using SSE logical ops on packed FP values.
 629 let isTwoAddress = 1 in {
 630 let isCommutable = 1 in {
 631 def FsANDPSrr : PSI<0x54, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 632                   "andps {$src2, $dst|$dst, $src2}",
 633                   [(set FR32:$dst, (X86fand FR32:$src1, FR32:$src2))]>;
 634 def FsANDPDrr : PDI<0x54, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 635                   "andpd {$src2, $dst|$dst, $src2}",
 636                   [(set FR64:$dst, (X86fand FR64:$src1, FR64:$src2))]>;
 637 def FsORPSrr  : PSI<0x56, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 638                   "orps {$src2, $dst|$dst, $src2}", []>;
 639 def FsORPDrr  : PDI<0x56, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 640                   "orpd {$src2, $dst|$dst, $src2}", []>;
 641 def FsXORPSrr : PSI<0x57, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 642                   "xorps {$src2, $dst|$dst, $src2}",
 643                   [(set FR32:$dst, (X86fxor FR32:$src1, FR32:$src2))]>;
 644 def FsXORPDrr : PDI<0x57, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 645                   "xorpd {$src2, $dst|$dst, $src2}",
 646                   [(set FR64:$dst, (X86fxor FR64:$src1, FR64:$src2))]>;
 647 }
 648 def FsANDPSrm : PSI<0x54, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 649                   "andps {$src2, $dst|$dst, $src2}",
 650                   [(set FR32:$dst, (X86fand FR32:$src1,
 651                                     (X86loadpf32 addr:$src2)))]>;
 652 def FsANDPDrm : PDI<0x54, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f128mem:$src2),
 653                   "andpd {$src2, $dst|$dst, $src2}",
 654                   [(set FR64:$dst, (X86fand FR64:$src1,
 655                                     (X86loadpf64 addr:$src2)))]>;
 656 def FsORPSrm  : PSI<0x56, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 657                   "orps {$src2, $dst|$dst, $src2}", []>;
 658 def FsORPDrm  : PDI<0x56, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f128mem:$src2),
 659                   "orpd {$src2, $dst|$dst, $src2}", []>;
 660 def FsXORPSrm : PSI<0x57, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 661                   "xorps {$src2, $dst|$dst, $src2}",
 662                   [(set FR32:$dst, (X86fxor FR32:$src1,
 663                                     (X86loadpf32 addr:$src2)))]>;
 664 def FsXORPDrm : PDI<0x57, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f128mem:$src2),
 665                   "xorpd {$src2, $dst|$dst, $src2}",
 666                   [(set FR64:$dst, (X86fxor FR64:$src1,
 667                                     (X86loadpf64 addr:$src2)))]>;
 668
 669 def FsANDNPSrr : PSI<0x55, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 670                    "andnps {$src2, $dst|$dst, $src2}", []>;
 671 def FsANDNPSrm : PSI<0x55, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 672                    "andnps {$src2, $dst|$dst, $src2}", []>;
 673 def FsANDNPDrr : PDI<0x55, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 674                    "andnpd {$src2, $dst|$dst, $src2}", []>;
 675 def FsANDNPDrm : PDI<0x55, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f128mem:$src2),
 676                    "andnpd {$src2, $dst|$dst, $src2}", []>;
 677 }
 678
 679 //===----------------------------------------------------------------------===//
 680 // SSE packed FP Instructions
 681 //===----------------------------------------------------------------------===//
 682
 683 // Some 'special' instructions
 684 def IMPLICIT_DEF_VR128 : I<0, Pseudo, (ops VR128:$dst),
 685                            "#IMPLICIT_DEF $dst",
 686                            [(set VR128:$dst, (v4f32 (undef)))]>,
 687                          Requires<[HasSSE1]>;
 688
 689 // Move Instructions
 690 def MOVAPSrr : PSI<0x28, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 691                    "movaps {$src, $dst|$dst, $src}", []>;
 692 def MOVAPSrm : PSI<0x28, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 693                    "movaps {$src, $dst|$dst, $src}",
 694                    [(set VR128:$dst, (loadv4f32 addr:$src))]>;
 695 def MOVAPDrr : PDI<0x28, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 696                    "movapd {$src, $dst|$dst, $src}", []>;
 697 def MOVAPDrm : PDI<0x28, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 698                    "movapd {$src, $dst|$dst, $src}",
 699                    [(set VR128:$dst, (loadv2f64 addr:$src))]>;
 700
 701 def MOVAPSmr : PSI<0x29, MRMDestMem, (ops f128mem:$dst, VR128:$src),
 702                    "movaps {$src, $dst|$dst, $src}",
 703                    [(store (v4f32 VR128:$src), addr:$dst)]>;
 704 def MOVAPDmr : PDI<0x29, MRMDestMem, (ops f128mem:$dst, VR128:$src),
 705                    "movapd {$src, $dst|$dst, $src}",
 706                    [(store (v2f64 VR128:$src), addr:$dst)]>;
 707
 708 def MOVUPSrr : PSI<0x10, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 709                    "movups {$src, $dst|$dst, $src}", []>;
 710 def MOVUPSrm : PSI<0x10, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 711                    "movups {$src, $dst|$dst, $src}", []>;
 712 def MOVUPSmr : PSI<0x11, MRMDestMem, (ops f128mem:$dst, VR128:$src),
 713                    "movups {$src, $dst|$dst, $src}", []>;
 714 def MOVUPDrr : PDI<0x10, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 715                    "movupd {$src, $dst|$dst, $src}", []>;
 716 def MOVUPDrm : PDI<0x10, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 717                    "movupd {$src, $dst|$dst, $src}", []>;
 718 def MOVUPDmr : PDI<0x11, MRMDestMem, (ops f128mem:$dst, VR128:$src),
 719                    "movupd {$src, $dst|$dst, $src}", []>;
 720
 721 let isTwoAddress = 1 in {
 722 def MOVLPSrm : PSI<0x12, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f64mem:$src2),
 723                    "movlps {$src2, $dst|$dst, $src2}",
 724                    [(set VR128:$dst,
 725                      (v4f32 (vector_shuffle VR128:$src1,
 726                      (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2)))),
 727                              MOVLP_shuffle_mask)))]>;
 728 def MOVLPDrm : PDI<0x12, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f64mem:$src2),
 729                    "movlpd {$src2, $dst|$dst, $src2}",
 730                    [(set VR128:$dst,
 731                      (v2f64 (vector_shuffle VR128:$src1,
 732                              (scalar_to_vector (loadf64 addr:$src2)),
 733                              MOVLP_shuffle_mask)))]>;
 734 def MOVHPSrm : PSI<0x16, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f64mem:$src2),
 735                    "movhps {$src2, $dst|$dst, $src2}",
 736                    [(set VR128:$dst,
 737                      (v4f32 (vector_shuffle VR128:$src1,
 738                      (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2)))),
 739                              MOVHP_shuffle_mask)))]>;
 740 def MOVHPDrm : PDI<0x16, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f64mem:$src2),
 741                    "movhpd {$src2, $dst|$dst, $src2}",
 742                    [(set VR128:$dst,
 743                      (v2f64 (vector_shuffle VR128:$src1,
 744                              (scalar_to_vector (loadf64 addr:$src2)),
 745                              MOVHP_shuffle_mask)))]>;
 746 }
 747
 748 def MOVLPSmr : PSI<0x13, MRMDestMem, (ops f64mem:$dst, VR128:$src),
 749                    "movlps {$src, $dst|$dst, $src}",
 750                    [(store (f64 (vector_extract (bc_v2f64 (v4f32 VR128:$src)),
 751                                  (i32 0))), addr:$dst)]>;
 752 def MOVLPDmr : PDI<0x13, MRMDestMem, (ops f64mem:$dst, VR128:$src),
 753                    "movlpd {$src, $dst|$dst, $src}",
 754                    [(store (f64 (vector_extract (v2f64 VR128:$src),
 755                                  (i32 0))), addr:$dst)]>;
 756
 757 // v2f64 extract element 1 is always custom lowered to unpack high to low
 758 // and extract element 0 so the non-store version isn't too horrible.
 759 def MOVHPSmr : PSI<0x17, MRMDestMem, (ops f64mem:$dst, VR128:$src),
 760                    "movhps {$src, $dst|$dst, $src}",
 761                    [(store (f64 (vector_extract
 762                                  (v2f64 (vector_shuffle
 763                                          (bc_v2f64 (v4f32 VR128:$src)), (undef),
 764                                          UNPCKH_shuffle_mask)), (i32 0))),
 765                      addr:$dst)]>;
 766 def MOVHPDmr : PDI<0x17, MRMDestMem, (ops f64mem:$dst, VR128:$src),
 767                    "movhpd {$src, $dst|$dst, $src}",
 768                    [(store (f64 (vector_extract
 769                                  (v2f64 (vector_shuffle VR128:$src, (undef),
 770                                          UNPCKH_shuffle_mask)), (i32 0))),
 771                      addr:$dst)]>;
 772
 773 let isTwoAddress = 1 in {
 774 def MOVLHPSrr : PSI<0x16, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 775                     "movlhps {$src2, $dst|$dst, $src2}",
 776                     [(set VR128:$dst,
 777                       (v4f32 (vector_shuffle VR128:$src1, VR128:$src2,
 778                               MOVLHPS_shuffle_mask)))]>;
 779
 780 def MOVHLPSrr : PSI<0x12, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 781                     "movhlps {$src2, $dst|$dst, $src2}",
 782                     [(set VR128:$dst,
 783                       (v4f32 (vector_shuffle VR128:$src1, VR128:$src2,
 784                               MOVHLPS_shuffle_mask)))]>;
 785 }
 786
 787 // Conversion instructions
 788 def CVTPI2PSr : PSI<0x2A, MRMSrcReg, (ops VR128:$dst, VR64:$src),
 789                     "cvtpi2ps {$src, $dst|$dst, $src}", []>;
 790 def CVTPI2PSm : PSI<0x2A, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
 791                     "cvtpi2ps {$src, $dst|$dst, $src}", []>;
 792 def CVTPI2PDr : PDI<0x2A, MRMSrcReg, (ops VR128:$dst, VR64:$src),
 793                     "cvtpi2pd {$src, $dst|$dst, $src}", []>;
 794 def CVTPI2PDm : PDI<0x2A, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
 795                     "cvtpi2pd {$src, $dst|$dst, $src}", []>;
 796
 797 // SSE2 instructions without OpSize prefix
 798 def CVTDQ2PSr : I<0x5B, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 799                   "cvtdq2ps {$src, $dst|$dst, $src}", []>, TB,
 800                 Requires<[HasSSE2]>;
 801 def CVTDQ2PSm : I<0x5B, MRMSrcMem, (ops VR128:$dst, i128mem:$src),
 802                   "cvtdq2ps {$src, $dst|$dst, $src}", []>, TB,
 803                 Requires<[HasSSE2]>;
 804
 805 // SSE2 instructions with XS prefix
 806 def CVTDQ2PDr : I<0xE6, MRMSrcReg, (ops VR128:$dst, VR64:$src),
 807                   "cvtdq2pd {$src, $dst|$dst, $src}", []>,
 808                 XS, Requires<[HasSSE2]>;
 809 def CVTDQ2PDm : I<0xE6, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
 810                   "cvtdq2pd {$src, $dst|$dst, $src}", []>,
 811                 XS, Requires<[HasSSE2]>;
 812
 813 def CVTPS2PIr : PSI<0x2D, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 814                     "cvtps2pi {$src, $dst|$dst, $src}", []>;
 815 def CVTPS2PIm : PSI<0x2D, MRMSrcMem, (ops VR64:$dst, f64mem:$src),
 816                     "cvtps2pi {$src, $dst|$dst, $src}", []>;
 817 def CVTPD2PIr : PDI<0x2D, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 818                     "cvtpd2pi {$src, $dst|$dst, $src}", []>;
 819 def CVTPD2PIm : PDI<0x2D, MRMSrcMem, (ops VR64:$dst, f128mem:$src),
 820                     "cvtpd2pi {$src, $dst|$dst, $src}", []>;
 821
 822 def CVTPS2DQr : PDI<0x5B, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 823                     "cvtps2dq {$src, $dst|$dst, $src}", []>;
 824 def CVTPS2DQm : PDI<0x5B, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 825                     "cvtps2dq {$src, $dst|$dst, $src}", []>;
 826 // SSE2 packed instructions with XD prefix
 827 def CVTPD2DQr : SDI<0xE6, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 828                     "cvtpd2dq {$src, $dst|$dst, $src}", []>;
 829 def CVTPD2DQm : SDI<0xE6, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 830                     "cvtpd2dq {$src, $dst|$dst, $src}", []>;
 831
 832 // SSE2 instructions without OpSize prefix
 833 def CVTPS2PDr : I<0x5A, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 834                   "cvtps2pd {$src, $dst|$dst, $src}", []>, TB,
 835                 Requires<[HasSSE2]>;
 836 def CVTPS2PDm : I<0x5A, MRMSrcReg, (ops VR128:$dst, f64mem:$src),
 837                   "cvtps2pd {$src, $dst|$dst, $src}", []>, TB,
 838                 Requires<[HasSSE2]>;
 839
 840 def CVTPD2PSr : PDI<0x5A, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 841                     "cvtpd2ps {$src, $dst|$dst, $src}", []>;
 842 def CVTPD2PSm : PDI<0x5A, MRMSrcReg, (ops VR128:$dst, f128mem:$src),
 843                     "cvtpd2ps {$src, $dst|$dst, $src}", []>;
 844
 845 // Arithmetic
 846 let isTwoAddress = 1 in {
 847 let isCommutable = 1 in {
 848 def ADDPSrr : PSI<0x58, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 849                   "addps {$src2, $dst|$dst, $src2}",
 850                   [(set VR128:$dst, (v4f32 (fadd VR128:$src1, VR128:$src2)))]>;
 851 def ADDPDrr : PDI<0x58, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 852                   "addpd {$src2, $dst|$dst, $src2}",
 853                   [(set VR128:$dst, (v2f64 (fadd VR128:$src1, VR128:$src2)))]>;
 854 def MULPSrr : PSI<0x59, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 855                   "mulps {$src2, $dst|$dst, $src2}",
 856                   [(set VR128:$dst, (v4f32 (fmul VR128:$src1, VR128:$src2)))]>;
 857 def MULPDrr : PDI<0x59, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 858                   "mulpd {$src2, $dst|$dst, $src2}",
 859                   [(set VR128:$dst, (v2f64 (fmul VR128:$src1, VR128:$src2)))]>;
 860 }
 861
 862 def ADDPSrm : PSI<0x58, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 863                   "addps {$src2, $dst|$dst, $src2}",
 864                   [(set VR128:$dst, (v4f32 (fadd VR128:$src1,
 865                                             (load addr:$src2))))]>;
 866 def ADDPDrm : PDI<0x58, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 867                   "addpd {$src2, $dst|$dst, $src2}",
 868                   [(set VR128:$dst, (v2f64 (fadd VR128:$src1,
 869                                             (load addr:$src2))))]>;
 870 def MULPSrm : PSI<0x59, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 871                   "mulps {$src2, $dst|$dst, $src2}",
 872                   [(set VR128:$dst, (v4f32 (fmul VR128:$src1,
 873                                             (load addr:$src2))))]>;
 874 def MULPDrm : PDI<0x59, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 875                   "mulpd {$src2, $dst|$dst, $src2}",
 876                   [(set VR128:$dst, (v2f64 (fmul VR128:$src1,
 877                                             (load addr:$src2))))]>;
 878
 879 def DIVPSrr : PSI<0x5E, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 880                   "divps {$src2, $dst|$dst, $src2}",
 881                   [(set VR128:$dst, (v4f32 (fdiv VR128:$src1, VR128:$src2)))]>;
 882 def DIVPSrm : PSI<0x5E, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 883                   "divps {$src2, $dst|$dst, $src2}",
 884                   [(set VR128:$dst, (v4f32 (fdiv VR128:$src1,
 885                                             (load addr:$src2))))]>;
 886 def DIVPDrr : PDI<0x5E, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 887                 "divpd {$src2, $dst|$dst, $src2}",
 888                   [(set VR128:$dst, (v2f64 (fdiv VR128:$src1, VR128:$src2)))]>;
 889 def DIVPDrm : PDI<0x5E, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 890                 "divpd {$src2, $dst|$dst, $src2}",
 891                   [(set VR128:$dst, (v2f64 (fdiv VR128:$src1,
 892                                             (load addr:$src2))))]>;
 893
 894 def SUBPSrr : PSI<0x5C, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 895                   "subps {$src2, $dst|$dst, $src2}",
 896                   [(set VR128:$dst, (v4f32 (fsub VR128:$src1, VR128:$src2)))]>;
 897 def SUBPSrm : PSI<0x5C, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 898                   "subps {$src2, $dst|$dst, $src2}",
 899                   [(set VR128:$dst, (v4f32 (fsub VR128:$src1,
 900                                             (load addr:$src2))))]>;
 901 def SUBPDrr : PDI<0x5C, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 902                   "subpd {$src2, $dst|$dst, $src2}",
 903                   [(set VR128:$dst, (v2f64 (fsub VR128:$src1, VR128:$src2)))]>;
 904 def SUBPDrm : PDI<0x5C, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 905                   "subpd {$src2, $dst|$dst, $src2}",
 906                   [(set VR128:$dst, (v2f64 (fsub VR128:$src1,
 907                                             (load addr:$src2))))]>;
 908 }
 909
 910 def SQRTPSr : PS_Intr<0x51, "sqrtps {$src, $dst|$dst, $src}",
 911                       int_x86_sse_sqrt_ps>;
 912 def SQRTPSm : PS_Intm<0x51, "sqrtps {$src, $dst|$dst, $src}",
 913                       int_x86_sse_sqrt_ps>;
 914 def SQRTPDr : PD_Intr<0x51, "sqrtpd {$src, $dst|$dst, $src}",
 915                       int_x86_sse2_sqrt_pd>;
 916 def SQRTPDm : PD_Intm<0x51, "sqrtpd {$src, $dst|$dst, $src}",
 917                       int_x86_sse2_sqrt_pd>;
 918
 919 def RSQRTPSr : PS_Intr<0x52, "rsqrtps {$src, $dst|$dst, $src}",
 920                        int_x86_sse_rsqrt_ps>;
 921 def RSQRTPSm : PS_Intm<0x52, "rsqrtps {$src, $dst|$dst, $src}",
 922                        int_x86_sse_rsqrt_ps>;
 923 def RCPPSr : PS_Intr<0x53, "rcpps {$src, $dst|$dst, $src}",
 924                      int_x86_sse_rcp_ps>;
 925 def RCPPSm : PS_Intm<0x53, "rcpps {$src, $dst|$dst, $src}",
 926                      int_x86_sse_rcp_ps>;
 927
 928 let isTwoAddress = 1 in {
 929 def MAXPSrr : PS_Intrr<0x5F, "maxps {$src2, $dst|$dst, $src2}",
 930                        int_x86_sse_max_ps>;
 931 def MAXPSrm : PS_Intrm<0x5F, "maxps {$src2, $dst|$dst, $src2}",
 932                        int_x86_sse_max_ps>;
 933 def MAXPDrr : PD_Intrr<0x5F, "maxpd {$src2, $dst|$dst, $src2}",
 934                        int_x86_sse2_max_pd>;
 935 def MAXPDrm : PD_Intrm<0x5F, "maxpd {$src2, $dst|$dst, $src2}",
 936                        int_x86_sse2_max_pd>;
 937 def MINPSrr : PS_Intrr<0x5D, "minps {$src2, $dst|$dst, $src2}",
 938                        int_x86_sse_min_ps>;
 939 def MINPSrm : PS_Intrm<0x5D, "minps {$src2, $dst|$dst, $src2}",
 940                        int_x86_sse_min_ps>;
 941 def MINPDrr : PD_Intrr<0x5D, "minpd {$src2, $dst|$dst, $src2}",
 942                        int_x86_sse2_min_pd>;
 943 def MINPDrm : PD_Intrm<0x5D, "minpd {$src2, $dst|$dst, $src2}",
 944                        int_x86_sse2_min_pd>;
 945 }
 946
 947 // Logical
 948 let isTwoAddress = 1 in {
 949 let isCommutable = 1 in {
 950 def ANDPSrr : PSI<0x54, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 951                   "andps {$src2, $dst|$dst, $src2}",
 952                   [(set VR128:$dst,
 953                     (and (bc_v4i32 (v4f32 VR128:$src1)),
 954                      (bc_v4i32 (v4f32 VR128:$src2))))]>;
 955 def ANDPDrr : PDI<0x54, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 956                 "andpd {$src2, $dst|$dst, $src2}",
 957                   [(set VR128:$dst,
 958                     (and (bc_v2i64 (v2f64 VR128:$src1)),
 959                      (bc_v2i64 (v2f64 VR128:$src2))))]>;
 960 def ORPSrr  : PSI<0x56, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 961                   "orps {$src2, $dst|$dst, $src2}",
 962                   [(set VR128:$dst,
 963                     (or (bc_v4i32 (v4f32 VR128:$src1)),
 964                      (bc_v4i32 (v4f32 VR128:$src2))))]>;
 965 def ORPDrr  : PDI<0x56, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 966                   "orpd {$src2, $dst|$dst, $src2}",
 967                   [(set VR128:$dst,
 968                     (or (bc_v2i64 (v2f64 VR128:$src1)),
 969                      (bc_v2i64 (v2f64 VR128:$src2))))]>;
 970 def XORPSrr : PSI<0x57, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 971                   "xorps {$src2, $dst|$dst, $src2}",
 972                   [(set VR128:$dst,
 973                     (xor (bc_v4i32 (v4f32 VR128:$src1)),
 974                      (bc_v4i32 (v4f32 VR128:$src2))))]>;
 975 def XORPDrr : PDI<0x57, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 976                   "xorpd {$src2, $dst|$dst, $src2}",
 977                   [(set VR128:$dst,
 978                     (xor (bc_v2i64 (v2f64 VR128:$src1)),
 979                      (bc_v2i64 (v2f64 VR128:$src2))))]>;
 980 }
 981 def ANDPSrm : PSI<0x54, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 982                   "andps {$src2, $dst|$dst, $src2}",
 983                 [(set VR128:$dst,
 984                   (and (bc_v4i32 (v4f32 VR128:$src1)),
 985                    (bc_v4i32 (loadv4f32 addr:$src2))))]>;
 986 def ANDPDrm : PDI<0x54, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 987                   "andpd {$src2, $dst|$dst, $src2}",
 988                 [(set VR128:$dst,
 989                   (and (bc_v2i64 (v2f64 VR128:$src1)),
 990                    (bc_v2i64 (loadv2f64 addr:$src2))))]>;
 991 def ORPSrm  : PSI<0x56, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 992                   "orps {$src2, $dst|$dst, $src2}",
 993                  [(set VR128:$dst,
 994                    (or (bc_v4i32 (v4f32 VR128:$src1)),
 995                     (bc_v4i32 (loadv4f32 addr:$src2))))]>;
 996 def ORPDrm  : PDI<0x56, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 997                 "orpd {$src2, $dst|$dst, $src2}",
 998                  [(set VR128:$dst,
 999                    (or (bc_v2i64 (v2f64 VR128:$src1)),
1000                     (bc_v2i64 (loadv2f64 addr:$src2))))]>;
1001 def XORPSrm : PSI<0x57, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1002                   "xorps {$src2, $dst|$dst, $src2}",
1003                 [(set VR128:$dst,
1004                   (xor (bc_v4i32 (v4f32 VR128:$src1)),
1005                    (bc_v4i32 (loadv4f32 addr:$src2))))]>;
1006 def XORPDrm : PDI<0x57, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1007                   "xorpd {$src2, $dst|$dst, $src2}",
1008                 [(set VR128:$dst,
1009                   (xor (bc_v2i64 (v2f64 VR128:$src1)),
1010                    (bc_v2i64 (loadv2f64 addr:$src2))))]>;
1011 def ANDNPSrr : PSI<0x55, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1012                   "andnps {$src2, $dst|$dst, $src2}",
1013                 [(set VR128:$dst,
1014                   (and (vnot (bc_v4i32 (v4f32 VR128:$src1))),
1015                    (bc_v4i32 (v4f32 VR128:$src2))))]>;
1016 def ANDNPSrm : PSI<0x55, MRMSrcMem, (ops VR128:$dst, VR128:$src1,f128mem:$src2),
1017                   "andnps {$src2, $dst|$dst, $src2}",
1018                   [(set VR128:$dst,
1019                     (and (vnot (bc_v4i32 (v4f32 VR128:$src1))),
1020                      (bc_v4i32 (loadv4f32 addr:$src2))))]>;
1021 def ANDNPDrr : PDI<0x55, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1022                   "andnpd {$src2, $dst|$dst, $src2}",
1023                 [(set VR128:$dst,
1024                   (and (vnot (bc_v2i64 (v2f64 VR128:$src1))),
1025                    (bc_v2i64 (v2f64 VR128:$src2))))]>;
1026 def ANDNPDrm : PDI<0x55, MRMSrcMem, (ops VR128:$dst, VR128:$src1,f128mem:$src2),
1027                   "andnpd {$src2, $dst|$dst, $src2}",
1028                   [(set VR128:$dst,
1029                     (and (vnot (bc_v2i64 (v2f64 VR128:$src1))),
1030                      (bc_v2i64 (loadv2f64 addr:$src2))))]>;
1031 }
1032
1033 let isTwoAddress = 1 in {
1034 def CMPPSrr : PSIi8<0xC2, MRMSrcReg,
1035                     (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
1036                     "cmp${cc}ps {$src, $dst|$dst, $src}",
1037                     [(set VR128:$dst, (int_x86_sse_cmp_ps VR128:$src1,
1038                                        VR128:$src, imm:$cc))]>;
1039 def CMPPSrm : PSIi8<0xC2, MRMSrcMem,
1040                     (ops VR128:$dst, VR128:$src1, f128mem:$src, SSECC:$cc),
1041                     "cmp${cc}ps {$src, $dst|$dst, $src}",
1042                     [(set VR128:$dst, (int_x86_sse_cmp_ps VR128:$src1,
1043                                        (load addr:$src), imm:$cc))]>;
1044 def CMPPDrr : PDIi8<0xC2, MRMSrcReg,
1045                     (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
1046                     "cmp${cc}pd {$src, $dst|$dst, $src}", []>;
1047 def CMPPDrm : PDIi8<0xC2, MRMSrcMem,
1048                     (ops VR128:$dst, VR128:$src1, f128mem:$src, SSECC:$cc),
1049                     "cmp${cc}pd {$src, $dst|$dst, $src}", []>;
1050 }
1051
1052 // Shuffle and unpack instructions
1053 let isTwoAddress = 1 in {
1054 def SHUFPSrr : PSIi8<0xC6, MRMSrcReg,
1055                      (ops VR128:$dst, VR128:$src1, VR128:$src2, i32i8imm:$src3),
1056                      "shufps {$src3, $src2, $dst|$dst, $src2, $src3}",
1057                      [(set VR128:$dst, (v4f32 (vector_shuffle
1058                                                VR128:$src1, VR128:$src2,
1059                                                SHUFP_shuffle_mask:$src3)))]>;
1060 def SHUFPSrm : PSIi8<0xC6, MRMSrcMem,
1061                    (ops VR128:$dst, VR128:$src1, f128mem:$src2, i32i8imm:$src3),
1062                      "shufps {$src3, $src2, $dst|$dst, $src2, $src3}",
1063                      [(set VR128:$dst, (v4f32 (vector_shuffle
1064                                                VR128:$src1, (load addr:$src2),
1065                                                SHUFP_shuffle_mask:$src3)))]>;
1066 def SHUFPDrr : PDIi8<0xC6, MRMSrcReg,
1067                      (ops VR128:$dst, VR128:$src1, VR128:$src2, i8imm:$src3),
1068                      "shufpd {$src3, $src2, $dst|$dst, $src2, $src3}",
1069                      [(set VR128:$dst, (v2f64 (vector_shuffle
1070                                                VR128:$src1, VR128:$src2,
1071                                                SHUFP_shuffle_mask:$src3)))]>;
1072 def SHUFPDrm : PDIi8<0xC6, MRMSrcMem,
1073                      (ops VR128:$dst, VR128:$src1, f128mem:$src2, i8imm:$src3),
1074                      "shufpd {$src3, $src2, $dst|$dst, $src2, $src3}",
1075                      [(set VR128:$dst, (v2f64 (vector_shuffle
1076                                                VR128:$src1, (load addr:$src2),
1077                                                SHUFP_shuffle_mask:$src3)))]>;
1078
1079 def UNPCKHPSrr : PSI<0x15, MRMSrcReg,
1080                     (ops VR128:$dst, VR128:$src1, VR128:$src2),
1081                     "unpckhps {$src2, $dst|$dst, $src2}",
1082                     [(set VR128:$dst, (v4f32 (vector_shuffle
1083                                               VR128:$src1, VR128:$src2,
1084                                               UNPCKH_shuffle_mask)))]>;
1085 def UNPCKHPSrm : PSI<0x15, MRMSrcMem,
1086                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1087                     "unpckhps {$src2, $dst|$dst, $src2}",
1088                     [(set VR128:$dst, (v4f32 (vector_shuffle
1089                                               VR128:$src1, (load addr:$src2),
1090                                               UNPCKH_shuffle_mask)))]>;
1091 def UNPCKHPDrr : PDI<0x15, MRMSrcReg,
1092                     (ops VR128:$dst, VR128:$src1, VR128:$src2),
1093                     "unpckhpd {$src2, $dst|$dst, $src2}",
1094                     [(set VR128:$dst, (v2f64 (vector_shuffle
1095                                               VR128:$src1, VR128:$src2,
1096                                               UNPCKH_shuffle_mask)))]>;
1097 def UNPCKHPDrm : PDI<0x15, MRMSrcMem,
1098                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1099                     "unpckhpd {$src2, $dst|$dst, $src2}",
1100                     [(set VR128:$dst, (v2f64 (vector_shuffle
1101                                               VR128:$src1, (load addr:$src2),
1102                                               UNPCKH_shuffle_mask)))]>;
1103
1104 def UNPCKLPSrr : PSI<0x14, MRMSrcReg,
1105                     (ops VR128:$dst, VR128:$src1, VR128:$src2),
1106                     "unpcklps {$src2, $dst|$dst, $src2}",
1107                     [(set VR128:$dst, (v4f32 (vector_shuffle
1108                                               VR128:$src1, VR128:$src2,
1109                                               UNPCKL_shuffle_mask)))]>;
1110 def UNPCKLPSrm : PSI<0x14, MRMSrcMem,
1111                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1112                     "unpcklps {$src2, $dst|$dst, $src2}",
1113                     [(set VR128:$dst, (v4f32 (vector_shuffle
1114                                               VR128:$src1, (load addr:$src2),
1115                                               UNPCKL_shuffle_mask)))]>;
1116 def UNPCKLPDrr : PDI<0x14, MRMSrcReg,
1117                     (ops VR128:$dst, VR128:$src1, VR128:$src2),
1118                     "unpcklpd {$src2, $dst|$dst, $src2}",
1119                     [(set VR128:$dst, (v2f64 (vector_shuffle
1120                                               VR128:$src1, VR128:$src2,
1121                                               UNPCKL_shuffle_mask)))]>;
1122 def UNPCKLPDrm : PDI<0x14, MRMSrcMem,
1123                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1124                     "unpcklpd {$src2, $dst|$dst, $src2}",
1125                     [(set VR128:$dst, (v2f64 (vector_shuffle
1126                                               VR128:$src1, (load addr:$src2),
1127                                               UNPCKL_shuffle_mask)))]>;
1128 }
1129
1130 // Horizontal ops
1131 let isTwoAddress = 1 in {
1132 def HADDPSrr : S3S_Intrr<0x7C, "haddps {$src2, $dst|$dst, $src2}",
1133                           int_x86_sse3_hadd_ps>;
1134 def HADDPSrm : S3S_Intrm<0x7C, "haddps {$src2, $dst|$dst, $src2}",
1135                           int_x86_sse3_hadd_ps>;
1136 def HADDPDrr : S3D_Intrr<0x7C, "haddpd {$src2, $dst|$dst, $src2}",
1137                           int_x86_sse3_hadd_pd>;
1138 def HADDPDrm : S3D_Intrm<0x7C, "haddpd {$src2, $dst|$dst, $src2}",
1139                           int_x86_sse3_hadd_pd>;
1140 def HSUBPSrr : S3S_Intrr<0x7C, "hsubps {$src2, $dst|$dst, $src2}",
1141                           int_x86_sse3_hsub_ps>;
1142 def HSUBPSrm : S3S_Intrm<0x7C, "hsubps {$src2, $dst|$dst, $src2}",
1143                           int_x86_sse3_hsub_ps>;
1144 def HSUBPDrr : S3D_Intrr<0x7C, "hsubpd {$src2, $dst|$dst, $src2}",
1145                           int_x86_sse3_hsub_pd>;
1146 def HSUBPDrm : S3D_Intrm<0x7C, "hsubpd {$src2, $dst|$dst, $src2}",
1147                           int_x86_sse3_hsub_pd>;
1148 }
1149
1150 //===----------------------------------------------------------------------===//
1151 // SSE integer instructions
1152 //===----------------------------------------------------------------------===//
1153
1154 // Move Instructions
1155 def MOVDQArr : PDI<0x6F, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1156                    "movdqa {$src, $dst|$dst, $src}", []>;
1157 def MOVDQArm : PDI<0x6F, MRMSrcMem, (ops VR128:$dst, i128mem:$src),
1158                    "movdqa {$src, $dst|$dst, $src}",
1159                    [(set VR128:$dst, (loadv4i32 addr:$src))]>;
1160 def MOVDQAmr : PDI<0x7F, MRMDestMem, (ops i128mem:$dst, VR128:$src),
1161                    "movdqa {$src, $dst|$dst, $src}",
1162                    [(store (v4i32 VR128:$src), addr:$dst)]>;
1163
1164 // 128-bit Integer Arithmetic
1165 let isTwoAddress = 1 in {
1166 let isCommutable = 1 in {
1167 def PADDBrr : PDI<0xFC, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1168                   "paddb {$src2, $dst|$dst, $src2}",
1169               [(set VR128:$dst, (v16i8 (add VR128:$src1, VR128:$src2)))]>;
1170 def PADDWrr : PDI<0xFD, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1171                   "paddw {$src2, $dst|$dst, $src2}",
1172               [(set VR128:$dst, (v8i16 (add VR128:$src1, VR128:$src2)))]>;
1173 def PADDDrr : PDI<0xFE, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1174                   "paddd {$src2, $dst|$dst, $src2}",
1175               [(set VR128:$dst, (v4i32 (add VR128:$src1, VR128:$src2)))]>;
1176
1177 def PADDQrr : PDI<0xD4, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1178                   "paddq {$src2, $dst|$dst, $src2}",
1179               [(set VR128:$dst, (v2i64 (add VR128:$src1, VR128:$src2)))]>;
1180 }
1181 def PADDBrm : PDI<0xFC, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1182                   "paddb {$src2, $dst|$dst, $src2}",
1183               [(set VR128:$dst, (v16i8 (add VR128:$src1,
1184                                         (load addr:$src2))))]>;
1185 def PADDWrm : PDI<0xFD, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1186                   "paddw {$src2, $dst|$dst, $src2}",
1187               [(set VR128:$dst, (v8i16 (add VR128:$src1,
1188                                         (load addr:$src2))))]>;
1189 def PADDDrm : PDI<0xFE, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1190                   "paddd {$src2, $dst|$dst, $src2}",
1191               [(set VR128:$dst, (v4i32 (add VR128:$src1,
1192                                         (load addr:$src2))))]>;
1193 def PADDQrm : PDI<0xD4, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1194                   "paddd {$src2, $dst|$dst, $src2}",
1195               [(set VR128:$dst, (v2i64 (add VR128:$src1,
1196                                         (load addr:$src2))))]>;
1197
1198 def PSUBBrr : PDI<0xF8, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1199                   "psubb {$src2, $dst|$dst, $src2}",
1200               [(set VR128:$dst, (v16i8 (sub VR128:$src1, VR128:$src2)))]>;
1201 def PSUBWrr : PDI<0xF9, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1202                   "psubw {$src2, $dst|$dst, $src2}",
1203               [(set VR128:$dst, (v8i16 (sub VR128:$src1, VR128:$src2)))]>;
1204 def PSUBDrr : PDI<0xFA, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1205                   "psubd {$src2, $dst|$dst, $src2}",
1206               [(set VR128:$dst, (v4i32 (sub VR128:$src1, VR128:$src2)))]>;
1207 def PSUBQrr : PDI<0xFB, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1208                   "psubq {$src2, $dst|$dst, $src2}",
1209               [(set VR128:$dst, (v2i64 (sub VR128:$src1, VR128:$src2)))]>;
1210
1211 def PSUBBrm : PDI<0xF8, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1212                   "psubb {$src2, $dst|$dst, $src2}",
1213               [(set VR128:$dst, (v16i8 (sub VR128:$src1,
1214                                         (load addr:$src2))))]>;
1215 def PSUBWrm : PDI<0xF9, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1216                   "psubw {$src2, $dst|$dst, $src2}",
1217               [(set VR128:$dst, (v8i16 (sub VR128:$src1,
1218                                         (load addr:$src2))))]>;
1219 def PSUBDrm : PDI<0xFA, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1220                   "psubd {$src2, $dst|$dst, $src2}",
1221               [(set VR128:$dst, (v4i32 (sub VR128:$src1,
1222                                         (load addr:$src2))))]>;
1223 def PSUBQrm : PDI<0xFB, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1224                   "psubd {$src2, $dst|$dst, $src2}",
1225               [(set VR128:$dst, (v2i64 (sub VR128:$src1,
1226                                         (load addr:$src2))))]>;
1227 }
1228
1229 let isTwoAddress = 1 in {
1230 def PSLLDQri : PDIi8<0x73, MRM7r, (ops VR128:$dst, VR128:$src1, i32i8imm:$src2),
1231                      "pslldq {$src2, $dst|$dst, $src2}", []>;
1232 def PSRLDQri : PDIi8<0x73, MRM7r, (ops VR128:$dst, VR128:$src1, i32i8imm:$src2),
1233                      "psrldq {$src2, $dst|$dst, $src2}", []>;
1234 }
1235
1236 // Logical
1237 let isTwoAddress = 1 in {
1238 let isCommutable = 1 in {
1239 def PANDrr : PDI<0xDB, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1240                  "pand {$src2, $dst|$dst, $src2}",
1241                  [(set VR128:$dst, (v2i64 (and VR128:$src1, VR128:$src2)))]>;
1242
1243 def PANDrm : PDI<0xDB, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1244                  "pand {$src2, $dst|$dst, $src2}",
1245                  [(set VR128:$dst, (v2i64 (and VR128:$src1,
1246                                            (load addr:$src2))))]>;
1247 def PORrr  : PDI<0xEB, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1248                  "por {$src2, $dst|$dst, $src2}",
1249                  [(set VR128:$dst, (v2i64 (or VR128:$src1, VR128:$src2)))]>;
1250
1251 def PORrm  : PDI<0xEB, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1252                  "por {$src2, $dst|$dst, $src2}",
1253                  [(set VR128:$dst, (v2i64 (or VR128:$src1,
1254                                            (load addr:$src2))))]>;
1255 def PXORrr : PDI<0xEF, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1256                  "pxor {$src2, $dst|$dst, $src2}",
1257                  [(set VR128:$dst, (v2i64 (xor VR128:$src1, VR128:$src2)))]>;
1258
1259 def PXORrm : PDI<0xEF, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1260                  "pxor {$src2, $dst|$dst, $src2}",
1261                  [(set VR128:$dst, (v2i64 (xor VR128:$src1,
1262                                            (load addr:$src2))))]>;
1263 }
1264
1265 def PANDNrr : PDI<0xDF, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1266                   "pandn {$src2, $dst|$dst, $src2}",
1267                   [(set VR128:$dst, (v2i64 (and (vnot VR128:$src1),
1268                                             VR128:$src2)))]>;
1269
1270 def PANDNrm : PDI<0xDF, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1271                  "pandn {$src2, $dst|$dst, $src2}",
1272                  [(set VR128:$dst, (v2i64 (and (vnot VR128:$src1),
1273                                            (load addr:$src2))))]>;
1274 }
1275
1276 // Pack instructions
1277 let isTwoAddress = 1 in {
1278 def PACKSSWBrr : PDI<0x63, MRMSrcReg, (ops VR128:$dst, VR128:$src1,
1279                                        VR128:$src2),
1280                  "packsswb {$src2, $dst|$dst, $src2}",
1281                  [(set VR128:$dst, (v8i16 (int_x86_sse2_packsswb_128
1282                                            VR128:$src1,
1283                                            VR128:$src2)))]>;
1284 def PACKSSWBrm : PDI<0x63, MRMSrcMem, (ops VR128:$dst, VR128:$src1,
1285                                        i128mem:$src2),
1286                  "packsswb {$src2, $dst|$dst, $src2}",
1287                  [(set VR128:$dst, (v8i16 (int_x86_sse2_packsswb_128
1288                                            VR128:$src1,
1289                                          (bc_v8i16 (loadv2f64 addr:$src2)))))]>;
1290 def PACKSSDWrr : PDI<0x6B, MRMSrcReg, (ops VR128:$dst, VR128:$src1,
1291                                        VR128:$src2),
1292                  "packssdw {$src2, $dst|$dst, $src2}",
1293                  [(set VR128:$dst, (v4i32 (int_x86_sse2_packssdw_128
1294                                            VR128:$src1,
1295                                            VR128:$src2)))]>;
1296 def PACKSSDWrm : PDI<0x6B, MRMSrcReg, (ops VR128:$dst, VR128:$src1,
1297                                        i128mem:$src2),
1298                  "packssdw {$src2, $dst|$dst, $src2}",
1299                  [(set VR128:$dst, (v4i32 (int_x86_sse2_packssdw_128
1300                                            VR128:$src1,
1301                                          (bc_v4i32 (loadv2i64 addr:$src2)))))]>;
1302 def PACKUSWBrr : PDI<0x67, MRMSrcReg, (ops VR128:$dst, VR128:$src1,
1303                                        VR128:$src2),
1304                      "packuswb {$src2, $dst|$dst, $src2}",
1305                  [(set VR128:$dst, (v8i16 (int_x86_sse2_packuswb_128
1306                                            VR128:$src1,
1307                                            VR128:$src2)))]>;
1308 def PACKUSWBrm : PDI<0x67, MRMSrcReg, (ops VR128:$dst, VR128:$src1,
1309                                        i128mem:$src2),
1310                      "packuswb {$src2, $dst|$dst, $src2}",
1311                  [(set VR128:$dst, (v8i16 (int_x86_sse2_packuswb_128
1312                                            VR128:$src1,
1313                                          (bc_v8i16 (loadv2i64 addr:$src2)))))]>;
1314 }
1315
1316 // Shuffle and unpack instructions
1317 def PSHUFWri : PSIi8<0x70, MRMSrcReg,
1318                      (ops VR64:$dst, VR64:$src1, i8imm:$src2),
1319                      "pshufw {$src2, $src1, $dst|$dst, $src1, $src2}", []>;
1320 def PSHUFWmi : PSIi8<0x70, MRMSrcMem,
1321                      (ops VR64:$dst, i64mem:$src1, i8imm:$src2),
1322                      "pshufw {$src2, $src1, $dst|$dst, $src1, $src2}", []>;
1323
1324 def PSHUFDri : PDIi8<0x70, MRMSrcReg,
1325                      (ops VR128:$dst, VR128:$src1, i8imm:$src2),
1326                      "pshufd {$src2, $src1, $dst|$dst, $src1, $src2}",
1327                      [(set VR128:$dst, (v4i32 (vector_shuffle
1328                                                VR128:$src1, (undef),
1329                                                PSHUFD_shuffle_mask:$src2)))]>;
1330 def PSHUFDmi : PDIi8<0x70, MRMSrcMem,
1331                      (ops VR128:$dst, i128mem:$src1, i8imm:$src2),
1332                      "pshufd {$src2, $src1, $dst|$dst, $src1, $src2}",
1333                      [(set VR128:$dst, (v4i32 (vector_shuffle
1334                                                (load addr:$src1), (undef),
1335                                                PSHUFD_shuffle_mask:$src2)))]>;
1336
1337 // SSE2 with ImmT == Imm8 and XS prefix.
1338 def PSHUFHWri : Ii8<0x70, MRMSrcReg,
1339                     (ops VR128:$dst, VR128:$src1, i8imm:$src2),
1340                     "pshufhw {$src2, $src1, $dst|$dst, $src1, $src2}",
1341                     [(set VR128:$dst, (v8i16 (vector_shuffle
1342                                               VR128:$src1, (undef),
1343                                               PSHUFHW_shuffle_mask:$src2)))]>,
1344                 XS, Requires<[HasSSE2]>;
1345 def PSHUFHWmi : Ii8<0x70, MRMSrcMem,
1346                     (ops VR128:$dst, i128mem:$src1, i8imm:$src2),
1347                     "pshufhw {$src2, $src1, $dst|$dst, $src1, $src2}",
1348                     [(set VR128:$dst, (v8i16 (vector_shuffle
1349                                      (bc_v8i16 (loadv2i64 addr:$src1)), (undef),
1350                                               PSHUFHW_shuffle_mask:$src2)))]>,
1351                 XS, Requires<[HasSSE2]>;
1352
1353 // SSE2 with ImmT == Imm8 and XD prefix.
1354 def PSHUFLWri : Ii8<0x70, MRMSrcReg,
1355                     (ops VR128:$dst, VR128:$src1, i32i8imm:$src2),
1356                     "pshuflw {$src2, $src1, $dst|$dst, $src1, $src2}",
1357                     [(set VR128:$dst, (v8i16 (vector_shuffle
1358                                               VR128:$src1, (undef),
1359                                               PSHUFLW_shuffle_mask:$src2)))]>,
1360                 XD, Requires<[HasSSE2]>;
1361 def PSHUFLWmi : Ii8<0x70, MRMSrcMem,
1362                     (ops VR128:$dst, i128mem:$src1, i32i8imm:$src2),
1363                     "pshuflw {$src2, $src1, $dst|$dst, $src1, $src2}",
1364                     [(set VR128:$dst, (v8i16 (vector_shuffle
1365                                      (bc_v8i16 (loadv2i64 addr:$src1)), (undef),
1366                                               PSHUFLW_shuffle_mask:$src2)))]>,
1367                 XD, Requires<[HasSSE2]>;
1368
1369 let isTwoAddress = 1 in {
1370 def PUNPCKLBWrr : PDI<0x60, MRMSrcReg,
1371                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1372                       "punpcklbw {$src2, $dst|$dst, $src2}",
1373                       [(set VR128:$dst,
1374                         (v16i8 (vector_shuffle VR128:$src1, VR128:$src2,
1375                                 UNPCKL_shuffle_mask)))]>;
1376 def PUNPCKLBWrm : PDI<0x60, MRMSrcMem,
1377                       (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1378                       "punpcklbw {$src2, $dst|$dst, $src2}",
1379                       [(set VR128:$dst,
1380                         (v16i8 (vector_shuffle VR128:$src1, (load addr:$src2),
1381                                 UNPCKL_shuffle_mask)))]>;
1382 def PUNPCKLWDrr : PDI<0x61, MRMSrcReg,
1383                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1384                       "punpcklwd {$src2, $dst|$dst, $src2}",
1385                       [(set VR128:$dst,
1386                         (v8i16 (vector_shuffle VR128:$src1, VR128:$src2,
1387                                 UNPCKL_shuffle_mask)))]>;
1388 def PUNPCKLWDrm : PDI<0x61, MRMSrcMem,
1389                       (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1390                       "punpcklwd {$src2, $dst|$dst, $src2}",
1391                       [(set VR128:$dst,
1392                         (v8i16 (vector_shuffle VR128:$src1, (load addr:$src2),
1393                                 UNPCKL_shuffle_mask)))]>;
1394 def PUNPCKLDQrr : PDI<0x62, MRMSrcReg,
1395                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1396                       "punpckldq {$src2, $dst|$dst, $src2}",
1397                       [(set VR128:$dst,
1398                         (v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
1399                                 UNPCKL_shuffle_mask)))]>;
1400 def PUNPCKLDQrm : PDI<0x62, MRMSrcMem,
1401                       (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1402                       "punpckldq {$src2, $dst|$dst, $src2}",
1403                       [(set VR128:$dst,
1404                         (v4i32 (vector_shuffle VR128:$src1, (load addr:$src2),
1405                                 UNPCKL_shuffle_mask)))]>;
1406 def PUNPCKLQDQrr : PDI<0x6C, MRMSrcReg,
1407                        (ops VR128:$dst, VR128:$src1, VR128:$src2),
1408                        "punpcklqdq {$src2, $dst|$dst, $src2}",
1409                       [(set VR128:$dst,
1410                         (v2i64 (vector_shuffle VR128:$src1, VR128:$src2,
1411                                 UNPCKL_shuffle_mask)))]>;
1412 def PUNPCKLQDQrm : PDI<0x6C, MRMSrcMem,
1413                        (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1414                        "punpcklqdq {$src2, $dst|$dst, $src2}",
1415                       [(set VR128:$dst,
1416                         (v2i64 (vector_shuffle VR128:$src1, (load addr:$src2),
1417                                 UNPCKL_shuffle_mask)))]>;
1418
1419 def PUNPCKHBWrr : PDI<0x68, MRMSrcReg,
1420                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1421                       "punpckhbw {$src2, $dst|$dst, $src2}",
1422                       [(set VR128:$dst,
1423                         (v16i8 (vector_shuffle VR128:$src1, VR128:$src2,
1424                                 UNPCKH_shuffle_mask)))]>;
1425 def PUNPCKHBWrm : PDI<0x68, MRMSrcMem,
1426                       (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1427                       "punpckhbw {$src2, $dst|$dst, $src2}",
1428                       [(set VR128:$dst,
1429                         (v16i8 (vector_shuffle VR128:$src1, (load addr:$src2),
1430                                 UNPCKH_shuffle_mask)))]>;
1431 def PUNPCKHWDrr : PDI<0x69, MRMSrcReg,
1432                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1433                       "punpckhwd {$src2, $dst|$dst, $src2}",
1434                       [(set VR128:$dst,
1435                         (v8i16 (vector_shuffle VR128:$src1, VR128:$src2,
1436                                 UNPCKH_shuffle_mask)))]>;
1437 def PUNPCKHWDrm : PDI<0x69, MRMSrcMem,
1438                       (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1439                       "punpckhwd {$src2, $dst|$dst, $src2}",
1440                       [(set VR128:$dst,
1441                         (v8i16 (vector_shuffle VR128:$src1, (load addr:$src2),
1442                                 UNPCKH_shuffle_mask)))]>;
1443 def PUNPCKHDQrr : PDI<0x6A, MRMSrcReg,
1444                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1445                       "punpckhdq {$src2, $dst|$dst, $src2}",
1446                       [(set VR128:$dst,
1447                         (v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
1448                                 UNPCKH_shuffle_mask)))]>;
1449 def PUNPCKHDQrm : PDI<0x6A, MRMSrcMem,
1450                       (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1451                       "punpckhdq {$src2, $dst|$dst, $src2}",
1452                       [(set VR128:$dst,
1453                         (v4i32 (vector_shuffle VR128:$src1, (load addr:$src2),
1454                                 UNPCKH_shuffle_mask)))]>;
1455 def PUNPCKHQDQrr : PDI<0x6D, MRMSrcReg,
1456                        (ops VR128:$dst, VR128:$src1, VR128:$src2),
1457                        "punpckhdq {$src2, $dst|$dst, $src2}",
1458                       [(set VR128:$dst,
1459                         (v2i64 (vector_shuffle VR128:$src1, VR128:$src2,
1460                                 UNPCKH_shuffle_mask)))]>;
1461 def PUNPCKHQDQrm : PDI<0x6D, MRMSrcMem,
1462                       (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1463                       "punpckhqdq {$src2, $dst|$dst, $src2}",
1464                       [(set VR128:$dst,
1465                         (v2i64 (vector_shuffle VR128:$src1, (load addr:$src2),
1466                                 UNPCKH_shuffle_mask)))]>;
1467 }
1468
1469 // Extract / Insert
1470 def PEXTRWr : PDIi8<0xC5, MRMSrcReg,
1471                     (ops R32:$dst, VR128:$src1, i32i8imm:$src2),
1472                     "pextrw {$src2, $src1, $dst|$dst, $src1, $src2}",
1473                     [(set R32:$dst, (X86pextrw (v8i16 VR128:$src1),
1474                                      (i32 imm:$src2)))]>;
1475 def PEXTRWm : PDIi8<0xC5, MRMSrcMem,
1476                     (ops R32:$dst, i128mem:$src1, i32i8imm:$src2),
1477                     "pextrw {$src2, $src1, $dst|$dst, $src1, $src2}",
1478                     [(set R32:$dst, (X86pextrw (loadv8i16 addr:$src1),
1479                                      (i32 imm:$src2)))]>;
1480
1481 let isTwoAddress = 1 in {
1482 def PINSRWr : PDIi8<0xC4, MRMSrcReg,
1483                      (ops VR128:$dst, VR128:$src1, R32:$src2, i32i8imm:$src3),
1484                      "pinsrw {$src3, $src2, $dst|$dst, $src2, $src3}",
1485                      [(set VR128:$dst, (v8i16 (X86pinsrw (v8i16 VR128:$src1),
1486                                                R32:$src2, (i32 imm:$src3))))]>;
1487 def PINSRWm : PDIi8<0xC4, MRMSrcMem,
1488                      (ops VR128:$dst, VR128:$src1, i16mem:$src2, i32i8imm:$src3),
1489                      "pinsrw {$src3, $src2, $dst|$dst, $src2, $src3}",
1490                      [(set VR128:$dst,
1491                        (v8i16 (X86pinsrw (v8i16 VR128:$src1),
1492                                (i32 (anyext (loadi16 addr:$src2))),
1493                                (i32 imm:$src3))))]>;
1494 }
1495
1496 //===----------------------------------------------------------------------===//
1497 // Miscellaneous Instructions
1498 //===----------------------------------------------------------------------===//
1499
1500 // Mask creation
1501 def MOVMSKPSrr : PSI<0x50, MRMSrcReg, (ops R32:$dst, VR128:$src),
1502                      "movmskps {$src, $dst|$dst, $src}",
1503                      [(set R32:$dst, (int_x86_sse_movmsk_ps VR128:$src))]>;
1504 def MOVMSKPDrr : PSI<0x50, MRMSrcReg, (ops R32:$dst, VR128:$src),
1505                      "movmskpd {$src, $dst|$dst, $src}",
1506                      [(set R32:$dst, (int_x86_sse2_movmskpd VR128:$src))]>;
1507
1508 def PMOVMSKBrr : PDI<0xD7, MRMSrcReg, (ops R32:$dst, VR128:$src),
1509                      "pmovmskb {$src, $dst|$dst, $src}",
1510                      [(set R32:$dst, (int_x86_sse2_pmovmskb_128 VR128:$src))]>;
1511
1512 // Prefetching loads
1513 def PREFETCHT0   : I<0x18, MRM1m, (ops i8mem:$src),
1514                      "prefetcht0 $src", []>, TB,
1515                    Requires<[HasSSE1]>;
1516 def PREFETCHT1   : I<0x18, MRM2m, (ops i8mem:$src),
1517                      "prefetcht0 $src", []>, TB,
1518                    Requires<[HasSSE1]>;
1519 def PREFETCHT2   : I<0x18, MRM3m, (ops i8mem:$src),
1520                      "prefetcht0 $src", []>, TB,
1521                    Requires<[HasSSE1]>;
1522 def PREFETCHTNTA : I<0x18, MRM0m, (ops i8mem:$src),
1523                      "prefetcht0 $src", []>, TB,
1524                    Requires<[HasSSE1]>;
1525
1526 // Non-temporal stores
1527 def MOVNTQ   : I<0xE7, MRMDestMem, (ops i64mem:$dst, VR64:$src),
1528                  "movntq {$src, $dst|$dst, $src}", []>, TB,
1529                Requires<[HasSSE1]>;
1530 def MOVNTPS  : I<0x2B, MRMDestMem, (ops i128mem:$dst, VR128:$src),
1531                 "movntps {$src, $dst|$dst, $src}", []>, TB,
1532                Requires<[HasSSE1]>;
1533 def MASKMOVQ : I<0xF7, MRMDestMem, (ops i64mem:$dst, VR64:$src),
1534                  "maskmovq {$src, $dst|$dst, $src}", []>, TB,
1535                Requires<[HasSSE1]>;
1536
1537 // Store fence
1538 def SFENCE : I<0xAE, MRM7m, (ops),
1539                "sfence", []>, TB, Requires<[HasSSE1]>;
1540
1541 // MXCSR register
1542 def LDMXCSR : I<0xAE, MRM2m, (ops i32mem:$src),
1543                 "ldmxcsr $src",
1544                 [(int_x86_sse_ldmxcsr addr:$src)]>, TB, Requires<[HasSSE1]>;
1545 def STMXCSR : I<0xAE, MRM3m, (ops i32mem:$dst),
1546                 "stmxcsr $dst",
1547                 [(int_x86_sse_stmxcsr addr:$dst)]>, TB, Requires<[HasSSE1]>;
1548
1549 //===----------------------------------------------------------------------===//
1550 // Alias Instructions
1551 //===----------------------------------------------------------------------===//
1552
1553 // Alias instructions that map zero vector to pxor / xorp* for sse.
1554 // FIXME: remove when we can teach regalloc that xor reg, reg is ok.
1555 def V_SET0_PI : PDI<0xEF, MRMInitReg, (ops VR128:$dst),
1556                     "pxor $dst, $dst",
1557                     [(set VR128:$dst, (v2i64 immAllZerosV))]>;
1558 def V_SET0_PS : PSI<0x57, MRMInitReg, (ops VR128:$dst),
1559                     "xorps $dst, $dst",
1560                     [(set VR128:$dst, (v4f32 immAllZerosV))]>;
1561 def V_SET0_PD : PDI<0x57, MRMInitReg, (ops VR128:$dst),
1562                     "xorpd $dst, $dst",
1563                     [(set VR128:$dst, (v2f64 immAllZerosV))]>;
1564
1565 def V_SETALLONES : PDI<0x76, MRMInitReg, (ops VR128:$dst),
1566                        "pcmpeqd $dst, $dst",
1567                        [(set VR128:$dst, (v2f64 immAllOnesV))]>;
1568
1569 // FR32 / FR64 to 128-bit vector conversion.
1570 def MOVSS2PSrr : SSI<0x10, MRMSrcReg, (ops VR128:$dst, FR32:$src),
1571                       "movss {$src, $dst|$dst, $src}",
1572                       [(set VR128:$dst,
1573                         (v4f32 (scalar_to_vector FR32:$src)))]>;
1574 def MOVSS2PSrm : SSI<0x10, MRMSrcMem, (ops VR128:$dst, f32mem:$src),
1575                      "movss {$src, $dst|$dst, $src}",
1576                      [(set VR128:$dst,
1577                        (v4f32 (scalar_to_vector (loadf32 addr:$src))))]>;
1578 def MOVSD2PDrr : SDI<0x10, MRMSrcReg, (ops VR128:$dst, FR64:$src),
1579                       "movsd {$src, $dst|$dst, $src}",
1580                       [(set VR128:$dst,
1581                         (v2f64 (scalar_to_vector FR64:$src)))]>;
1582 def MOVSD2PDrm : SDI<0x10, MRMSrcMem, (ops VR128:$dst, f64mem:$src),
1583                      "movsd {$src, $dst|$dst, $src}",
1584                      [(set VR128:$dst,
1585                        (v2f64 (scalar_to_vector (loadf64 addr:$src))))]>;
1586
1587 def MOVDI2PDIrr : PDI<0x6E, MRMSrcReg, (ops VR128:$dst, R32:$src),
1588                       "movd {$src, $dst|$dst, $src}",
1589                       [(set VR128:$dst,
1590                         (v4i32 (scalar_to_vector R32:$src)))]>;
1591 def MOVDI2PDIrm : PDI<0x6E, MRMSrcMem, (ops VR128:$dst, i32mem:$src),
1592                       "movd {$src, $dst|$dst, $src}",
1593                       [(set VR128:$dst,
1594                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))]>;
1595 // SSE2 instructions with XS prefix
1596 def MOVQI2PQIrr : I<0x7E, MRMSrcReg, (ops VR128:$dst, VR64:$src),
1597                     "movq {$src, $dst|$dst, $src}",
1598                     [(set VR128:$dst,
1599                       (v2i64 (scalar_to_vector VR64:$src)))]>, XS,
1600                   Requires<[HasSSE2]>;
1601 def MOVQI2PQIrm : I<0x7E, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
1602                     "movq {$src, $dst|$dst, $src}",
1603                     [(set VR128:$dst,
1604                       (v2i64 (scalar_to_vector (loadi64 addr:$src))))]>, XS,
1605                   Requires<[HasSSE2]>;
1606 // FIXME: may not be able to eliminate this movss with coalescing the src and
1607 // dest register classes are different. We really want to write this pattern
1608 // like this:
1609 // def : Pat<(f32 (vector_extract (v4f32 VR128:$src), (i32 0))),
1610 //           (f32 FR32:$src)>;
1611 def MOVPS2SSrr : SSI<0x10, MRMSrcReg, (ops FR32:$dst, VR128:$src),
1612                      "movss {$src, $dst|$dst, $src}",
1613                      [(set FR32:$dst, (vector_extract (v4f32 VR128:$src),
1614                                        (i32 0)))]>;
1615 def MOVPS2SSmr : SSI<0x11, MRMDestMem, (ops f32mem:$dst, VR128:$src),
1616                      "movss {$src, $dst|$dst, $src}",
1617                      [(store (f32 (vector_extract (v4f32 VR128:$src),
1618                                    (i32 0))), addr:$dst)]>;
1619 def MOVPD2SDrr : SDI<0x10, MRMSrcReg, (ops FR64:$dst, VR128:$src),
1620                      "movsd {$src, $dst|$dst, $src}",
1621                      [(set FR64:$dst, (vector_extract (v2f64 VR128:$src),
1622                                        (i32 0)))]>;
1623 def MOVPDI2DIrr  : PDI<0x6E, MRMSrcReg, (ops R32:$dst, VR128:$src),
1624                        "movd {$src, $dst|$dst, $src}",
1625                        [(set R32:$dst, (vector_extract (v4i32 VR128:$src),
1626                                         (i32 0)))]>;
1627 def MOVPDI2DImr  : PDI<0x7E, MRMDestMem, (ops i32mem:$dst, VR128:$src),
1628                        "movd {$src, $dst|$dst, $src}",
1629                        [(store (i32 (vector_extract (v4i32 VR128:$src),
1630                                      (i32 0))), addr:$dst)]>;
1631
1632 // Move to lower bits of a VR128, leaving upper bits alone.
1633 // Three operand (but two address) aliases.
1634 let isTwoAddress = 1 in {
1635 def MOVLSS2PSrr : SSI<0x10, MRMSrcReg, (ops VR128:$dst, VR128:$src1, FR32:$src2),
1636                       "movss {$src2, $dst|$dst, $src2}", []>;
1637 def MOVLSD2PDrr : SDI<0x10, MRMSrcReg, (ops VR128:$dst, VR128:$src1, FR64:$src2),
1638                       "movsd {$src2, $dst|$dst, $src2}", []>;
1639 def MOVLDI2PDIrr : PDI<0x6E, MRMSrcReg, (ops VR128:$dst, VR128:$src1, R32:$src2),
1640                       "movd {$src2, $dst|$dst, $src2}", []>;
1641 }
1642
1643 // Move to lower bits of a VR128 and zeroing upper bits.
1644 // Loading from memory automatically zeroing upper bits.
1645 def MOVZSS2PSrm : SSI<0x10, MRMSrcMem, (ops VR128:$dst, f32mem:$src),
1646                       "movss {$src, $dst|$dst, $src}",
1647                       [(set VR128:$dst,
1648                         (v4f32 (X86zexts2vec (loadf32 addr:$src))))]>;
1649 def MOVZSD2PDrm : SDI<0x10, MRMSrcMem, (ops VR128:$dst, f64mem:$src),
1650                       "movsd {$src, $dst|$dst, $src}",
1651                       [(set VR128:$dst,
1652                         (v2f64 (X86zexts2vec (loadf64 addr:$src))))]>;
1653 def MOVZDI2PDIrm : PDI<0x6E, MRMSrcMem, (ops VR128:$dst, i32mem:$src),
1654                        "movd {$src, $dst|$dst, $src}",
1655                        [(set VR128:$dst,
1656                          (v4i32 (X86zexts2vec (loadi32 addr:$src))))]>;
1657 def MOVZQI2PQIrm : PDI<0x7E, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
1658                        "movd {$src, $dst|$dst, $src}",
1659                        [(set VR128:$dst,
1660                          (v2i64 (X86zexts2vec (loadi64 addr:$src))))]>;
1661
1662 //===----------------------------------------------------------------------===//
1663 // Non-Instruction Patterns
1664 //===----------------------------------------------------------------------===//
1665
1666 // 128-bit vector undef's.
1667 def : Pat<(v2f64 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
1668 def : Pat<(v16i8 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
1669 def : Pat<(v8i16 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
1670 def : Pat<(v4i32 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
1671 def : Pat<(v2i64 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
1672
1673 // 128-bit vector all zero's.
1674 def : Pat<(v16i8 immAllZerosV), (v16i8 (V_SET0_PI))>, Requires<[HasSSE2]>;
1675 def : Pat<(v8i16 immAllZerosV), (v8i16 (V_SET0_PI))>, Requires<[HasSSE2]>;
1676 def : Pat<(v4i32 immAllZerosV), (v4i32 (V_SET0_PI))>, Requires<[HasSSE2]>;
1677
1678 // 128-bit vector all one's.
1679 def : Pat<(v16i8 immAllOnesV), (v16i8 (V_SETALLONES))>, Requires<[HasSSE2]>;
1680 def : Pat<(v8i16 immAllOnesV), (v8i16 (V_SETALLONES))>, Requires<[HasSSE2]>;
1681 def : Pat<(v4i32 immAllOnesV), (v4i32 (V_SETALLONES))>, Requires<[HasSSE2]>;
1682 def : Pat<(v2i64 immAllOnesV), (v2i64 (V_SETALLONES))>, Requires<[HasSSE2]>;
1683 def : Pat<(v4f32 immAllOnesV), (v4f32 (V_SETALLONES))>, Requires<[HasSSE1]>;
1684
1685 // Load 128-bit integer vector values.
1686 def : Pat<(v16i8 (load addr:$src)), (MOVDQArm addr:$src)>,
1687       Requires<[HasSSE2]>;
1688 def : Pat<(v8i16 (load addr:$src)), (MOVDQArm addr:$src)>,
1689       Requires<[HasSSE2]>;
1690 def : Pat<(v4i32 (load addr:$src)), (MOVDQArm addr:$src)>,
1691       Requires<[HasSSE2]>;
1692 def : Pat<(v2i64 (load addr:$src)), (MOVDQArm addr:$src)>,
1693       Requires<[HasSSE2]>;
1694
1695 // Store 128-bit integer vector values.
1696 def : Pat<(store (v16i8 VR128:$src), addr:$dst),
1697           (MOVDQAmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
1698 def : Pat<(store (v8i16 VR128:$src), addr:$dst),
1699           (MOVDQAmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
1700 def : Pat<(store (v4i32 VR128:$src), addr:$dst),
1701           (MOVDQAmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
1702 def : Pat<(store (v2i64 VR128:$src), addr:$dst),
1703           (MOVDQAmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
1704
1705 // Scalar to v8i16 / v16i8. The source may be a R32, but only the lower 8 or
1706 // 16-bits matter.
1707 def : Pat<(v8i16 (X86s2vec R32:$src)), (MOVDI2PDIrr R32:$src)>,
1708       Requires<[HasSSE2]>;
1709 def : Pat<(v16i8 (X86s2vec R32:$src)), (MOVDI2PDIrr R32:$src)>,
1710       Requires<[HasSSE2]>;
1711
1712 // bit_convert
1713 def : Pat<(v2i64 (bitconvert (v4i32 VR128:$src))), (v2i64 VR128:$src)>,
1714       Requires<[HasSSE2]>;
1715 def : Pat<(v2i64 (bitconvert (v8i16 VR128:$src))), (v2i64 VR128:$src)>,
1716       Requires<[HasSSE2]>;
1717 def : Pat<(v2i64 (bitconvert (v16i8 VR128:$src))), (v2i64 VR128:$src)>,
1718       Requires<[HasSSE2]>;
1719 def : Pat<(v2i64 (bitconvert (v2f64 VR128:$src))), (v2i64 VR128:$src)>,
1720       Requires<[HasSSE2]>;
1721 def : Pat<(v2i64 (bitconvert (v4f32 VR128:$src))), (v2i64 VR128:$src)>,
1722       Requires<[HasSSE2]>;
1723 def : Pat<(v4i32 (bitconvert (v2i64 VR128:$src))), (v4i32 VR128:$src)>,
1724       Requires<[HasSSE2]>;
1725 def : Pat<(v4i32 (bitconvert (v8i16 VR128:$src))), (v4i32 VR128:$src)>,
1726       Requires<[HasSSE2]>;
1727 def : Pat<(v4i32 (bitconvert (v16i8 VR128:$src))), (v4i32 VR128:$src)>,
1728       Requires<[HasSSE2]>;
1729 def : Pat<(v4i32 (bitconvert (v2f64 VR128:$src))), (v4i32 VR128:$src)>,
1730       Requires<[HasSSE2]>;
1731 def : Pat<(v4i32 (bitconvert (v4f32 VR128:$src))), (v4i32 VR128:$src)>,
1732       Requires<[HasSSE2]>;
1733 def : Pat<(v8i16 (bitconvert (v2i64 VR128:$src))), (v4i32 VR128:$src)>,
1734       Requires<[HasSSE2]>;
1735 def : Pat<(v8i16 (bitconvert (v4i32 VR128:$src))), (v4i32 VR128:$src)>,
1736       Requires<[HasSSE2]>;
1737 def : Pat<(v8i16 (bitconvert (v16i8 VR128:$src))), (v4i32 VR128:$src)>,
1738       Requires<[HasSSE2]>;
1739 def : Pat<(v8i16 (bitconvert (v2f64 VR128:$src))), (v8i16 VR128:$src)>,
1740       Requires<[HasSSE2]>;
1741 def : Pat<(v8i16 (bitconvert (v4f32 VR128:$src))), (v8i16 VR128:$src)>,
1742       Requires<[HasSSE2]>;
1743 def : Pat<(v16i8 (bitconvert (v2i64 VR128:$src))), (v4i32 VR128:$src)>,
1744       Requires<[HasSSE2]>;
1745 def : Pat<(v16i8 (bitconvert (v4i32 VR128:$src))), (v4i32 VR128:$src)>,
1746       Requires<[HasSSE2]>;
1747 def : Pat<(v16i8 (bitconvert (v8i16 VR128:$src))), (v4i32 VR128:$src)>,
1748       Requires<[HasSSE2]>;
1749 def : Pat<(v16i8 (bitconvert (v2f64 VR128:$src))), (v16i8 VR128:$src)>,
1750       Requires<[HasSSE2]>;
1751 def : Pat<(v16i8 (bitconvert (v4f32 VR128:$src))), (v16i8 VR128:$src)>,
1752       Requires<[HasSSE2]>;
1753 def : Pat<(v4f32 (bitconvert (v2i64 VR128:$src))), (v4f32 VR128:$src)>,
1754       Requires<[HasSSE2]>;
1755 def : Pat<(v4f32 (bitconvert (v4i32 VR128:$src))), (v4f32 VR128:$src)>,
1756       Requires<[HasSSE2]>;
1757 def : Pat<(v4f32 (bitconvert (v8i16 VR128:$src))), (v4f32 VR128:$src)>,
1758       Requires<[HasSSE2]>;
1759 def : Pat<(v4f32 (bitconvert (v16i8 VR128:$src))), (v4f32 VR128:$src)>,
1760       Requires<[HasSSE2]>;
1761 def : Pat<(v4f32 (bitconvert (v2f64 VR128:$src))), (v4f32 VR128:$src)>,
1762       Requires<[HasSSE2]>;
1763 def : Pat<(v2f64 (bitconvert (v2i64 VR128:$src))), (v2f64 VR128:$src)>,
1764       Requires<[HasSSE2]>;
1765 def : Pat<(v2f64 (bitconvert (v4i32 VR128:$src))), (v2f64 VR128:$src)>,
1766       Requires<[HasSSE2]>;
1767 def : Pat<(v2f64 (bitconvert (v8i16 VR128:$src))), (v2f64 VR128:$src)>,
1768       Requires<[HasSSE2]>;
1769 def : Pat<(v2f64 (bitconvert (v16i8 VR128:$src))), (v2f64 VR128:$src)>,
1770       Requires<[HasSSE2]>;
1771 def : Pat<(v2f64 (bitconvert (v4f32 VR128:$src))), (v2f64 VR128:$src)>,
1772       Requires<[HasSSE2]>;
1773
1774 // Zeroing a VR128 then do a MOVS* to the lower bits.
1775 def : Pat<(v2f64 (X86zexts2vec FR64:$src)),
1776           (MOVLSD2PDrr (V_SET0_PD), FR64:$src)>, Requires<[HasSSE2]>;
1777 def : Pat<(v4f32 (X86zexts2vec FR32:$src)),
1778           (MOVLSS2PSrr (V_SET0_PS), FR32:$src)>, Requires<[HasSSE2]>;
1779 def : Pat<(v4i32 (X86zexts2vec R32:$src)),
1780           (MOVLDI2PDIrr (V_SET0_PI), R32:$src)>, Requires<[HasSSE2]>;
1781 def : Pat<(v8i16 (X86zexts2vec R16:$src)),
1782        (MOVLDI2PDIrr (V_SET0_PI), (MOVZX32rr16 R16:$src))>, Requires<[HasSSE2]>;
1783 def : Pat<(v16i8 (X86zexts2vec R8:$src)),
1784          (MOVLDI2PDIrr (V_SET0_PI), (MOVZX32rr8 R8:$src))>, Requires<[HasSSE2]>;
1785
1786 // Splat v2f64 / v2i64
1787 def : Pat<(vector_shuffle (v2f64 VR128:$src), (undef), SSE_splat_mask:$sm),
1788           (v2f64 (UNPCKLPDrr VR128:$src, VR128:$src))>,   Requires<[HasSSE2]>;
1789 def : Pat<(vector_shuffle (v2i64 VR128:$src), (undef), SSE_splat_mask:$sm),
1790           (v2i64 (PUNPCKLQDQrr VR128:$src, VR128:$src))>, Requires<[HasSSE2]>;
1791
1792 // Splat v4f32
1793 def : Pat<(vector_shuffle (v4f32 VR128:$src), (undef), SSE_splat_mask:$sm),
1794           (v4f32 (SHUFPSrr VR128:$src, VR128:$src, SSE_splat_mask:$sm))>,
1795       Requires<[HasSSE1]>;
1796
1797 // Shuffle v4i32 with SHUFP* if others do not match.
1798 def : Pat<(vector_shuffle (v4i32 VR128:$src1), (v4i32 VR128:$src2),
1799            SHUFP_int_shuffle_mask:$sm),
1800           (v4i32 (SHUFPSrr VR128:$src1, VR128:$src2,
1801                   SHUFP_int_shuffle_mask:$sm))>, Requires<[HasSSE2]>;
1802 def : Pat<(vector_shuffle (v4i32 VR128:$src1), (load addr:$src2),
1803            SHUFP_int_shuffle_mask:$sm),
1804           (v4i32 (SHUFPSrm VR128:$src1, addr:$src2,
1805                   SHUFP_int_shuffle_mask:$sm))>, Requires<[HasSSE2]>;
1806
1807 // Shuffle v4f32 with PSHUF* if others do not match.
1808 def : Pat<(vector_shuffle (v4f32 VR128:$src1), (undef),
1809            PSHUFD_fp_shuffle_mask:$sm),
1810           (v4f32 (PSHUFDri VR128:$src1, PSHUFD_fp_shuffle_mask:$sm))>,
1811       Requires<[HasSSE2]>;
1812 def : Pat<(vector_shuffle (loadv4f32 addr:$src1), (undef),
1813            PSHUFD_fp_shuffle_mask:$sm),
1814           (v4f32 (PSHUFDmi addr:$src1, PSHUFD_fp_shuffle_mask:$sm))>,
1815       Requires<[HasSSE2]>;
1816 def : Pat<(vector_shuffle (v4f32 VR128:$src1), (undef),
1817            PSHUFHW_fp_shuffle_mask:$sm),
1818           (v4f32 (PSHUFHWri VR128:$src1, PSHUFHW_fp_shuffle_mask:$sm))>,
1819       Requires<[HasSSE2]>;
1820 def : Pat<(vector_shuffle (loadv4f32 addr:$src1), (undef),
1821            PSHUFHW_fp_shuffle_mask:$sm),
1822           (v4f32 (PSHUFHWmi addr:$src1, PSHUFHW_fp_shuffle_mask:$sm))>,
1823       Requires<[HasSSE2]>;
1824 def : Pat<(vector_shuffle (v4f32 VR128:$src1), (undef),
1825            PSHUFLW_fp_shuffle_mask:$sm),
1826           (v4f32 (PSHUFLWri VR128:$src1, PSHUFLW_fp_shuffle_mask:$sm))>,
1827       Requires<[HasSSE2]>;
1828 def : Pat<(vector_shuffle (loadv4f32 addr:$src1), (undef),
1829            PSHUFLW_fp_shuffle_mask:$sm),
1830           (v4f32 (PSHUFLWmi addr:$src1, PSHUFLW_fp_shuffle_mask:$sm))>,
1831       Requires<[HasSSE2]>;
1832
1833 // vector_shuffle v1, <undef>, <0, 0, 1, 1, ...>
1834 def : Pat<(v4f32 (vector_shuffle VR128:$src, (undef),
1835                   UNPCKL_v_undef_shuffle_mask)),
1836           (UNPCKLPSrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
1837 def : Pat<(v16i8 (vector_shuffle VR128:$src, (undef),
1838                   UNPCKL_v_undef_shuffle_mask)),
1839           (PUNPCKLBWrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
1840 def : Pat<(v8i16 (vector_shuffle VR128:$src, (undef),
1841                   UNPCKL_v_undef_shuffle_mask)),
1842           (PUNPCKLWDrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
1843 def : Pat<(v4i32 (vector_shuffle VR128:$src, (undef),
1844                   UNPCKL_v_undef_shuffle_mask)),
1845           (PUNPCKLDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE1]>;
1846
1847 // 128-bit logical shifts
1848 def : Pat<(int_x86_sse2_psll_dq VR128:$src1, imm:$src2),
1849           (v2i64 (PSLLDQri VR128:$src1, (PSxLDQ_imm imm:$src2)))>;
1850 def : Pat<(int_x86_sse2_psrl_dq VR128:$src1, imm:$src2),
1851           (v2i64 (PSRLDQri VR128:$src1, (PSxLDQ_imm imm:$src2)))>;
1852
1853 // Logical ops
1854 def : Pat<(and (bc_v4i32 (v4f32 VR128:$src1)), (loadv4i32 addr:$src2)),
1855           (ANDPSrm VR128:$src1, addr:$src2)>;
1856 def : Pat<(and (bc_v2i64 (v2f64 VR128:$src1)), (loadv2i64 addr:$src2)),
1857           (ANDPDrm VR128:$src1, addr:$src2)>;
1858 def : Pat<(or  (bc_v4i32 (v4f32 VR128:$src1)), (loadv4i32 addr:$src2)),
1859           (ORPSrm VR128:$src1, addr:$src2)>;
1860 def : Pat<(or  (bc_v2i64 (v2f64 VR128:$src1)), (loadv2i64 addr:$src2)),
1861           (ORPDrm VR128:$src1, addr:$src2)>;
1862 def : Pat<(xor (bc_v4i32 (v4f32 VR128:$src1)), (loadv4i32 addr:$src2)),
1863           (XORPSrm VR128:$src1, addr:$src2)>;
1864 def : Pat<(xor (bc_v2i64 (v2f64 VR128:$src1)), (loadv2i64 addr:$src2)),
1865           (XORPDrm VR128:$src1, addr:$src2)>;
1866 def : Pat<(and (vnot (bc_v4i32 (v4f32 VR128:$src1))), (loadv4i32 addr:$src2)),
1867           (ANDNPSrm VR128:$src1, addr:$src2)>;
1868 def : Pat<(and (vnot (bc_v2i64 (v2f64 VR128:$src1))), (loadv2i64 addr:$src2)),
1869           (ANDNPDrm VR128:$src1, addr:$src2)>;
1870
1871 def : Pat<(bc_v4f32 (v4i32 (and VR128:$src1, VR128:$src2))),
1872           (ANDPSrr VR128:$src1, VR128:$src2)>;
1873 def : Pat<(bc_v4f32 (v4i32 (or VR128:$src1, VR128:$src2))),
1874           (ORPSrr VR128:$src1, VR128:$src2)>;
1875 def : Pat<(bc_v4f32 (v4i32 (xor VR128:$src1, VR128:$src2))),
1876           (XORPSrr VR128:$src1, VR128:$src2)>;
1877 def : Pat<(bc_v4f32 (v4i32 (and (vnot VR128:$src1), VR128:$src2))),
1878           (ANDNPSrr VR128:$src1, VR128:$src2)>;
1879
1880 def : Pat<(bc_v4f32 (v4i32 (and VR128:$src1, (load addr:$src2)))),
1881           (ANDPSrm (v4i32 VR128:$src1), addr:$src2)>;
1882 def : Pat<(bc_v4f32 (v4i32 (or VR128:$src1, (load addr:$src2)))),
1883           (ORPSrm VR128:$src1, addr:$src2)>;
1884 def : Pat<(bc_v4f32 (v4i32 (xor VR128:$src1, (load addr:$src2)))),
1885           (XORPSrm VR128:$src1, addr:$src2)>;
1886 def : Pat<(bc_v4f32 (v4i32 (and (vnot VR128:$src1), (load addr:$src2)))),
1887           (ANDNPSrm VR128:$src1, addr:$src2)>;
1888
1889 def : Pat<(bc_v2f64 (v2i64 (and VR128:$src1, VR128:$src2))),
1890           (ANDPDrr VR128:$src1, VR128:$src2)>;
1891 def : Pat<(bc_v2f64 (v2i64 (or VR128:$src1, VR128:$src2))),
1892           (ORPDrr VR128:$src1, VR128:$src2)>;
1893 def : Pat<(bc_v2f64 (v2i64 (xor VR128:$src1, VR128:$src2))),
1894           (XORPDrr VR128:$src1, VR128:$src2)>;
1895 def : Pat<(bc_v2f64 (v2i64 (and (vnot VR128:$src1), VR128:$src2))),
1896           (ANDNPDrr VR128:$src1, VR128:$src2)>;
1897
1898 def : Pat<(bc_v2f64 (v2i64 (and VR128:$src1, (load addr:$src2)))),
1899           (ANDPSrm (v2i64 VR128:$src1), addr:$src2)>;
1900 def : Pat<(bc_v2f64 (v2i64 (or VR128:$src1, (load addr:$src2)))),
1901           (ORPSrm VR128:$src1, addr:$src2)>;
1902 def : Pat<(bc_v2f64 (v2i64 (xor VR128:$src1, (load addr:$src2)))),
1903           (XORPSrm VR128:$src1, addr:$src2)>;
1904 def : Pat<(bc_v2f64 (v2i64 (and (vnot VR128:$src1), (load addr:$src2)))),
1905           (ANDNPSrm VR128:$src1, addr:$src2)>;
1906
1907 def : Pat<(v4i32 (and VR128:$src1, VR128:$src2)),
1908           (PANDrr VR128:$src1, VR128:$src2)>;
1909 def : Pat<(v8i16 (and VR128:$src1, VR128:$src2)),
1910           (PANDrr VR128:$src1, VR128:$src2)>;
1911 def : Pat<(v16i8 (and VR128:$src1, VR128:$src2)),
1912           (PANDrr VR128:$src1, VR128:$src2)>;
1913 def : Pat<(v4i32 (or VR128:$src1, VR128:$src2)),
1914           (PORrr VR128:$src1, VR128:$src2)>;
1915 def : Pat<(v8i16 (or VR128:$src1, VR128:$src2)),
1916           (PORrr VR128:$src1, VR128:$src2)>;
1917 def : Pat<(v16i8 (or VR128:$src1, VR128:$src2)),
1918           (PORrr VR128:$src1, VR128:$src2)>;
1919 def : Pat<(v4i32 (xor VR128:$src1, VR128:$src2)),
1920           (PXORrr VR128:$src1, VR128:$src2)>;
1921 def : Pat<(v8i16 (xor VR128:$src1, VR128:$src2)),
1922           (PXORrr VR128:$src1, VR128:$src2)>;
1923 def : Pat<(v16i8 (xor VR128:$src1, VR128:$src2)),
1924           (PXORrr VR128:$src1, VR128:$src2)>;
1925 def : Pat<(v4i32 (and (vnot VR128:$src1), VR128:$src2)),
1926           (PANDNrr VR128:$src1, VR128:$src2)>;
1927 def : Pat<(v8i16 (and (vnot VR128:$src1), VR128:$src2)),
1928           (PANDNrr VR128:$src1, VR128:$src2)>;
1929 def : Pat<(v16i8 (and (vnot VR128:$src1), VR128:$src2)),
1930           (PANDNrr VR128:$src1, VR128:$src2)>;
1931
1932 def : Pat<(v4i32 (and VR128:$src1, (load addr:$src2))),
1933           (PANDrm VR128:$src1, addr:$src2)>;
1934 def : Pat<(v8i16 (and VR128:$src1, (load addr:$src2))),
1935           (PANDrm VR128:$src1, addr:$src2)>;
1936 def : Pat<(v16i8 (and VR128:$src1, (load addr:$src2))),
1937           (PANDrm VR128:$src1, addr:$src2)>;
1938 def : Pat<(v4i32 (or VR128:$src1, (load addr:$src2))),
1939           (PORrm VR128:$src1, addr:$src2)>;
1940 def : Pat<(v8i16 (or VR128:$src1, (load addr:$src2))),
1941           (PORrm VR128:$src1, addr:$src2)>;
1942 def : Pat<(v16i8 (or VR128:$src1, (load addr:$src2))),
1943           (PORrm VR128:$src1, addr:$src2)>;
1944 def : Pat<(v4i32 (xor VR128:$src1, (load addr:$src2))),
1945           (PXORrm VR128:$src1, addr:$src2)>;
1946 def : Pat<(v8i16 (xor VR128:$src1, (load addr:$src2))),
1947           (PXORrm VR128:$src1, addr:$src2)>;
1948 def : Pat<(v16i8 (xor VR128:$src1, (load addr:$src2))),
1949           (PXORrm VR128:$src1, addr:$src2)>;
1950 def : Pat<(v4i32 (and (vnot VR128:$src1), (load addr:$src2))),
1951           (PANDNrm VR128:$src1, addr:$src2)>;
1952 def : Pat<(v8i16 (and (vnot VR128:$src1), (load addr:$src2))),
1953           (PANDNrm VR128:$src1, addr:$src2)>;
1954 def : Pat<(v16i8 (and (vnot VR128:$src1), (load addr:$src2))),
1955           (PANDNrm VR128:$src1, addr:$src2)>;