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