lib/Target/X86/X86InstrSSE.td

   1 //====- X86InstrSSE.td - Describe the X86 Instruction Set --*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the X86 SSE instruction set, defining the instructions,
  11 // and properties of the instructions which are needed for code generation,
  12 // machine code emission, and analysis.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16
  17 //===----------------------------------------------------------------------===//
  18 // SSE specific DAG Nodes.
  19 //===----------------------------------------------------------------------===//
  20
  21 def SDTX86FPShiftOp : SDTypeProfile<1, 2, [ SDTCisSameAs<0, 1>,
  22                                             SDTCisFP<0>, SDTCisInt<2> ]>;
  23 def SDTX86VFCMP : SDTypeProfile<1, 3, [SDTCisInt<0>, SDTCisSameAs<1, 2>,
  24                                        SDTCisFP<1>, SDTCisVT<3, i8>]>;
  25
  26 def X86fmin    : SDNode<"X86ISD::FMIN",      SDTFPBinOp>;
  27 def X86fmax    : SDNode<"X86ISD::FMAX",      SDTFPBinOp>;
  28 def X86fand    : SDNode<"X86ISD::FAND",      SDTFPBinOp,
  29                         [SDNPCommutative, SDNPAssociative]>;
  30 def X86for     : SDNode<"X86ISD::FOR",       SDTFPBinOp,
  31                         [SDNPCommutative, SDNPAssociative]>;
  32 def X86fxor    : SDNode<"X86ISD::FXOR",      SDTFPBinOp,
  33                         [SDNPCommutative, SDNPAssociative]>;
  34 def X86frsqrt  : SDNode<"X86ISD::FRSQRT",    SDTFPUnaryOp>;
  35 def X86frcp    : SDNode<"X86ISD::FRCP",      SDTFPUnaryOp>;
  36 def X86fsrl    : SDNode<"X86ISD::FSRL",      SDTX86FPShiftOp>;
  37 def X86comi    : SDNode<"X86ISD::COMI",      SDTX86CmpTest>;
  38 def X86ucomi   : SDNode<"X86ISD::UCOMI",     SDTX86CmpTest>;
  39 def X86pshufb  : SDNode<"X86ISD::PSHUFB",
  40                  SDTypeProfile<1, 2, [SDTCisVT<0, v16i8>, SDTCisSameAs<0,1>,
  41                                       SDTCisSameAs<0,2>]>>;
  42 def X86pextrb  : SDNode<"X86ISD::PEXTRB",
  43                  SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisPtrTy<2>]>>;
  44 def X86pextrw  : SDNode<"X86ISD::PEXTRW",
  45                  SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisPtrTy<2>]>>;
  46 def X86pinsrb  : SDNode<"X86ISD::PINSRB",
  47                  SDTypeProfile<1, 3, [SDTCisVT<0, v16i8>, SDTCisSameAs<0,1>,
  48                                       SDTCisVT<2, i32>, SDTCisPtrTy<3>]>>;
  49 def X86pinsrw  : SDNode<"X86ISD::PINSRW",
  50                  SDTypeProfile<1, 3, [SDTCisVT<0, v8i16>, SDTCisSameAs<0,1>,
  51                                       SDTCisVT<2, i32>, SDTCisPtrTy<3>]>>;
  52 def X86insrtps : SDNode<"X86ISD::INSERTPS",
  53                  SDTypeProfile<1, 3, [SDTCisVT<0, v4f32>, SDTCisSameAs<0,1>,
  54                                       SDTCisVT<2, v4f32>, SDTCisPtrTy<3>]>>;
  55 def X86vzmovl  : SDNode<"X86ISD::VZEXT_MOVL",
  56                  SDTypeProfile<1, 1, [SDTCisSameAs<0,1>]>>;
  57 def X86vzload  : SDNode<"X86ISD::VZEXT_LOAD", SDTLoad,
  58                         [SDNPHasChain, SDNPMayLoad]>;
  59 def X86vshl    : SDNode<"X86ISD::VSHL",      SDTIntShiftOp>;
  60 def X86vshr    : SDNode<"X86ISD::VSRL",      SDTIntShiftOp>;
  61 def X86cmpps   : SDNode<"X86ISD::CMPPS",     SDTX86VFCMP>;
  62 def X86cmppd   : SDNode<"X86ISD::CMPPD",     SDTX86VFCMP>;
  63 def X86pcmpeqb : SDNode<"X86ISD::PCMPEQB", SDTIntBinOp, [SDNPCommutative]>;
  64 def X86pcmpeqw : SDNode<"X86ISD::PCMPEQW", SDTIntBinOp, [SDNPCommutative]>;
  65 def X86pcmpeqd : SDNode<"X86ISD::PCMPEQD", SDTIntBinOp, [SDNPCommutative]>;
  66 def X86pcmpeqq : SDNode<"X86ISD::PCMPEQQ", SDTIntBinOp, [SDNPCommutative]>;
  67 def X86pcmpgtb : SDNode<"X86ISD::PCMPGTB", SDTIntBinOp>;
  68 def X86pcmpgtw : SDNode<"X86ISD::PCMPGTW", SDTIntBinOp>;
  69 def X86pcmpgtd : SDNode<"X86ISD::PCMPGTD", SDTIntBinOp>;
  70 def X86pcmpgtq : SDNode<"X86ISD::PCMPGTQ", SDTIntBinOp>;
  71
  72 def SDTX86CmpPTest : SDTypeProfile<0, 2, [SDTCisVT<0, v4f32>,
  73                                           SDTCisVT<1, v4f32>]>;
  74 def X86ptest   : SDNode<"X86ISD::PTEST", SDTX86CmpPTest>;
  75
  76 //===----------------------------------------------------------------------===//
  77 // SSE Complex Patterns
  78 //===----------------------------------------------------------------------===//
  79
  80 // These are 'extloads' from a scalar to the low element of a vector, zeroing
  81 // the top elements.  These are used for the SSE 'ss' and 'sd' instruction
  82 // forms.
  83 def sse_load_f32 : ComplexPattern<v4f32, 5, "SelectScalarSSELoad", [],
  84                                   [SDNPHasChain, SDNPMayLoad]>;
  85 def sse_load_f64 : ComplexPattern<v2f64, 5, "SelectScalarSSELoad", [],
  86                                   [SDNPHasChain, SDNPMayLoad]>;
  87
  88 def ssmem : Operand<v4f32> {
  89   let PrintMethod = "printf32mem";
  90   let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc_nosp, i32imm, i8imm);
  91   let ParserMatchClass = X86MemAsmOperand;
  92 }
  93 def sdmem : Operand<v2f64> {
  94   let PrintMethod = "printf64mem";
  95   let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc_nosp, i32imm, i8imm);
  96   let ParserMatchClass = X86MemAsmOperand;
  97 }
  98
  99 //===----------------------------------------------------------------------===//
 100 // SSE pattern fragments
 101 //===----------------------------------------------------------------------===//
 102
 103 def loadv4f32    : PatFrag<(ops node:$ptr), (v4f32 (load node:$ptr))>;
 104 def loadv2f64    : PatFrag<(ops node:$ptr), (v2f64 (load node:$ptr))>;
 105 def loadv4i32    : PatFrag<(ops node:$ptr), (v4i32 (load node:$ptr))>;
 106 def loadv2i64    : PatFrag<(ops node:$ptr), (v2i64 (load node:$ptr))>;
 107
 108 // Like 'store', but always requires vector alignment.
 109 def alignedstore : PatFrag<(ops node:$val, node:$ptr),
 110                            (store node:$val, node:$ptr), [{
 111   return cast<StoreSDNode>(N)->getAlignment() >= 16;
 112 }]>;
 113
 114 // Like 'load', but always requires vector alignment.
 115 def alignedload : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 116   return cast<LoadSDNode>(N)->getAlignment() >= 16;
 117 }]>;
 118
 119 def alignedloadfsf32 : PatFrag<(ops node:$ptr),
 120                                (f32 (alignedload node:$ptr))>;
 121 def alignedloadfsf64 : PatFrag<(ops node:$ptr),
 122                                (f64 (alignedload node:$ptr))>;
 123 def alignedloadv4f32 : PatFrag<(ops node:$ptr),
 124                                (v4f32 (alignedload node:$ptr))>;
 125 def alignedloadv2f64 : PatFrag<(ops node:$ptr),
 126                                (v2f64 (alignedload node:$ptr))>;
 127 def alignedloadv4i32 : PatFrag<(ops node:$ptr),
 128                                (v4i32 (alignedload node:$ptr))>;
 129 def alignedloadv2i64 : PatFrag<(ops node:$ptr),
 130                                (v2i64 (alignedload node:$ptr))>;
 131
 132 // Like 'load', but uses special alignment checks suitable for use in
 133 // memory operands in most SSE instructions, which are required to
 134 // be naturally aligned on some targets but not on others.  If the subtarget
 135 // allows unaligned accesses, match any load, though this may require
 136 // setting a feature bit in the processor (on startup, for example).
 137 // Opteron 10h and later implement such a feature.
 138 def memop : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 139   return    Subtarget->hasVectorUAMem()
 140          || cast<LoadSDNode>(N)->getAlignment() >= 16;
 141 }]>;
 142
 143 def memopfsf32 : PatFrag<(ops node:$ptr), (f32   (memop node:$ptr))>;
 144 def memopfsf64 : PatFrag<(ops node:$ptr), (f64   (memop node:$ptr))>;
 145 def memopv4f32 : PatFrag<(ops node:$ptr), (v4f32 (memop node:$ptr))>;
 146 def memopv2f64 : PatFrag<(ops node:$ptr), (v2f64 (memop node:$ptr))>;
 147 def memopv4i32 : PatFrag<(ops node:$ptr), (v4i32 (memop node:$ptr))>;
 148 def memopv2i64 : PatFrag<(ops node:$ptr), (v2i64 (memop node:$ptr))>;
 149 def memopv16i8 : PatFrag<(ops node:$ptr), (v16i8 (memop node:$ptr))>;
 150
 151 // SSSE3 uses MMX registers for some instructions. They aren't aligned on a
 152 // 16-byte boundary.
 153 // FIXME: 8 byte alignment for mmx reads is not required
 154 def memop64 : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 155   return cast<LoadSDNode>(N)->getAlignment() >= 8;
 156 }]>;
 157
 158 def memopv8i8  : PatFrag<(ops node:$ptr), (v8i8  (memop64 node:$ptr))>;
 159 def memopv4i16 : PatFrag<(ops node:$ptr), (v4i16 (memop64 node:$ptr))>;
 160 def memopv8i16 : PatFrag<(ops node:$ptr), (v8i16 (memop64 node:$ptr))>;
 161 def memopv2i32 : PatFrag<(ops node:$ptr), (v2i32 (memop64 node:$ptr))>;
 162
 163 def bc_v4f32 : PatFrag<(ops node:$in), (v4f32 (bitconvert node:$in))>;
 164 def bc_v2f64 : PatFrag<(ops node:$in), (v2f64 (bitconvert node:$in))>;
 165 def bc_v16i8 : PatFrag<(ops node:$in), (v16i8 (bitconvert node:$in))>;
 166 def bc_v8i16 : PatFrag<(ops node:$in), (v8i16 (bitconvert node:$in))>;
 167 def bc_v4i32 : PatFrag<(ops node:$in), (v4i32 (bitconvert node:$in))>;
 168 def bc_v2i64 : PatFrag<(ops node:$in), (v2i64 (bitconvert node:$in))>;
 169
 170 def vzmovl_v2i64 : PatFrag<(ops node:$src),
 171                            (bitconvert (v2i64 (X86vzmovl
 172                              (v2i64 (scalar_to_vector (loadi64 node:$src))))))>;
 173 def vzmovl_v4i32 : PatFrag<(ops node:$src),
 174                            (bitconvert (v4i32 (X86vzmovl
 175                              (v4i32 (scalar_to_vector (loadi32 node:$src))))))>;
 176
 177 def vzload_v2i64 : PatFrag<(ops node:$src),
 178                            (bitconvert (v2i64 (X86vzload node:$src)))>;
 179
 180
 181 def fp32imm0 : PatLeaf<(f32 fpimm), [{
 182   return N->isExactlyValue(+0.0);
 183 }]>;
 184
 185 // BYTE_imm - Transform bit immediates into byte immediates.
 186 def BYTE_imm  : SDNodeXForm<imm, [{
 187   // Transformation function: imm >> 3
 188   return getI32Imm(N->getZExtValue() >> 3);
 189 }]>;
 190
 191 // SHUFFLE_get_shuf_imm xform function: convert vector_shuffle mask to PSHUF*,
 192 // SHUFP* etc. imm.
 193 def SHUFFLE_get_shuf_imm : SDNodeXForm<vector_shuffle, [{
 194   return getI8Imm(X86::getShuffleSHUFImmediate(N));
 195 }]>;
 196
 197 // SHUFFLE_get_pshufhw_imm xform function: convert vector_shuffle mask to
 198 // PSHUFHW imm.
 199 def SHUFFLE_get_pshufhw_imm : SDNodeXForm<vector_shuffle, [{
 200   return getI8Imm(X86::getShufflePSHUFHWImmediate(N));
 201 }]>;
 202
 203 // SHUFFLE_get_pshuflw_imm xform function: convert vector_shuffle mask to
 204 // PSHUFLW imm.
 205 def SHUFFLE_get_pshuflw_imm : SDNodeXForm<vector_shuffle, [{
 206   return getI8Imm(X86::getShufflePSHUFLWImmediate(N));
 207 }]>;
 208
 209 // SHUFFLE_get_palign_imm xform function: convert vector_shuffle mask to
 210 // a PALIGNR imm.
 211 def SHUFFLE_get_palign_imm : SDNodeXForm<vector_shuffle, [{
 212   return getI8Imm(X86::getShufflePALIGNRImmediate(N));
 213 }]>;
 214
 215 def splat_lo : PatFrag<(ops node:$lhs, node:$rhs),
 216                        (vector_shuffle node:$lhs, node:$rhs), [{
 217   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
 218   return SVOp->isSplat() && SVOp->getSplatIndex() == 0;
 219 }]>;
 220
 221 def movddup : PatFrag<(ops node:$lhs, node:$rhs),
 222                       (vector_shuffle node:$lhs, node:$rhs), [{
 223   return X86::isMOVDDUPMask(cast<ShuffleVectorSDNode>(N));
 224 }]>;
 225
 226 def movhlps : PatFrag<(ops node:$lhs, node:$rhs),
 227                       (vector_shuffle node:$lhs, node:$rhs), [{
 228   return X86::isMOVHLPSMask(cast<ShuffleVectorSDNode>(N));
 229 }]>;
 230
 231 def movhlps_undef : PatFrag<(ops node:$lhs, node:$rhs),
 232                             (vector_shuffle node:$lhs, node:$rhs), [{
 233   return X86::isMOVHLPS_v_undef_Mask(cast<ShuffleVectorSDNode>(N));
 234 }]>;
 235
 236 def movlhps : PatFrag<(ops node:$lhs, node:$rhs),
 237                       (vector_shuffle node:$lhs, node:$rhs), [{
 238   return X86::isMOVLHPSMask(cast<ShuffleVectorSDNode>(N));
 239 }]>;
 240
 241 def movlp : PatFrag<(ops node:$lhs, node:$rhs),
 242                     (vector_shuffle node:$lhs, node:$rhs), [{
 243   return X86::isMOVLPMask(cast<ShuffleVectorSDNode>(N));
 244 }]>;
 245
 246 def movl : PatFrag<(ops node:$lhs, node:$rhs),
 247                    (vector_shuffle node:$lhs, node:$rhs), [{
 248   return X86::isMOVLMask(cast<ShuffleVectorSDNode>(N));
 249 }]>;
 250
 251 def movshdup : PatFrag<(ops node:$lhs, node:$rhs),
 252                        (vector_shuffle node:$lhs, node:$rhs), [{
 253   return X86::isMOVSHDUPMask(cast<ShuffleVectorSDNode>(N));
 254 }]>;
 255
 256 def movsldup : PatFrag<(ops node:$lhs, node:$rhs),
 257                        (vector_shuffle node:$lhs, node:$rhs), [{
 258   return X86::isMOVSLDUPMask(cast<ShuffleVectorSDNode>(N));
 259 }]>;
 260
 261 def unpckl : PatFrag<(ops node:$lhs, node:$rhs),
 262                      (vector_shuffle node:$lhs, node:$rhs), [{
 263   return X86::isUNPCKLMask(cast<ShuffleVectorSDNode>(N));
 264 }]>;
 265
 266 def unpckh : PatFrag<(ops node:$lhs, node:$rhs),
 267                      (vector_shuffle node:$lhs, node:$rhs), [{
 268   return X86::isUNPCKHMask(cast<ShuffleVectorSDNode>(N));
 269 }]>;
 270
 271 def unpckl_undef : PatFrag<(ops node:$lhs, node:$rhs),
 272                            (vector_shuffle node:$lhs, node:$rhs), [{
 273   return X86::isUNPCKL_v_undef_Mask(cast<ShuffleVectorSDNode>(N));
 274 }]>;
 275
 276 def unpckh_undef : PatFrag<(ops node:$lhs, node:$rhs),
 277                            (vector_shuffle node:$lhs, node:$rhs), [{
 278   return X86::isUNPCKH_v_undef_Mask(cast<ShuffleVectorSDNode>(N));
 279 }]>;
 280
 281 def pshufd : PatFrag<(ops node:$lhs, node:$rhs),
 282                      (vector_shuffle node:$lhs, node:$rhs), [{
 283   return X86::isPSHUFDMask(cast<ShuffleVectorSDNode>(N));
 284 }], SHUFFLE_get_shuf_imm>;
 285
 286 def shufp : PatFrag<(ops node:$lhs, node:$rhs),
 287                     (vector_shuffle node:$lhs, node:$rhs), [{
 288   return X86::isSHUFPMask(cast<ShuffleVectorSDNode>(N));
 289 }], SHUFFLE_get_shuf_imm>;
 290
 291 def pshufhw : PatFrag<(ops node:$lhs, node:$rhs),
 292                       (vector_shuffle node:$lhs, node:$rhs), [{
 293   return X86::isPSHUFHWMask(cast<ShuffleVectorSDNode>(N));
 294 }], SHUFFLE_get_pshufhw_imm>;
 295
 296 def pshuflw : PatFrag<(ops node:$lhs, node:$rhs),
 297                       (vector_shuffle node:$lhs, node:$rhs), [{
 298   return X86::isPSHUFLWMask(cast<ShuffleVectorSDNode>(N));
 299 }], SHUFFLE_get_pshuflw_imm>;
 300
 301 def palign : PatFrag<(ops node:$lhs, node:$rhs),
 302                      (vector_shuffle node:$lhs, node:$rhs), [{
 303   return X86::isPALIGNRMask(cast<ShuffleVectorSDNode>(N));
 304 }], SHUFFLE_get_palign_imm>;
 305
 306 //===----------------------------------------------------------------------===//
 307 // SSE scalar FP Instructions
 308 //===----------------------------------------------------------------------===//
 309
 310 // CMOV* - Used to implement the SSE SELECT DAG operation.  Expanded after
 311 // instruction selection into a branch sequence.
 312 let Uses = [EFLAGS], usesCustomInserter = 1 in {
 313   def CMOV_FR32 : I<0, Pseudo,
 314                     (outs FR32:$dst), (ins FR32:$t, FR32:$f, i8imm:$cond),
 315                     "#CMOV_FR32 PSEUDO!",
 316                     [(set FR32:$dst, (X86cmov FR32:$t, FR32:$f, imm:$cond,
 317                                                   EFLAGS))]>;
 318   def CMOV_FR64 : I<0, Pseudo,
 319                     (outs FR64:$dst), (ins FR64:$t, FR64:$f, i8imm:$cond),
 320                     "#CMOV_FR64 PSEUDO!",
 321                     [(set FR64:$dst, (X86cmov FR64:$t, FR64:$f, imm:$cond,
 322                                                   EFLAGS))]>;
 323   def CMOV_V4F32 : I<0, Pseudo,
 324                     (outs VR128:$dst), (ins VR128:$t, VR128:$f, i8imm:$cond),
 325                     "#CMOV_V4F32 PSEUDO!",
 326                     [(set VR128:$dst,
 327                       (v4f32 (X86cmov VR128:$t, VR128:$f, imm:$cond,
 328                                           EFLAGS)))]>;
 329   def CMOV_V2F64 : I<0, Pseudo,
 330                     (outs VR128:$dst), (ins VR128:$t, VR128:$f, i8imm:$cond),
 331                     "#CMOV_V2F64 PSEUDO!",
 332                     [(set VR128:$dst,
 333                       (v2f64 (X86cmov VR128:$t, VR128:$f, imm:$cond,
 334                                           EFLAGS)))]>;
 335   def CMOV_V2I64 : I<0, Pseudo,
 336                     (outs VR128:$dst), (ins VR128:$t, VR128:$f, i8imm:$cond),
 337                     "#CMOV_V2I64 PSEUDO!",
 338                     [(set VR128:$dst,
 339                       (v2i64 (X86cmov VR128:$t, VR128:$f, imm:$cond,
 340                                           EFLAGS)))]>;
 341 }
 342
 343 //===----------------------------------------------------------------------===//
 344 // SSE1 Instructions
 345 //===----------------------------------------------------------------------===//
 346
 347 // Move Instructions
 348 let neverHasSideEffects = 1 in
 349 def MOVSSrr : SSI<0x10, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src),
 350                   "movss\t{$src, $dst|$dst, $src}", []>;
 351 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
 352 def MOVSSrm : SSI<0x10, MRMSrcMem, (outs FR32:$dst), (ins f32mem:$src),
 353                   "movss\t{$src, $dst|$dst, $src}",
 354                   [(set FR32:$dst, (loadf32 addr:$src))]>;
 355 def MOVSSmr : SSI<0x11, MRMDestMem, (outs), (ins f32mem:$dst, FR32:$src),
 356                   "movss\t{$src, $dst|$dst, $src}",
 357                   [(store FR32:$src, addr:$dst)]>;
 358
 359 // Conversion instructions
 360 def CVTTSS2SIrr : SSI<0x2C, MRMSrcReg, (outs GR32:$dst), (ins FR32:$src),
 361                       "cvttss2si\t{$src, $dst|$dst, $src}",
 362                       [(set GR32:$dst, (fp_to_sint FR32:$src))]>;
 363 def CVTTSS2SIrm : SSI<0x2C, MRMSrcMem, (outs GR32:$dst), (ins f32mem:$src),
 364                       "cvttss2si\t{$src, $dst|$dst, $src}",
 365                       [(set GR32:$dst, (fp_to_sint (loadf32 addr:$src)))]>;
 366 def CVTSI2SSrr  : SSI<0x2A, MRMSrcReg, (outs FR32:$dst), (ins GR32:$src),
 367                       "cvtsi2ss\t{$src, $dst|$dst, $src}",
 368                       [(set FR32:$dst, (sint_to_fp GR32:$src))]>;
 369 def CVTSI2SSrm  : SSI<0x2A, MRMSrcMem, (outs FR32:$dst), (ins i32mem:$src),
 370                       "cvtsi2ss\t{$src, $dst|$dst, $src}",
 371                       [(set FR32:$dst, (sint_to_fp (loadi32 addr:$src)))]>;
 372
 373 // Match intrinsics which expect XMM operand(s).
 374 def CVTSS2SIrr: SSI<0x2D, MRMSrcReg, (outs GR32:$dst), (ins FR32:$src),
 375                     "cvtss2si{l}\t{$src, $dst|$dst, $src}", []>;
 376 def CVTSS2SIrm: SSI<0x2D, MRMSrcMem, (outs GR32:$dst), (ins f32mem:$src),
 377                     "cvtss2si{l}\t{$src, $dst|$dst, $src}", []>;
 378
 379 def Int_CVTSS2SIrr : SSI<0x2D, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
 380                          "cvtss2si\t{$src, $dst|$dst, $src}",
 381                          [(set GR32:$dst, (int_x86_sse_cvtss2si VR128:$src))]>;
 382 def Int_CVTSS2SIrm : SSI<0x2D, MRMSrcMem, (outs GR32:$dst), (ins f32mem:$src),
 383                          "cvtss2si\t{$src, $dst|$dst, $src}",
 384                          [(set GR32:$dst, (int_x86_sse_cvtss2si
 385                                            (load addr:$src)))]>;
 386
 387 // Match intrinisics which expect MM and XMM operand(s).
 388 def Int_CVTPS2PIrr : PSI<0x2D, MRMSrcReg, (outs VR64:$dst), (ins VR128:$src),
 389                          "cvtps2pi\t{$src, $dst|$dst, $src}",
 390                          [(set VR64:$dst, (int_x86_sse_cvtps2pi VR128:$src))]>;
 391 def Int_CVTPS2PIrm : PSI<0x2D, MRMSrcMem, (outs VR64:$dst), (ins f64mem:$src),
 392                          "cvtps2pi\t{$src, $dst|$dst, $src}",
 393                          [(set VR64:$dst, (int_x86_sse_cvtps2pi
 394                                            (load addr:$src)))]>;
 395 def Int_CVTTPS2PIrr: PSI<0x2C, MRMSrcReg, (outs VR64:$dst), (ins VR128:$src),
 396                          "cvttps2pi\t{$src, $dst|$dst, $src}",
 397                          [(set VR64:$dst, (int_x86_sse_cvttps2pi VR128:$src))]>;
 398 def Int_CVTTPS2PIrm: PSI<0x2C, MRMSrcMem, (outs VR64:$dst), (ins f64mem:$src),
 399                          "cvttps2pi\t{$src, $dst|$dst, $src}",
 400                          [(set VR64:$dst, (int_x86_sse_cvttps2pi
 401                                            (load addr:$src)))]>;
 402 let Constraints = "$src1 = $dst" in {
 403   def Int_CVTPI2PSrr : PSI<0x2A, MRMSrcReg,
 404                            (outs VR128:$dst), (ins VR128:$src1, VR64:$src2),
 405                         "cvtpi2ps\t{$src2, $dst|$dst, $src2}",
 406                         [(set VR128:$dst, (int_x86_sse_cvtpi2ps VR128:$src1,
 407                                            VR64:$src2))]>;
 408   def Int_CVTPI2PSrm : PSI<0x2A, MRMSrcMem,
 409                            (outs VR128:$dst), (ins VR128:$src1, i64mem:$src2),
 410                         "cvtpi2ps\t{$src2, $dst|$dst, $src2}",
 411                         [(set VR128:$dst, (int_x86_sse_cvtpi2ps VR128:$src1,
 412                                             (load addr:$src2)))]>;
 413 }
 414
 415 // Aliases for intrinsics
 416 def Int_CVTTSS2SIrr : SSI<0x2C, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
 417                           "cvttss2si\t{$src, $dst|$dst, $src}",
 418                           [(set GR32:$dst,
 419                             (int_x86_sse_cvttss2si VR128:$src))]>;
 420 def Int_CVTTSS2SIrm : SSI<0x2C, MRMSrcMem, (outs GR32:$dst), (ins f32mem:$src),
 421                           "cvttss2si\t{$src, $dst|$dst, $src}",
 422                           [(set GR32:$dst,
 423                             (int_x86_sse_cvttss2si(load addr:$src)))]>;
 424
 425 let Constraints = "$src1 = $dst" in {
 426   def Int_CVTSI2SSrr : SSI<0x2A, MRMSrcReg,
 427                            (outs VR128:$dst), (ins VR128:$src1, GR32:$src2),
 428                            "cvtsi2ss\t{$src2, $dst|$dst, $src2}",
 429                            [(set VR128:$dst, (int_x86_sse_cvtsi2ss VR128:$src1,
 430                                               GR32:$src2))]>;
 431   def Int_CVTSI2SSrm : SSI<0x2A, MRMSrcMem,
 432                            (outs VR128:$dst), (ins VR128:$src1, i32mem:$src2),
 433                            "cvtsi2ss\t{$src2, $dst|$dst, $src2}",
 434                            [(set VR128:$dst, (int_x86_sse_cvtsi2ss VR128:$src1,
 435                                               (loadi32 addr:$src2)))]>;
 436 }
 437
 438 // Comparison instructions
 439 let Constraints = "$src1 = $dst", neverHasSideEffects = 1 in {
 440   def CMPSSrr : SSIi8<0xC2, MRMSrcReg,
 441                     (outs FR32:$dst), (ins FR32:$src1, FR32:$src, SSECC:$cc),
 442                     "cmp${cc}ss\t{$src, $dst|$dst, $src}", []>;
 443 let mayLoad = 1 in
 444   def CMPSSrm : SSIi8<0xC2, MRMSrcMem,
 445                     (outs FR32:$dst), (ins FR32:$src1, f32mem:$src, SSECC:$cc),
 446                     "cmp${cc}ss\t{$src, $dst|$dst, $src}", []>;
 447 }
 448
 449 let Defs = [EFLAGS] in {
 450 def UCOMISSrr: PSI<0x2E, MRMSrcReg, (outs), (ins FR32:$src1, FR32:$src2),
 451                    "ucomiss\t{$src2, $src1|$src1, $src2}",
 452                    [(X86cmp FR32:$src1, FR32:$src2), (implicit EFLAGS)]>;
 453 def UCOMISSrm: PSI<0x2E, MRMSrcMem, (outs), (ins FR32:$src1, f32mem:$src2),
 454                    "ucomiss\t{$src2, $src1|$src1, $src2}",
 455                    [(X86cmp FR32:$src1, (loadf32 addr:$src2)),
 456                     (implicit EFLAGS)]>;
 457
 458 def COMISSrr: PSI<0x2F, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
 459                   "comiss\t{$src2, $src1|$src1, $src2}", []>;
 460 def COMISSrm: PSI<0x2F, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
 461                   "comiss\t{$src2, $src1|$src1, $src2}", []>;
 462
 463 } // Defs = [EFLAGS]
 464
 465 // Aliases to match intrinsics which expect XMM operand(s).
 466 let Constraints = "$src1 = $dst" in {
 467   def Int_CMPSSrr : SSIi8<0xC2, MRMSrcReg,
 468                         (outs VR128:$dst),
 469                         (ins VR128:$src1, VR128:$src, SSECC:$cc),
 470                         "cmp${cc}ss\t{$src, $dst|$dst, $src}",
 471                         [(set VR128:$dst, (int_x86_sse_cmp_ss
 472                                              VR128:$src1,
 473                                              VR128:$src, imm:$cc))]>;
 474   def Int_CMPSSrm : SSIi8<0xC2, MRMSrcMem,
 475                         (outs VR128:$dst),
 476                         (ins VR128:$src1, f32mem:$src, SSECC:$cc),
 477                         "cmp${cc}ss\t{$src, $dst|$dst, $src}",
 478                         [(set VR128:$dst, (int_x86_sse_cmp_ss VR128:$src1,
 479                                            (load addr:$src), imm:$cc))]>;
 480 }
 481
 482 let Defs = [EFLAGS] in {
 483 def Int_UCOMISSrr: PSI<0x2E, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
 484                        "ucomiss\t{$src2, $src1|$src1, $src2}",
 485                        [(X86ucomi (v4f32 VR128:$src1), VR128:$src2),
 486                         (implicit EFLAGS)]>;
 487 def Int_UCOMISSrm: PSI<0x2E, MRMSrcMem, (outs),(ins VR128:$src1, f128mem:$src2),
 488                        "ucomiss\t{$src2, $src1|$src1, $src2}",
 489                        [(X86ucomi (v4f32 VR128:$src1), (load addr:$src2)),
 490                         (implicit EFLAGS)]>;
 491
 492 def Int_COMISSrr: PSI<0x2F, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
 493                       "comiss\t{$src2, $src1|$src1, $src2}",
 494                       [(X86comi (v4f32 VR128:$src1), VR128:$src2),
 495                        (implicit EFLAGS)]>;
 496 def Int_COMISSrm: PSI<0x2F, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
 497                       "comiss\t{$src2, $src1|$src1, $src2}",
 498                       [(X86comi (v4f32 VR128:$src1), (load addr:$src2)),
 499                        (implicit EFLAGS)]>;
 500 } // Defs = [EFLAGS]
 501
 502 // Aliases of packed SSE1 instructions for scalar use. These all have names
 503 // that start with 'Fs'.
 504
 505 // Alias instructions that map fld0 to pxor for sse.
 506 let isReMaterializable = 1, isAsCheapAsAMove = 1, isCodeGenOnly = 1,
 507     canFoldAsLoad = 1 in
 508 def FsFLD0SS : I<0xEF, MRMInitReg, (outs FR32:$dst), (ins),
 509                  "pxor\t$dst, $dst", [(set FR32:$dst, fp32imm0)]>,
 510                Requires<[HasSSE1]>, TB, OpSize;
 511
 512 // Alias instruction to do FR32 reg-to-reg copy using movaps. Upper bits are
 513 // disregarded.
 514 let neverHasSideEffects = 1 in
 515 def FsMOVAPSrr : PSI<0x28, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src),
 516                      "movaps\t{$src, $dst|$dst, $src}", []>;
 517
 518 // Alias instruction to load FR32 from f128mem using movaps. Upper bits are
 519 // disregarded.
 520 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
 521 def FsMOVAPSrm : PSI<0x28, MRMSrcMem, (outs FR32:$dst), (ins f128mem:$src),
 522                      "movaps\t{$src, $dst|$dst, $src}",
 523                      [(set FR32:$dst, (alignedloadfsf32 addr:$src))]>;
 524
 525 // Alias bitwise logical operations using SSE logical ops on packed FP values.
 526 let Constraints = "$src1 = $dst" in {
 527 let isCommutable = 1 in {
 528   def FsANDPSrr : PSI<0x54, MRMSrcReg, (outs FR32:$dst),
 529                                        (ins FR32:$src1, FR32:$src2),
 530                       "andps\t{$src2, $dst|$dst, $src2}",
 531                       [(set FR32:$dst, (X86fand FR32:$src1, FR32:$src2))]>;
 532   def FsORPSrr  : PSI<0x56, MRMSrcReg, (outs FR32:$dst),
 533                                        (ins FR32:$src1, FR32:$src2),
 534                       "orps\t{$src2, $dst|$dst, $src2}",
 535                       [(set FR32:$dst, (X86for FR32:$src1, FR32:$src2))]>;
 536   def FsXORPSrr : PSI<0x57, MRMSrcReg, (outs FR32:$dst),
 537                                        (ins FR32:$src1, FR32:$src2),
 538                       "xorps\t{$src2, $dst|$dst, $src2}",
 539                       [(set FR32:$dst, (X86fxor FR32:$src1, FR32:$src2))]>;
 540 }
 541
 542 def FsANDPSrm : PSI<0x54, MRMSrcMem, (outs FR32:$dst),
 543                                      (ins FR32:$src1, f128mem:$src2),
 544                     "andps\t{$src2, $dst|$dst, $src2}",
 545                     [(set FR32:$dst, (X86fand FR32:$src1,
 546                                       (memopfsf32 addr:$src2)))]>;
 547 def FsORPSrm  : PSI<0x56, MRMSrcMem, (outs FR32:$dst),
 548                                      (ins FR32:$src1, f128mem:$src2),
 549                     "orps\t{$src2, $dst|$dst, $src2}",
 550                     [(set FR32:$dst, (X86for FR32:$src1,
 551                                       (memopfsf32 addr:$src2)))]>;
 552 def FsXORPSrm : PSI<0x57, MRMSrcMem, (outs FR32:$dst),
 553                                      (ins FR32:$src1, f128mem:$src2),
 554                     "xorps\t{$src2, $dst|$dst, $src2}",
 555                     [(set FR32:$dst, (X86fxor FR32:$src1,
 556                                       (memopfsf32 addr:$src2)))]>;
 557
 558 let neverHasSideEffects = 1 in {
 559 def FsANDNPSrr : PSI<0x55, MRMSrcReg,
 560                      (outs FR32:$dst), (ins FR32:$src1, FR32:$src2),
 561                      "andnps\t{$src2, $dst|$dst, $src2}", []>;
 562 let mayLoad = 1 in
 563 def FsANDNPSrm : PSI<0x55, MRMSrcMem,
 564                      (outs FR32:$dst), (ins FR32:$src1, f128mem:$src2),
 565                      "andnps\t{$src2, $dst|$dst, $src2}", []>;
 566 }
 567 }
 568
 569 /// basic_sse1_fp_binop_rm - SSE1 binops come in both scalar and vector forms.
 570 ///
 571 /// In addition, we also have a special variant of the scalar form here to
 572 /// represent the associated intrinsic operation.  This form is unlike the
 573 /// plain scalar form, in that it takes an entire vector (instead of a scalar)
 574 /// and leaves the top elements unmodified (therefore these cannot be commuted).
 575 ///
 576 /// These three forms can each be reg+reg or reg+mem, so there are a total of
 577 /// six "instructions".
 578 ///
 579 let Constraints = "$src1 = $dst" in {
 580 multiclass basic_sse1_fp_binop_rm<bits<8> opc, string OpcodeStr,
 581                                   SDNode OpNode, Intrinsic F32Int,
 582                                   bit Commutable = 0> {
 583   // Scalar operation, reg+reg.
 584   def SSrr : SSI<opc, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src1, FR32:$src2),
 585                  !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 586                  [(set FR32:$dst, (OpNode FR32:$src1, FR32:$src2))]> {
 587     let isCommutable = Commutable;
 588   }
 589
 590   // Scalar operation, reg+mem.
 591   def SSrm : SSI<opc, MRMSrcMem, (outs FR32:$dst),
 592                                  (ins FR32:$src1, f32mem:$src2),
 593                  !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 594                  [(set FR32:$dst, (OpNode FR32:$src1, (load addr:$src2)))]>;
 595
 596   // Vector operation, reg+reg.
 597   def PSrr : PSI<opc, MRMSrcReg, (outs VR128:$dst),
 598                                  (ins VR128:$src1, VR128:$src2),
 599                !strconcat(OpcodeStr, "ps\t{$src2, $dst|$dst, $src2}"),
 600                [(set VR128:$dst, (v4f32 (OpNode VR128:$src1, VR128:$src2)))]> {
 601     let isCommutable = Commutable;
 602   }
 603
 604   // Vector operation, reg+mem.
 605   def PSrm : PSI<opc, MRMSrcMem, (outs VR128:$dst),
 606                                  (ins VR128:$src1, f128mem:$src2),
 607                  !strconcat(OpcodeStr, "ps\t{$src2, $dst|$dst, $src2}"),
 608              [(set VR128:$dst, (OpNode VR128:$src1, (memopv4f32 addr:$src2)))]>;
 609
 610   // Intrinsic operation, reg+reg.
 611   def SSrr_Int : SSI<opc, MRMSrcReg, (outs VR128:$dst),
 612                                      (ins VR128:$src1, VR128:$src2),
 613                      !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 614                      [(set VR128:$dst, (F32Int VR128:$src1, VR128:$src2))]>;
 615
 616   // Intrinsic operation, reg+mem.
 617   def SSrm_Int : SSI<opc, MRMSrcMem, (outs VR128:$dst),
 618                                      (ins VR128:$src1, ssmem:$src2),
 619                      !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 620                      [(set VR128:$dst, (F32Int VR128:$src1,
 621                                                sse_load_f32:$src2))]>;
 622 }
 623 }
 624
 625 // Arithmetic instructions
 626 defm ADD : basic_sse1_fp_binop_rm<0x58, "add", fadd, int_x86_sse_add_ss, 1>;
 627 defm MUL : basic_sse1_fp_binop_rm<0x59, "mul", fmul, int_x86_sse_mul_ss, 1>;
 628 defm SUB : basic_sse1_fp_binop_rm<0x5C, "sub", fsub, int_x86_sse_sub_ss>;
 629 defm DIV : basic_sse1_fp_binop_rm<0x5E, "div", fdiv, int_x86_sse_div_ss>;
 630
 631 /// sse1_fp_binop_rm - Other SSE1 binops
 632 ///
 633 /// This multiclass is like basic_sse1_fp_binop_rm, with the addition of
 634 /// instructions for a full-vector intrinsic form.  Operations that map
 635 /// onto C operators don't use this form since they just use the plain
 636 /// vector form instead of having a separate vector intrinsic form.
 637 ///
 638 /// This provides a total of eight "instructions".
 639 ///
 640 let Constraints = "$src1 = $dst" in {
 641 multiclass sse1_fp_binop_rm<bits<8> opc, string OpcodeStr,
 642                             SDNode OpNode,
 643                             Intrinsic F32Int,
 644                             Intrinsic V4F32Int,
 645                             bit Commutable = 0> {
 646
 647   // Scalar operation, reg+reg.
 648   def SSrr : SSI<opc, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src1, FR32:$src2),
 649                  !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 650                  [(set FR32:$dst, (OpNode FR32:$src1, FR32:$src2))]> {
 651     let isCommutable = Commutable;
 652   }
 653
 654   // Scalar operation, reg+mem.
 655   def SSrm : SSI<opc, MRMSrcMem, (outs FR32:$dst),
 656                                  (ins FR32:$src1, f32mem:$src2),
 657                  !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 658                  [(set FR32:$dst, (OpNode FR32:$src1, (load addr:$src2)))]>;
 659
 660   // Vector operation, reg+reg.
 661   def PSrr : PSI<opc, MRMSrcReg, (outs VR128:$dst),
 662                                  (ins VR128:$src1, VR128:$src2),
 663                !strconcat(OpcodeStr, "ps\t{$src2, $dst|$dst, $src2}"),
 664                [(set VR128:$dst, (v4f32 (OpNode VR128:$src1, VR128:$src2)))]> {
 665     let isCommutable = Commutable;
 666   }
 667
 668   // Vector operation, reg+mem.
 669   def PSrm : PSI<opc, MRMSrcMem, (outs VR128:$dst),
 670                                  (ins VR128:$src1, f128mem:$src2),
 671                  !strconcat(OpcodeStr, "ps\t{$src2, $dst|$dst, $src2}"),
 672              [(set VR128:$dst, (OpNode VR128:$src1, (memopv4f32 addr:$src2)))]>;
 673
 674   // Intrinsic operation, reg+reg.
 675   def SSrr_Int : SSI<opc, MRMSrcReg, (outs VR128:$dst),
 676                                      (ins VR128:$src1, VR128:$src2),
 677                      !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 678                      [(set VR128:$dst, (F32Int VR128:$src1, VR128:$src2))]> {
 679     let isCommutable = Commutable;
 680   }
 681
 682   // Intrinsic operation, reg+mem.
 683   def SSrm_Int : SSI<opc, MRMSrcMem, (outs VR128:$dst),
 684                                      (ins VR128:$src1, ssmem:$src2),
 685                      !strconcat(OpcodeStr, "ss\t{$src2, $dst|$dst, $src2}"),
 686                      [(set VR128:$dst, (F32Int VR128:$src1,
 687                                                sse_load_f32:$src2))]>;
 688
 689   // Vector intrinsic operation, reg+reg.
 690   def PSrr_Int : PSI<opc, MRMSrcReg, (outs VR128:$dst),
 691                                      (ins VR128:$src1, VR128:$src2),
 692                      !strconcat(OpcodeStr, "ps\t{$src2, $dst|$dst, $src2}"),
 693                      [(set VR128:$dst, (V4F32Int VR128:$src1, VR128:$src2))]> {
 694     let isCommutable = Commutable;
 695   }
 696
 697   // Vector intrinsic operation, reg+mem.
 698   def PSrm_Int : PSI<opc, MRMSrcMem, (outs VR128:$dst),
 699                                      (ins VR128:$src1, f128mem:$src2),
 700                      !strconcat(OpcodeStr, "ps\t{$src2, $dst|$dst, $src2}"),
 701            [(set VR128:$dst, (V4F32Int VR128:$src1, (memopv4f32 addr:$src2)))]>;
 702 }
 703 }
 704
 705 defm MAX : sse1_fp_binop_rm<0x5F, "max", X86fmax,
 706                             int_x86_sse_max_ss, int_x86_sse_max_ps>;
 707 defm MIN : sse1_fp_binop_rm<0x5D, "min", X86fmin,
 708                             int_x86_sse_min_ss, int_x86_sse_min_ps>;
 709
 710 //===----------------------------------------------------------------------===//
 711 // SSE packed FP Instructions
 712
 713 // Move Instructions
 714 let neverHasSideEffects = 1 in
 715 def MOVAPSrr : PSI<0x28, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
 716                    "movaps\t{$src, $dst|$dst, $src}", []>;
 717 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
 718 def MOVAPSrm : PSI<0x28, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
 719                    "movaps\t{$src, $dst|$dst, $src}",
 720                    [(set VR128:$dst, (alignedloadv4f32 addr:$src))]>;
 721
 722 def MOVAPSmr : PSI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 723                    "movaps\t{$src, $dst|$dst, $src}",
 724                    [(alignedstore (v4f32 VR128:$src), addr:$dst)]>;
 725
 726 let neverHasSideEffects = 1 in
 727 def MOVUPSrr : PSI<0x10, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
 728                    "movups\t{$src, $dst|$dst, $src}", []>;
 729 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
 730 def MOVUPSrm : PSI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
 731                    "movups\t{$src, $dst|$dst, $src}",
 732                    [(set VR128:$dst, (loadv4f32 addr:$src))]>;
 733 def MOVUPSmr : PSI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 734                    "movups\t{$src, $dst|$dst, $src}",
 735                    [(store (v4f32 VR128:$src), addr:$dst)]>;
 736
 737 // Intrinsic forms of MOVUPS load and store
 738 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
 739 def MOVUPSrm_Int : PSI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
 740                        "movups\t{$src, $dst|$dst, $src}",
 741                        [(set VR128:$dst, (int_x86_sse_loadu_ps addr:$src))]>;
 742 def MOVUPSmr_Int : PSI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
 743                        "movups\t{$src, $dst|$dst, $src}",
 744                        [(int_x86_sse_storeu_ps addr:$dst, VR128:$src)]>;
 745
 746 let Constraints = "$src1 = $dst" in {
 747   let AddedComplexity = 20 in {
 748     def MOVLPSrm : PSI<0x12, MRMSrcMem,
 749                        (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
 750                        "movlps\t{$src2, $dst|$dst, $src2}",
 751        [(set VR128:$dst,
 752          (movlp VR128:$src1,
 753                 (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))))]>;
 754     def MOVHPSrm : PSI<0x16, MRMSrcMem,
 755                        (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
 756                        "movhps\t{$src2, $dst|$dst, $src2}",
 757        [(set VR128:$dst,
 758          (movlhps VR128:$src1,
 759                 (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2))))))]>;
 760   } // AddedComplexity
 761 } // Constraints = "$src1 = $dst"
 762
 763
 764 def MOVLPSmr : PSI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
 765                    "movlps\t{$src, $dst|$dst, $src}",
 766                    [(store (f64 (vector_extract (bc_v2f64 (v4f32 VR128:$src)),
 767                                  (iPTR 0))), addr:$dst)]>;
 768
 769 // v2f64 extract element 1 is always custom lowered to unpack high to low
 770 // and extract element 0 so the non-store version isn't too horrible.
 771 def MOVHPSmr : PSI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
 772                    "movhps\t{$src, $dst|$dst, $src}",
 773                    [(store (f64 (vector_extract
 774                                  (unpckh (bc_v2f64 (v4f32 VR128:$src)),
 775                                          (undef)), (iPTR 0))), addr:$dst)]>;
 776
 777 let Constraints = "$src1 = $dst" in {
 778 let AddedComplexity = 20 in {
 779 def MOVLHPSrr : PSI<0x16, MRMSrcReg, (outs VR128:$dst),
 780                                      (ins VR128:$src1, VR128:$src2),
 781                     "movlhps\t{$src2, $dst|$dst, $src2}",
 782                     [(set VR128:$dst,
 783                       (v4f32 (movlhps VR128:$src1, VR128:$src2)))]>;
 784
 785 def MOVHLPSrr : PSI<0x12, MRMSrcReg, (outs VR128:$dst),
 786                                      (ins VR128:$src1, VR128:$src2),
 787                     "movhlps\t{$src2, $dst|$dst, $src2}",
 788                     [(set VR128:$dst,
 789                       (v4f32 (movhlps VR128:$src1, VR128:$src2)))]>;
 790 } // AddedComplexity
 791 } // Constraints = "$src1 = $dst"
 792
 793 let AddedComplexity = 20 in {
 794 def : Pat<(v4f32 (movddup VR128:$src, (undef))),
 795           (MOVLHPSrr VR128:$src, VR128:$src)>, Requires<[HasSSE1]>;
 796 def : Pat<(v2i64 (movddup VR128:$src, (undef))),
 797           (MOVLHPSrr VR128:$src, VR128:$src)>, Requires<[HasSSE1]>;
 798 }
 799
 800
 801
 802 // Arithmetic
 803
 804 /// sse1_fp_unop_rm - SSE1 unops come in both scalar and vector forms.
 805 ///
 806 /// In addition, we also have a special variant of the scalar form here to
 807 /// represent the associated intrinsic operation.  This form is unlike the
 808 /// plain scalar form, in that it takes an entire vector (instead of a
 809 /// scalar) and leaves the top elements undefined.
 810 ///
 811 /// And, we have a special variant form for a full-vector intrinsic form.
 812 ///
 813 /// These four forms can each have a reg or a mem operand, so there are a
 814 /// total of eight "instructions".
 815 ///
 816 multiclass sse1_fp_unop_rm<bits<8> opc, string OpcodeStr,
 817                            SDNode OpNode,
 818                            Intrinsic F32Int,
 819                            Intrinsic V4F32Int,
 820                            bit Commutable = 0> {
 821   // Scalar operation, reg.
 822   def SSr : SSI<opc, MRMSrcReg, (outs FR32:$dst), (ins FR32:$src),
 823                 !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
 824                 [(set FR32:$dst, (OpNode FR32:$src))]> {
 825     let isCommutable = Commutable;
 826   }
 827
 828   // Scalar operation, mem.
 829   def SSm : I<opc, MRMSrcMem, (outs FR32:$dst), (ins f32mem:$src),
 830                 !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
 831                 [(set FR32:$dst, (OpNode (load addr:$src)))]>, XS,
 832             Requires<[HasSSE1, OptForSize]>;
 833
 834   // Vector operation, reg.
 835   def PSr : PSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
 836               !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
 837               [(set VR128:$dst, (v4f32 (OpNode VR128:$src)))]> {
 838     let isCommutable = Commutable;
 839   }
 840
 841   // Vector operation, mem.
 842   def PSm : PSI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
 843                 !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
 844                 [(set VR128:$dst, (OpNode (memopv4f32 addr:$src)))]>;
 845
 846   // Intrinsic operation, reg.
 847   def SSr_Int : SSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
 848                     !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
 849                     [(set VR128:$dst, (F32Int VR128:$src))]> {
 850     let isCommutable = Commutable;
 851   }
 852
 853   // Intrinsic operation, mem.
 854   def SSm_Int : SSI<opc, MRMSrcMem, (outs VR128:$dst), (ins ssmem:$src),
 855                     !strconcat(OpcodeStr, "ss\t{$src, $dst|$dst, $src}"),
 856                     [(set VR128:$dst, (F32Int sse_load_f32:$src))]>;
 857
 858   // Vector intrinsic operation, reg
 859   def PSr_Int : PSI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
 860                     !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
 861                     [(set VR128:$dst, (V4F32Int VR128:$src))]> {
 862     let isCommutable = Commutable;
 863   }
 864
 865   // Vector intrinsic operation, mem
 866   def PSm_Int : PSI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
 867                     !strconcat(OpcodeStr, "ps\t{$src, $dst|$dst, $src}"),
 868                     [(set VR128:$dst, (V4F32Int (memopv4f32 addr:$src)))]>;
 869 }
 870
 871 // Square root.
 872 defm SQRT  : sse1_fp_unop_rm<0x51, "sqrt",  fsqrt,
 873                              int_x86_sse_sqrt_ss, int_x86_sse_sqrt_ps>;
 874
 875 // Reciprocal approximations. Note that these typically require refinement
 876 // in order to obtain suitable precision.
 877 defm RSQRT : sse1_fp_unop_rm<0x52, "rsqrt", X86frsqrt,
 878                              int_x86_sse_rsqrt_ss, int_x86_sse_rsqrt_ps>;
 879 defm RCP   : sse1_fp_unop_rm<0x53, "rcp",   X86frcp,
 880                              int_x86_sse_rcp_ss, int_x86_sse_rcp_ps>;
 881
 882 // Logical
 883 let Constraints = "$src1 = $dst" in {
 884   let isCommutable = 1 in {
 885     def ANDPSrr : PSI<0x54, MRMSrcReg,
 886                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
 887                       "andps\t{$src2, $dst|$dst, $src2}",
 888                       [(set VR128:$dst, (v2i64
 889                                          (and VR128:$src1, VR128:$src2)))]>;
 890     def ORPSrr  : PSI<0x56, MRMSrcReg,
 891                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
 892                       "orps\t{$src2, $dst|$dst, $src2}",
 893                       [(set VR128:$dst, (v2i64
 894                                          (or VR128:$src1, VR128:$src2)))]>;
 895     def XORPSrr : PSI<0x57, MRMSrcReg,
 896                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
 897                       "xorps\t{$src2, $dst|$dst, $src2}",
 898                       [(set VR128:$dst, (v2i64
 899                                          (xor VR128:$src1, VR128:$src2)))]>;
 900   }
 901
 902   def ANDPSrm : PSI<0x54, MRMSrcMem,
 903                     (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
 904                     "andps\t{$src2, $dst|$dst, $src2}",
 905                     [(set VR128:$dst, (and (bc_v2i64 (v4f32 VR128:$src1)),
 906                                        (memopv2i64 addr:$src2)))]>;
 907   def ORPSrm  : PSI<0x56, MRMSrcMem,
 908                     (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
 909                     "orps\t{$src2, $dst|$dst, $src2}",
 910                     [(set VR128:$dst, (or (bc_v2i64 (v4f32 VR128:$src1)),
 911                                        (memopv2i64 addr:$src2)))]>;
 912   def XORPSrm : PSI<0x57, MRMSrcMem,
 913                     (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
 914                     "xorps\t{$src2, $dst|$dst, $src2}",
 915                     [(set VR128:$dst, (xor (bc_v2i64 (v4f32 VR128:$src1)),
 916                                        (memopv2i64 addr:$src2)))]>;
 917   def ANDNPSrr : PSI<0x55, MRMSrcReg,
 918                      (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
 919                      "andnps\t{$src2, $dst|$dst, $src2}",
 920                      [(set VR128:$dst,
 921                        (v2i64 (and (xor VR128:$src1,
 922                                     (bc_v2i64 (v4i32 immAllOnesV))),
 923                                VR128:$src2)))]>;
 924   def ANDNPSrm : PSI<0x55, MRMSrcMem,
 925                      (outs VR128:$dst), (ins VR128:$src1,f128mem:$src2),
 926                      "andnps\t{$src2, $dst|$dst, $src2}",
 927                      [(set VR128:$dst,
 928                        (v2i64 (and (xor (bc_v2i64 (v4f32 VR128:$src1)),
 929                                     (bc_v2i64 (v4i32 immAllOnesV))),
 930                                (memopv2i64 addr:$src2))))]>;
 931 }
 932
 933 let Constraints = "$src1 = $dst" in {
 934   def CMPPSrri : PSIi8<0xC2, MRMSrcReg,
 935                     (outs VR128:$dst), (ins VR128:$src1, VR128:$src, SSECC:$cc),
 936                     "cmp${cc}ps\t{$src, $dst|$dst, $src}",
 937                     [(set VR128:$dst, (int_x86_sse_cmp_ps VR128:$src1,
 938                                                         VR128:$src, imm:$cc))]>;
 939   def CMPPSrmi : PSIi8<0xC2, MRMSrcMem,
 940                   (outs VR128:$dst), (ins VR128:$src1, f128mem:$src, SSECC:$cc),
 941                   "cmp${cc}ps\t{$src, $dst|$dst, $src}",
 942                   [(set VR128:$dst, (int_x86_sse_cmp_ps VR128:$src1,
 943                                             (memop addr:$src), imm:$cc))]>;
 944 }
 945 def : Pat<(v4i32 (X86cmpps (v4f32 VR128:$src1), VR128:$src2, imm:$cc)),
 946           (CMPPSrri VR128:$src1, VR128:$src2, imm:$cc)>;
 947 def : Pat<(v4i32 (X86cmpps (v4f32 VR128:$src1), (memop addr:$src2), imm:$cc)),
 948           (CMPPSrmi VR128:$src1, addr:$src2, imm:$cc)>;
 949
 950 // Shuffle and unpack instructions
 951 let Constraints = "$src1 = $dst" in {
 952   let isConvertibleToThreeAddress = 1 in // Convert to pshufd
 953     def SHUFPSrri : PSIi8<0xC6, MRMSrcReg,
 954                           (outs VR128:$dst), (ins VR128:$src1,
 955                            VR128:$src2, i8imm:$src3),
 956                           "shufps\t{$src3, $src2, $dst|$dst, $src2, $src3}",
 957                           [(set VR128:$dst,
 958                             (v4f32 (shufp:$src3 VR128:$src1, VR128:$src2)))]>;
 959   def SHUFPSrmi : PSIi8<0xC6, MRMSrcMem,
 960                         (outs VR128:$dst), (ins VR128:$src1,
 961                          f128mem:$src2, i8imm:$src3),
 962                         "shufps\t{$src3, $src2, $dst|$dst, $src2, $src3}",
 963                         [(set VR128:$dst,
 964                           (v4f32 (shufp:$src3
 965                                   VR128:$src1, (memopv4f32 addr:$src2))))]>;
 966
 967   let AddedComplexity = 10 in {
 968     def UNPCKHPSrr : PSI<0x15, MRMSrcReg,
 969                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
 970                          "unpckhps\t{$src2, $dst|$dst, $src2}",
 971                          [(set VR128:$dst,
 972                            (v4f32 (unpckh VR128:$src1, VR128:$src2)))]>;
 973     def UNPCKHPSrm : PSI<0x15, MRMSrcMem,
 974                          (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
 975                          "unpckhps\t{$src2, $dst|$dst, $src2}",
 976                          [(set VR128:$dst,
 977                            (v4f32 (unpckh VR128:$src1,
 978                                           (memopv4f32 addr:$src2))))]>;
 979
 980     def UNPCKLPSrr : PSI<0x14, MRMSrcReg,
 981                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
 982                          "unpcklps\t{$src2, $dst|$dst, $src2}",
 983                          [(set VR128:$dst,
 984                            (v4f32 (unpckl VR128:$src1, VR128:$src2)))]>;
 985     def UNPCKLPSrm : PSI<0x14, MRMSrcMem,
 986                          (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
 987                          "unpcklps\t{$src2, $dst|$dst, $src2}",
 988                          [(set VR128:$dst,
 989                            (unpckl VR128:$src1, (memopv4f32 addr:$src2)))]>;
 990   } // AddedComplexity
 991 } // Constraints = "$src1 = $dst"
 992
 993 // Mask creation
 994 def MOVMSKPSrr : PSI<0x50, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
 995                      "movmskps\t{$src, $dst|$dst, $src}",
 996                      [(set GR32:$dst, (int_x86_sse_movmsk_ps VR128:$src))]>;
 997 def MOVMSKPDrr : PDI<0x50, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
 998                      "movmskpd\t{$src, $dst|$dst, $src}",
 999                      [(set GR32:$dst, (int_x86_sse2_movmsk_pd VR128:$src))]>;
1000
1001 // Prefetch intrinsic.
1002 def PREFETCHT0   : PSI<0x18, MRM1m, (outs), (ins i8mem:$src),
1003     "prefetcht0\t$src", [(prefetch addr:$src, imm, (i32 3))]>;
1004 def PREFETCHT1   : PSI<0x18, MRM2m, (outs), (ins i8mem:$src),
1005     "prefetcht1\t$src", [(prefetch addr:$src, imm, (i32 2))]>;
1006 def PREFETCHT2   : PSI<0x18, MRM3m, (outs), (ins i8mem:$src),
1007     "prefetcht2\t$src", [(prefetch addr:$src, imm, (i32 1))]>;
1008 def PREFETCHNTA  : PSI<0x18, MRM0m, (outs), (ins i8mem:$src),
1009     "prefetchnta\t$src", [(prefetch addr:$src, imm, (i32 0))]>;
1010
1011 // Non-temporal stores
1012 def MOVNTPSmr : PSI<0x2B, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
1013                     "movntps\t{$src, $dst|$dst, $src}",
1014                     [(int_x86_sse_movnt_ps addr:$dst, VR128:$src)]>;
1015
1016 // Load, store, and memory fence
1017 def SFENCE : PSI<0xAE, MRM7r, (outs), (ins), "sfence", [(int_x86_sse_sfence)]>;
1018
1019 // MXCSR register
1020 def LDMXCSR : PSI<0xAE, MRM2m, (outs), (ins i32mem:$src),
1021                   "ldmxcsr\t$src", [(int_x86_sse_ldmxcsr addr:$src)]>;
1022 def STMXCSR : PSI<0xAE, MRM3m, (outs), (ins i32mem:$dst),
1023                   "stmxcsr\t$dst", [(int_x86_sse_stmxcsr addr:$dst)]>;
1024
1025 // Alias instructions that map zero vector to pxor / xorp* for sse.
1026 // We set canFoldAsLoad because this can be converted to a constant-pool
1027 // load of an all-zeros value if folding it would be beneficial.
1028 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
1029     isCodeGenOnly = 1 in
1030 def V_SET0 : PSI<0x57, MRMInitReg, (outs VR128:$dst), (ins),
1031                  "xorps\t$dst, $dst",
1032                  [(set VR128:$dst, (v4i32 immAllZerosV))]>;
1033
1034 let Predicates = [HasSSE1] in {
1035   def : Pat<(v2i64 immAllZerosV), (V_SET0)>;
1036   def : Pat<(v8i16 immAllZerosV), (V_SET0)>;
1037   def : Pat<(v16i8 immAllZerosV), (V_SET0)>;
1038   def : Pat<(v2f64 immAllZerosV), (V_SET0)>;
1039   def : Pat<(v4f32 immAllZerosV), (V_SET0)>;
1040 }
1041
1042 // FR32 to 128-bit vector conversion.
1043 let isAsCheapAsAMove = 1 in
1044 def MOVSS2PSrr : SSI<0x10, MRMSrcReg, (outs VR128:$dst), (ins FR32:$src),
1045                       "movss\t{$src, $dst|$dst, $src}",
1046                       [(set VR128:$dst,
1047                         (v4f32 (scalar_to_vector FR32:$src)))]>;
1048 def MOVSS2PSrm : SSI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f32mem:$src),
1049                      "movss\t{$src, $dst|$dst, $src}",
1050                      [(set VR128:$dst,
1051                        (v4f32 (scalar_to_vector (loadf32 addr:$src))))]>;
1052
1053 // FIXME: may not be able to eliminate this movss with coalescing the src and
1054 // dest register classes are different. We really want to write this pattern
1055 // like this:
1056 // def : Pat<(f32 (vector_extract (v4f32 VR128:$src), (iPTR 0))),
1057 //           (f32 FR32:$src)>;
1058 let isAsCheapAsAMove = 1 in
1059 def MOVPS2SSrr : SSI<0x10, MRMSrcReg, (outs FR32:$dst), (ins VR128:$src),
1060                      "movss\t{$src, $dst|$dst, $src}",
1061                      [(set FR32:$dst, (vector_extract (v4f32 VR128:$src),
1062                                        (iPTR 0)))]>;
1063 def MOVPS2SSmr : SSI<0x11, MRMDestMem, (outs), (ins f32mem:$dst, VR128:$src),
1064                      "movss\t{$src, $dst|$dst, $src}",
1065                      [(store (f32 (vector_extract (v4f32 VR128:$src),
1066                                    (iPTR 0))), addr:$dst)]>;
1067
1068
1069 // Move to lower bits of a VR128, leaving upper bits alone.
1070 // Three operand (but two address) aliases.
1071 let Constraints = "$src1 = $dst" in {
1072 let neverHasSideEffects = 1 in
1073   def MOVLSS2PSrr : SSI<0x10, MRMSrcReg,
1074                         (outs VR128:$dst), (ins VR128:$src1, FR32:$src2),
1075                         "movss\t{$src2, $dst|$dst, $src2}", []>;
1076
1077   let AddedComplexity = 15 in
1078     def MOVLPSrr : SSI<0x10, MRMSrcReg,
1079                        (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1080                        "movss\t{$src2, $dst|$dst, $src2}",
1081                        [(set VR128:$dst,
1082                          (v4f32 (movl VR128:$src1, VR128:$src2)))]>;
1083 }
1084
1085 // Move to lower bits of a VR128 and zeroing upper bits.
1086 // Loading from memory automatically zeroing upper bits.
1087 let AddedComplexity = 20 in
1088 def MOVZSS2PSrm : SSI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f32mem:$src),
1089                       "movss\t{$src, $dst|$dst, $src}",
1090                    [(set VR128:$dst, (v4f32 (X86vzmovl (v4f32 (scalar_to_vector
1091                                                     (loadf32 addr:$src))))))]>;
1092
1093 def : Pat<(v4f32 (X86vzmovl (loadv4f32 addr:$src))),
1094           (MOVZSS2PSrm addr:$src)>;
1095
1096 //===---------------------------------------------------------------------===//
1097 // SSE2 Instructions
1098 //===---------------------------------------------------------------------===//
1099
1100 // Move Instructions
1101 let neverHasSideEffects = 1 in
1102 def MOVSDrr : SDI<0x10, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src),
1103                   "movsd\t{$src, $dst|$dst, $src}", []>;
1104 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
1105 def MOVSDrm : SDI<0x10, MRMSrcMem, (outs FR64:$dst), (ins f64mem:$src),
1106                   "movsd\t{$src, $dst|$dst, $src}",
1107                   [(set FR64:$dst, (loadf64 addr:$src))]>;
1108 def MOVSDmr : SDI<0x11, MRMDestMem, (outs), (ins f64mem:$dst, FR64:$src),
1109                   "movsd\t{$src, $dst|$dst, $src}",
1110                   [(store FR64:$src, addr:$dst)]>;
1111
1112 // Conversion instructions
1113 def CVTTSD2SIrr : SDI<0x2C, MRMSrcReg, (outs GR32:$dst), (ins FR64:$src),
1114                       "cvttsd2si\t{$src, $dst|$dst, $src}",
1115                       [(set GR32:$dst, (fp_to_sint FR64:$src))]>;
1116 def CVTTSD2SIrm : SDI<0x2C, MRMSrcMem, (outs GR32:$dst), (ins f64mem:$src),
1117                       "cvttsd2si\t{$src, $dst|$dst, $src}",
1118                       [(set GR32:$dst, (fp_to_sint (loadf64 addr:$src)))]>;
1119 def CVTSD2SSrr  : SDI<0x5A, MRMSrcReg, (outs FR32:$dst), (ins FR64:$src),
1120                       "cvtsd2ss\t{$src, $dst|$dst, $src}",
1121                       [(set FR32:$dst, (fround FR64:$src))]>;
1122 def CVTSD2SSrm  : I<0x5A, MRMSrcMem, (outs FR32:$dst), (ins f64mem:$src),
1123                       "cvtsd2ss\t{$src, $dst|$dst, $src}",
1124                       [(set FR32:$dst, (fround (loadf64 addr:$src)))]>, XD,
1125                   Requires<[HasSSE2, OptForSize]>;
1126 def CVTSI2SDrr  : SDI<0x2A, MRMSrcReg, (outs FR64:$dst), (ins GR32:$src),
1127                       "cvtsi2sd\t{$src, $dst|$dst, $src}",
1128                       [(set FR64:$dst, (sint_to_fp GR32:$src))]>;
1129 def CVTSI2SDrm  : SDI<0x2A, MRMSrcMem, (outs FR64:$dst), (ins i32mem:$src),
1130                       "cvtsi2sd\t{$src, $dst|$dst, $src}",
1131                       [(set FR64:$dst, (sint_to_fp (loadi32 addr:$src)))]>;
1132
1133 def CVTPD2DQrm  : S3DI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1134                        "cvtpd2dq\t{$src, $dst|$dst, $src}", []>;
1135 def CVTPD2DQrr  : S3DI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1136                        "cvtpd2dq\t{$src, $dst|$dst, $src}", []>;
1137 def CVTDQ2PDrm  : S3SI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1138                        "cvtdq2pd\t{$src, $dst|$dst, $src}", []>;
1139 def CVTDQ2PDrr  : S3SI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1140                        "cvtdq2pd\t{$src, $dst|$dst, $src}", []>;
1141 def CVTPS2DQrr : PDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1142                      "cvtps2dq\t{$src, $dst|$dst, $src}", []>;
1143 def CVTPS2DQrm : PDI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1144                      "cvtps2dq\t{$src, $dst|$dst, $src}", []>;
1145 def CVTDQ2PSrr : PSI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1146                      "cvtdq2ps\t{$src, $dst|$dst, $src}", []>;
1147 def CVTDQ2PSrm : PSI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1148                      "cvtdq2ps\t{$src, $dst|$dst, $src}", []>;
1149 def COMISDrr: PDI<0x2F, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
1150                   "comisd\t{$src2, $src1|$src1, $src2}", []>;
1151 def COMISDrm: PDI<0x2F, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
1152                       "comisd\t{$src2, $src1|$src1, $src2}", []>;
1153
1154 // SSE2 instructions with XS prefix
1155 def CVTSS2SDrr : I<0x5A, MRMSrcReg, (outs FR64:$dst), (ins FR32:$src),
1156                    "cvtss2sd\t{$src, $dst|$dst, $src}",
1157                    [(set FR64:$dst, (fextend FR32:$src))]>, XS,
1158                  Requires<[HasSSE2]>;
1159 def CVTSS2SDrm : I<0x5A, MRMSrcMem, (outs FR64:$dst), (ins f32mem:$src),
1160                    "cvtss2sd\t{$src, $dst|$dst, $src}",
1161                    [(set FR64:$dst, (extloadf32 addr:$src))]>, XS,
1162                  Requires<[HasSSE2, OptForSize]>;
1163
1164 def : Pat<(extloadf32 addr:$src),
1165           (CVTSS2SDrr (MOVSSrm addr:$src))>, Requires<[HasSSE2, OptForSpeed]>;
1166
1167 // Match intrinsics which expect XMM operand(s).
1168 def Int_CVTSD2SIrr : SDI<0x2D, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
1169                          "cvtsd2si\t{$src, $dst|$dst, $src}",
1170                          [(set GR32:$dst, (int_x86_sse2_cvtsd2si VR128:$src))]>;
1171 def Int_CVTSD2SIrm : SDI<0x2D, MRMSrcMem, (outs GR32:$dst), (ins f128mem:$src),
1172                          "cvtsd2si\t{$src, $dst|$dst, $src}",
1173                          [(set GR32:$dst, (int_x86_sse2_cvtsd2si
1174                                            (load addr:$src)))]>;
1175
1176 // Match intrinisics which expect MM and XMM operand(s).
1177 def Int_CVTPD2PIrr : PDI<0x2D, MRMSrcReg, (outs VR64:$dst), (ins VR128:$src),
1178                          "cvtpd2pi\t{$src, $dst|$dst, $src}",
1179                          [(set VR64:$dst, (int_x86_sse_cvtpd2pi VR128:$src))]>;
1180 def Int_CVTPD2PIrm : PDI<0x2D, MRMSrcMem, (outs VR64:$dst), (ins f128mem:$src),
1181                          "cvtpd2pi\t{$src, $dst|$dst, $src}",
1182                          [(set VR64:$dst, (int_x86_sse_cvtpd2pi
1183                                            (memop addr:$src)))]>;
1184 def Int_CVTTPD2PIrr: PDI<0x2C, MRMSrcReg, (outs VR64:$dst), (ins VR128:$src),
1185                          "cvttpd2pi\t{$src, $dst|$dst, $src}",
1186                          [(set VR64:$dst, (int_x86_sse_cvttpd2pi VR128:$src))]>;
1187 def Int_CVTTPD2PIrm: PDI<0x2C, MRMSrcMem, (outs VR64:$dst), (ins f128mem:$src),
1188                          "cvttpd2pi\t{$src, $dst|$dst, $src}",
1189                          [(set VR64:$dst, (int_x86_sse_cvttpd2pi
1190                                            (memop addr:$src)))]>;
1191 def Int_CVTPI2PDrr : PDI<0x2A, MRMSrcReg, (outs VR128:$dst), (ins VR64:$src),
1192                          "cvtpi2pd\t{$src, $dst|$dst, $src}",
1193                          [(set VR128:$dst, (int_x86_sse_cvtpi2pd VR64:$src))]>;
1194 def Int_CVTPI2PDrm : PDI<0x2A, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
1195                          "cvtpi2pd\t{$src, $dst|$dst, $src}",
1196                          [(set VR128:$dst, (int_x86_sse_cvtpi2pd
1197                                             (load addr:$src)))]>;
1198
1199 // Aliases for intrinsics
1200 def Int_CVTTSD2SIrr : SDI<0x2C, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
1201                           "cvttsd2si\t{$src, $dst|$dst, $src}",
1202                           [(set GR32:$dst,
1203                             (int_x86_sse2_cvttsd2si VR128:$src))]>;
1204 def Int_CVTTSD2SIrm : SDI<0x2C, MRMSrcMem, (outs GR32:$dst), (ins f128mem:$src),
1205                           "cvttsd2si\t{$src, $dst|$dst, $src}",
1206                           [(set GR32:$dst, (int_x86_sse2_cvttsd2si
1207                                             (load addr:$src)))]>;
1208
1209 // Comparison instructions
1210 let Constraints = "$src1 = $dst", neverHasSideEffects = 1 in {
1211   def CMPSDrr : SDIi8<0xC2, MRMSrcReg,
1212                     (outs FR64:$dst), (ins FR64:$src1, FR64:$src, SSECC:$cc),
1213                     "cmp${cc}sd\t{$src, $dst|$dst, $src}", []>;
1214 let mayLoad = 1 in
1215   def CMPSDrm : SDIi8<0xC2, MRMSrcMem,
1216                     (outs FR64:$dst), (ins FR64:$src1, f64mem:$src, SSECC:$cc),
1217                     "cmp${cc}sd\t{$src, $dst|$dst, $src}", []>;
1218 }
1219
1220 let Defs = [EFLAGS] in {
1221 def UCOMISDrr: PDI<0x2E, MRMSrcReg, (outs), (ins FR64:$src1, FR64:$src2),
1222                    "ucomisd\t{$src2, $src1|$src1, $src2}",
1223                    [(X86cmp FR64:$src1, FR64:$src2), (implicit EFLAGS)]>;
1224 def UCOMISDrm: PDI<0x2E, MRMSrcMem, (outs), (ins FR64:$src1, f64mem:$src2),
1225                    "ucomisd\t{$src2, $src1|$src1, $src2}",
1226                    [(X86cmp FR64:$src1, (loadf64 addr:$src2)),
1227                     (implicit EFLAGS)]>;
1228 } // Defs = [EFLAGS]
1229
1230 // Aliases to match intrinsics which expect XMM operand(s).
1231 let Constraints = "$src1 = $dst" in {
1232   def Int_CMPSDrr : SDIi8<0xC2, MRMSrcReg,
1233                         (outs VR128:$dst),
1234                         (ins VR128:$src1, VR128:$src, SSECC:$cc),
1235                         "cmp${cc}sd\t{$src, $dst|$dst, $src}",
1236                         [(set VR128:$dst, (int_x86_sse2_cmp_sd VR128:$src1,
1237                                            VR128:$src, imm:$cc))]>;
1238   def Int_CMPSDrm : SDIi8<0xC2, MRMSrcMem,
1239                         (outs VR128:$dst),
1240                         (ins VR128:$src1, f64mem:$src, SSECC:$cc),
1241                         "cmp${cc}sd\t{$src, $dst|$dst, $src}",
1242                         [(set VR128:$dst, (int_x86_sse2_cmp_sd VR128:$src1,
1243                                            (load addr:$src), imm:$cc))]>;
1244 }
1245
1246 let Defs = [EFLAGS] in {
1247 def Int_UCOMISDrr: PDI<0x2E, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
1248                        "ucomisd\t{$src2, $src1|$src1, $src2}",
1249                        [(X86ucomi (v2f64 VR128:$src1), (v2f64 VR128:$src2)),
1250                         (implicit EFLAGS)]>;
1251 def Int_UCOMISDrm: PDI<0x2E, MRMSrcMem, (outs),(ins VR128:$src1, f128mem:$src2),
1252                        "ucomisd\t{$src2, $src1|$src1, $src2}",
1253                        [(X86ucomi (v2f64 VR128:$src1), (load addr:$src2)),
1254                         (implicit EFLAGS)]>;
1255
1256 def Int_COMISDrr: PDI<0x2F, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
1257                       "comisd\t{$src2, $src1|$src1, $src2}",
1258                       [(X86comi (v2f64 VR128:$src1), (v2f64 VR128:$src2)),
1259                        (implicit EFLAGS)]>;
1260 def Int_COMISDrm: PDI<0x2F, MRMSrcMem, (outs), (ins VR128:$src1, f128mem:$src2),
1261                       "comisd\t{$src2, $src1|$src1, $src2}",
1262                       [(X86comi (v2f64 VR128:$src1), (load addr:$src2)),
1263                        (implicit EFLAGS)]>;
1264 } // Defs = [EFLAGS]
1265
1266 // Aliases of packed SSE2 instructions for scalar use. These all have names
1267 // that start with 'Fs'.
1268
1269 // Alias instructions that map fld0 to pxor for sse.
1270 let isReMaterializable = 1, isAsCheapAsAMove = 1, isCodeGenOnly = 1,
1271     canFoldAsLoad = 1 in
1272 def FsFLD0SD : I<0xEF, MRMInitReg, (outs FR64:$dst), (ins),
1273                  "pxor\t$dst, $dst", [(set FR64:$dst, fpimm0)]>,
1274                Requires<[HasSSE2]>, TB, OpSize;
1275
1276 // Alias instruction to do FR64 reg-to-reg copy using movapd. Upper bits are
1277 // disregarded.
1278 let neverHasSideEffects = 1 in
1279 def FsMOVAPDrr : PDI<0x28, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src),
1280                      "movapd\t{$src, $dst|$dst, $src}", []>;
1281
1282 // Alias instruction to load FR64 from f128mem using movapd. Upper bits are
1283 // disregarded.
1284 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
1285 def FsMOVAPDrm : PDI<0x28, MRMSrcMem, (outs FR64:$dst), (ins f128mem:$src),
1286                      "movapd\t{$src, $dst|$dst, $src}",
1287                      [(set FR64:$dst, (alignedloadfsf64 addr:$src))]>;
1288
1289 // Alias bitwise logical operations using SSE logical ops on packed FP values.
1290 let Constraints = "$src1 = $dst" in {
1291 let isCommutable = 1 in {
1292   def FsANDPDrr : PDI<0x54, MRMSrcReg, (outs FR64:$dst),
1293                                        (ins FR64:$src1, FR64:$src2),
1294                       "andpd\t{$src2, $dst|$dst, $src2}",
1295                       [(set FR64:$dst, (X86fand FR64:$src1, FR64:$src2))]>;
1296   def FsORPDrr  : PDI<0x56, MRMSrcReg, (outs FR64:$dst),
1297                                        (ins FR64:$src1, FR64:$src2),
1298                       "orpd\t{$src2, $dst|$dst, $src2}",
1299                       [(set FR64:$dst, (X86for FR64:$src1, FR64:$src2))]>;
1300   def FsXORPDrr : PDI<0x57, MRMSrcReg, (outs FR64:$dst),
1301                                        (ins FR64:$src1, FR64:$src2),
1302                       "xorpd\t{$src2, $dst|$dst, $src2}",
1303                       [(set FR64:$dst, (X86fxor FR64:$src1, FR64:$src2))]>;
1304 }
1305
1306 def FsANDPDrm : PDI<0x54, MRMSrcMem, (outs FR64:$dst),
1307                                      (ins FR64:$src1, f128mem:$src2),
1308                     "andpd\t{$src2, $dst|$dst, $src2}",
1309                     [(set FR64:$dst, (X86fand FR64:$src1,
1310                                       (memopfsf64 addr:$src2)))]>;
1311 def FsORPDrm  : PDI<0x56, MRMSrcMem, (outs FR64:$dst),
1312                                      (ins FR64:$src1, f128mem:$src2),
1313                     "orpd\t{$src2, $dst|$dst, $src2}",
1314                     [(set FR64:$dst, (X86for FR64:$src1,
1315                                       (memopfsf64 addr:$src2)))]>;
1316 def FsXORPDrm : PDI<0x57, MRMSrcMem, (outs FR64:$dst),
1317                                      (ins FR64:$src1, f128mem:$src2),
1318                     "xorpd\t{$src2, $dst|$dst, $src2}",
1319                     [(set FR64:$dst, (X86fxor FR64:$src1,
1320                                       (memopfsf64 addr:$src2)))]>;
1321
1322 let neverHasSideEffects = 1 in {
1323 def FsANDNPDrr : PDI<0x55, MRMSrcReg,
1324                      (outs FR64:$dst), (ins FR64:$src1, FR64:$src2),
1325                      "andnpd\t{$src2, $dst|$dst, $src2}", []>;
1326 let mayLoad = 1 in
1327 def FsANDNPDrm : PDI<0x55, MRMSrcMem,
1328                      (outs FR64:$dst), (ins FR64:$src1, f128mem:$src2),
1329                      "andnpd\t{$src2, $dst|$dst, $src2}", []>;
1330 }
1331 }
1332
1333 /// basic_sse2_fp_binop_rm - SSE2 binops come in both scalar and vector forms.
1334 ///
1335 /// In addition, we also have a special variant of the scalar form here to
1336 /// represent the associated intrinsic operation.  This form is unlike the
1337 /// plain scalar form, in that it takes an entire vector (instead of a scalar)
1338 /// and leaves the top elements unmodified (therefore these cannot be commuted).
1339 ///
1340 /// These three forms can each be reg+reg or reg+mem, so there are a total of
1341 /// six "instructions".
1342 ///
1343 let Constraints = "$src1 = $dst" in {
1344 multiclass basic_sse2_fp_binop_rm<bits<8> opc, string OpcodeStr,
1345                                   SDNode OpNode, Intrinsic F64Int,
1346                                   bit Commutable = 0> {
1347   // Scalar operation, reg+reg.
1348   def SDrr : SDI<opc, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src1, FR64:$src2),
1349                  !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1350                  [(set FR64:$dst, (OpNode FR64:$src1, FR64:$src2))]> {
1351     let isCommutable = Commutable;
1352   }
1353
1354   // Scalar operation, reg+mem.
1355   def SDrm : SDI<opc, MRMSrcMem, (outs FR64:$dst),
1356                                  (ins FR64:$src1, f64mem:$src2),
1357                  !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1358                  [(set FR64:$dst, (OpNode FR64:$src1, (load addr:$src2)))]>;
1359
1360   // Vector operation, reg+reg.
1361   def PDrr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
1362                                  (ins VR128:$src1, VR128:$src2),
1363                !strconcat(OpcodeStr, "pd\t{$src2, $dst|$dst, $src2}"),
1364                [(set VR128:$dst, (v2f64 (OpNode VR128:$src1, VR128:$src2)))]> {
1365     let isCommutable = Commutable;
1366   }
1367
1368   // Vector operation, reg+mem.
1369   def PDrm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
1370                                  (ins VR128:$src1, f128mem:$src2),
1371                  !strconcat(OpcodeStr, "pd\t{$src2, $dst|$dst, $src2}"),
1372              [(set VR128:$dst, (OpNode VR128:$src1, (memopv2f64 addr:$src2)))]>;
1373
1374   // Intrinsic operation, reg+reg.
1375   def SDrr_Int : SDI<opc, MRMSrcReg, (outs VR128:$dst),
1376                                      (ins VR128:$src1, VR128:$src2),
1377                      !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1378                      [(set VR128:$dst, (F64Int VR128:$src1, VR128:$src2))]>;
1379
1380   // Intrinsic operation, reg+mem.
1381   def SDrm_Int : SDI<opc, MRMSrcMem, (outs VR128:$dst),
1382                                      (ins VR128:$src1, sdmem:$src2),
1383                      !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1384                      [(set VR128:$dst, (F64Int VR128:$src1,
1385                                                sse_load_f64:$src2))]>;
1386 }
1387 }
1388
1389 // Arithmetic instructions
1390 defm ADD : basic_sse2_fp_binop_rm<0x58, "add", fadd, int_x86_sse2_add_sd, 1>;
1391 defm MUL : basic_sse2_fp_binop_rm<0x59, "mul", fmul, int_x86_sse2_mul_sd, 1>;
1392 defm SUB : basic_sse2_fp_binop_rm<0x5C, "sub", fsub, int_x86_sse2_sub_sd>;
1393 defm DIV : basic_sse2_fp_binop_rm<0x5E, "div", fdiv, int_x86_sse2_div_sd>;
1394
1395 /// sse2_fp_binop_rm - Other SSE2 binops
1396 ///
1397 /// This multiclass is like basic_sse2_fp_binop_rm, with the addition of
1398 /// instructions for a full-vector intrinsic form.  Operations that map
1399 /// onto C operators don't use this form since they just use the plain
1400 /// vector form instead of having a separate vector intrinsic form.
1401 ///
1402 /// This provides a total of eight "instructions".
1403 ///
1404 let Constraints = "$src1 = $dst" in {
1405 multiclass sse2_fp_binop_rm<bits<8> opc, string OpcodeStr,
1406                             SDNode OpNode,
1407                             Intrinsic F64Int,
1408                             Intrinsic V2F64Int,
1409                             bit Commutable = 0> {
1410
1411   // Scalar operation, reg+reg.
1412   def SDrr : SDI<opc, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src1, FR64:$src2),
1413                  !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1414                  [(set FR64:$dst, (OpNode FR64:$src1, FR64:$src2))]> {
1415     let isCommutable = Commutable;
1416   }
1417
1418   // Scalar operation, reg+mem.
1419   def SDrm : SDI<opc, MRMSrcMem, (outs FR64:$dst),
1420                                  (ins FR64:$src1, f64mem:$src2),
1421                  !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1422                  [(set FR64:$dst, (OpNode FR64:$src1, (load addr:$src2)))]>;
1423
1424   // Vector operation, reg+reg.
1425   def PDrr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
1426                                  (ins VR128:$src1, VR128:$src2),
1427                !strconcat(OpcodeStr, "pd\t{$src2, $dst|$dst, $src2}"),
1428                [(set VR128:$dst, (v2f64 (OpNode VR128:$src1, VR128:$src2)))]> {
1429     let isCommutable = Commutable;
1430   }
1431
1432   // Vector operation, reg+mem.
1433   def PDrm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
1434                                  (ins VR128:$src1, f128mem:$src2),
1435                  !strconcat(OpcodeStr, "pd\t{$src2, $dst|$dst, $src2}"),
1436              [(set VR128:$dst, (OpNode VR128:$src1, (memopv2f64 addr:$src2)))]>;
1437
1438   // Intrinsic operation, reg+reg.
1439   def SDrr_Int : SDI<opc, MRMSrcReg, (outs VR128:$dst),
1440                                      (ins VR128:$src1, VR128:$src2),
1441                      !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1442                      [(set VR128:$dst, (F64Int VR128:$src1, VR128:$src2))]> {
1443     let isCommutable = Commutable;
1444   }
1445
1446   // Intrinsic operation, reg+mem.
1447   def SDrm_Int : SDI<opc, MRMSrcMem, (outs VR128:$dst),
1448                                      (ins VR128:$src1, sdmem:$src2),
1449                      !strconcat(OpcodeStr, "sd\t{$src2, $dst|$dst, $src2}"),
1450                      [(set VR128:$dst, (F64Int VR128:$src1,
1451                                                sse_load_f64:$src2))]>;
1452
1453   // Vector intrinsic operation, reg+reg.
1454   def PDrr_Int : PDI<opc, MRMSrcReg, (outs VR128:$dst),
1455                                      (ins VR128:$src1, VR128:$src2),
1456                      !strconcat(OpcodeStr, "pd\t{$src2, $dst|$dst, $src2}"),
1457                      [(set VR128:$dst, (V2F64Int VR128:$src1, VR128:$src2))]> {
1458     let isCommutable = Commutable;
1459   }
1460
1461   // Vector intrinsic operation, reg+mem.
1462   def PDrm_Int : PDI<opc, MRMSrcMem, (outs VR128:$dst),
1463                                      (ins VR128:$src1, f128mem:$src2),
1464                      !strconcat(OpcodeStr, "pd\t{$src2, $dst|$dst, $src2}"),
1465                      [(set VR128:$dst, (V2F64Int VR128:$src1,
1466                                                  (memopv2f64 addr:$src2)))]>;
1467 }
1468 }
1469
1470 defm MAX : sse2_fp_binop_rm<0x5F, "max", X86fmax,
1471                             int_x86_sse2_max_sd, int_x86_sse2_max_pd>;
1472 defm MIN : sse2_fp_binop_rm<0x5D, "min", X86fmin,
1473                             int_x86_sse2_min_sd, int_x86_sse2_min_pd>;
1474
1475 //===---------------------------------------------------------------------===//
1476 // SSE packed FP Instructions
1477
1478 // Move Instructions
1479 let neverHasSideEffects = 1 in
1480 def MOVAPDrr : PDI<0x28, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1481                    "movapd\t{$src, $dst|$dst, $src}", []>;
1482 let canFoldAsLoad = 1, isReMaterializable = 1, mayHaveSideEffects = 1 in
1483 def MOVAPDrm : PDI<0x28, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1484                    "movapd\t{$src, $dst|$dst, $src}",
1485                    [(set VR128:$dst, (alignedloadv2f64 addr:$src))]>;
1486
1487 def MOVAPDmr : PDI<0x29, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
1488                    "movapd\t{$src, $dst|$dst, $src}",
1489                    [(alignedstore (v2f64 VR128:$src), addr:$dst)]>;
1490
1491 let neverHasSideEffects = 1 in
1492 def MOVUPDrr : PDI<0x10, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1493                    "movupd\t{$src, $dst|$dst, $src}", []>;
1494 let canFoldAsLoad = 1 in
1495 def MOVUPDrm : PDI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1496                    "movupd\t{$src, $dst|$dst, $src}",
1497                    [(set VR128:$dst, (loadv2f64 addr:$src))]>;
1498 def MOVUPDmr : PDI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
1499                    "movupd\t{$src, $dst|$dst, $src}",
1500                    [(store (v2f64 VR128:$src), addr:$dst)]>;
1501
1502 // Intrinsic forms of MOVUPD load and store
1503 def MOVUPDrm_Int : PDI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1504                        "movupd\t{$src, $dst|$dst, $src}",
1505                        [(set VR128:$dst, (int_x86_sse2_loadu_pd addr:$src))]>;
1506 def MOVUPDmr_Int : PDI<0x11, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
1507                        "movupd\t{$src, $dst|$dst, $src}",
1508                        [(int_x86_sse2_storeu_pd addr:$dst, VR128:$src)]>;
1509
1510 let Constraints = "$src1 = $dst" in {
1511   let AddedComplexity = 20 in {
1512     def MOVLPDrm : PDI<0x12, MRMSrcMem,
1513                        (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
1514                        "movlpd\t{$src2, $dst|$dst, $src2}",
1515                        [(set VR128:$dst,
1516                          (v2f64 (movlp VR128:$src1,
1517                                  (scalar_to_vector (loadf64 addr:$src2)))))]>;
1518     def MOVHPDrm : PDI<0x16, MRMSrcMem,
1519                        (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
1520                        "movhpd\t{$src2, $dst|$dst, $src2}",
1521                        [(set VR128:$dst,
1522                          (v2f64 (movlhps VR128:$src1,
1523                                  (scalar_to_vector (loadf64 addr:$src2)))))]>;
1524   } // AddedComplexity
1525 } // Constraints = "$src1 = $dst"
1526
1527 def MOVLPDmr : PDI<0x13, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1528                    "movlpd\t{$src, $dst|$dst, $src}",
1529                    [(store (f64 (vector_extract (v2f64 VR128:$src),
1530                                  (iPTR 0))), addr:$dst)]>;
1531
1532 // v2f64 extract element 1 is always custom lowered to unpack high to low
1533 // and extract element 0 so the non-store version isn't too horrible.
1534 def MOVHPDmr : PDI<0x17, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
1535                    "movhpd\t{$src, $dst|$dst, $src}",
1536                    [(store (f64 (vector_extract
1537                                  (v2f64 (unpckh VR128:$src, (undef))),
1538                                  (iPTR 0))), addr:$dst)]>;
1539
1540 // SSE2 instructions without OpSize prefix
1541 def Int_CVTDQ2PSrr : I<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1542                        "cvtdq2ps\t{$src, $dst|$dst, $src}",
1543                        [(set VR128:$dst, (int_x86_sse2_cvtdq2ps VR128:$src))]>,
1544                      TB, Requires<[HasSSE2]>;
1545 def Int_CVTDQ2PSrm : I<0x5B, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
1546                       "cvtdq2ps\t{$src, $dst|$dst, $src}",
1547                       [(set VR128:$dst, (int_x86_sse2_cvtdq2ps
1548                                         (bitconvert (memopv2i64 addr:$src))))]>,
1549                      TB, Requires<[HasSSE2]>;
1550
1551 // SSE2 instructions with XS prefix
1552 def Int_CVTDQ2PDrr : I<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1553                        "cvtdq2pd\t{$src, $dst|$dst, $src}",
1554                        [(set VR128:$dst, (int_x86_sse2_cvtdq2pd VR128:$src))]>,
1555                      XS, Requires<[HasSSE2]>;
1556 def Int_CVTDQ2PDrm : I<0xE6, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
1557                      "cvtdq2pd\t{$src, $dst|$dst, $src}",
1558                      [(set VR128:$dst, (int_x86_sse2_cvtdq2pd
1559                                         (bitconvert (memopv2i64 addr:$src))))]>,
1560                      XS, Requires<[HasSSE2]>;
1561
1562 def Int_CVTPS2DQrr : PDI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1563                         "cvtps2dq\t{$src, $dst|$dst, $src}",
1564                         [(set VR128:$dst, (int_x86_sse2_cvtps2dq VR128:$src))]>;
1565 def Int_CVTPS2DQrm : PDI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1566                          "cvtps2dq\t{$src, $dst|$dst, $src}",
1567                          [(set VR128:$dst, (int_x86_sse2_cvtps2dq
1568                                             (memop addr:$src)))]>;
1569 // SSE2 packed instructions with XS prefix
1570 def CVTTPS2DQrr : SSI<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1571                       "cvttps2dq\t{$src, $dst|$dst, $src}", []>;
1572 def CVTTPS2DQrm : SSI<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1573                       "cvttps2dq\t{$src, $dst|$dst, $src}", []>;
1574
1575 def Int_CVTTPS2DQrr : I<0x5B, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1576                         "cvttps2dq\t{$src, $dst|$dst, $src}",
1577                         [(set VR128:$dst,
1578                               (int_x86_sse2_cvttps2dq VR128:$src))]>,
1579                       XS, Requires<[HasSSE2]>;
1580 def Int_CVTTPS2DQrm : I<0x5B, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1581                         "cvttps2dq\t{$src, $dst|$dst, $src}",
1582                         [(set VR128:$dst, (int_x86_sse2_cvttps2dq
1583                                            (memop addr:$src)))]>,
1584                       XS, Requires<[HasSSE2]>;
1585
1586 // SSE2 packed instructions with XD prefix
1587 def Int_CVTPD2DQrr : I<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1588                        "cvtpd2dq\t{$src, $dst|$dst, $src}",
1589                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq VR128:$src))]>,
1590                      XD, Requires<[HasSSE2]>;
1591 def Int_CVTPD2DQrm : I<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1592                        "cvtpd2dq\t{$src, $dst|$dst, $src}",
1593                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq
1594                                           (memop addr:$src)))]>,
1595                      XD, Requires<[HasSSE2]>;
1596
1597 def Int_CVTTPD2DQrr : PDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1598                           "cvttpd2dq\t{$src, $dst|$dst, $src}",
1599                        [(set VR128:$dst, (int_x86_sse2_cvttpd2dq VR128:$src))]>;
1600 def Int_CVTTPD2DQrm : PDI<0xE6, MRMSrcMem, (outs VR128:$dst),(ins f128mem:$src),
1601                           "cvttpd2dq\t{$src, $dst|$dst, $src}",
1602                           [(set VR128:$dst, (int_x86_sse2_cvttpd2dq
1603                                              (memop addr:$src)))]>;
1604
1605 // SSE2 instructions without OpSize prefix
1606 def CVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1607                        "cvtps2pd\t{$src, $dst|$dst, $src}", []>, TB;
1608 def CVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
1609                        "cvtps2pd\t{$src, $dst|$dst, $src}", []>, TB;
1610
1611 def Int_CVTPS2PDrr : I<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1612                        "cvtps2pd\t{$src, $dst|$dst, $src}",
1613                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd VR128:$src))]>,
1614                      TB, Requires<[HasSSE2]>;
1615 def Int_CVTPS2PDrm : I<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
1616                        "cvtps2pd\t{$src, $dst|$dst, $src}",
1617                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd
1618                                           (load addr:$src)))]>,
1619                      TB, Requires<[HasSSE2]>;
1620
1621 def CVTPD2PSrr : PDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1622                      "cvtpd2ps\t{$src, $dst|$dst, $src}", []>;
1623 def CVTPD2PSrm : PDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1624                      "cvtpd2ps\t{$src, $dst|$dst, $src}", []>;
1625
1626
1627 def Int_CVTPD2PSrr : PDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1628                          "cvtpd2ps\t{$src, $dst|$dst, $src}",
1629                         [(set VR128:$dst, (int_x86_sse2_cvtpd2ps VR128:$src))]>;
1630 def Int_CVTPD2PSrm : PDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1631                          "cvtpd2ps\t{$src, $dst|$dst, $src}",
1632                          [(set VR128:$dst, (int_x86_sse2_cvtpd2ps
1633                                             (memop addr:$src)))]>;
1634
1635 // Match intrinsics which expect XMM operand(s).
1636 // Aliases for intrinsics
1637 let Constraints = "$src1 = $dst" in {
1638 def Int_CVTSI2SDrr: SDI<0x2A, MRMSrcReg,
1639                         (outs VR128:$dst), (ins VR128:$src1, GR32:$src2),
1640                         "cvtsi2sd\t{$src2, $dst|$dst, $src2}",
1641                         [(set VR128:$dst, (int_x86_sse2_cvtsi2sd VR128:$src1,
1642                                            GR32:$src2))]>;
1643 def Int_CVTSI2SDrm: SDI<0x2A, MRMSrcMem,
1644                         (outs VR128:$dst), (ins VR128:$src1, i32mem:$src2),
1645                         "cvtsi2sd\t{$src2, $dst|$dst, $src2}",
1646                         [(set VR128:$dst, (int_x86_sse2_cvtsi2sd VR128:$src1,
1647                                            (loadi32 addr:$src2)))]>;
1648 def Int_CVTSD2SSrr: SDI<0x5A, MRMSrcReg,
1649                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1650                    "cvtsd2ss\t{$src2, $dst|$dst, $src2}",
1651                    [(set VR128:$dst, (int_x86_sse2_cvtsd2ss VR128:$src1,
1652                                       VR128:$src2))]>;
1653 def Int_CVTSD2SSrm: SDI<0x5A, MRMSrcMem,
1654                         (outs VR128:$dst), (ins VR128:$src1, f64mem:$src2),
1655                    "cvtsd2ss\t{$src2, $dst|$dst, $src2}",
1656                    [(set VR128:$dst, (int_x86_sse2_cvtsd2ss VR128:$src1,
1657                                       (load addr:$src2)))]>;
1658 def Int_CVTSS2SDrr: I<0x5A, MRMSrcReg,
1659                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1660                     "cvtss2sd\t{$src2, $dst|$dst, $src2}",
1661                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1662                                        VR128:$src2))]>, XS,
1663                     Requires<[HasSSE2]>;
1664 def Int_CVTSS2SDrm: I<0x5A, MRMSrcMem,
1665                       (outs VR128:$dst), (ins VR128:$src1, f32mem:$src2),
1666                     "cvtss2sd\t{$src2, $dst|$dst, $src2}",
1667                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1668                                        (load addr:$src2)))]>, XS,
1669                     Requires<[HasSSE2]>;
1670 }
1671
1672 // Arithmetic
1673
1674 /// sse2_fp_unop_rm - SSE2 unops come in both scalar and vector forms.
1675 ///
1676 /// In addition, we also have a special variant of the scalar form here to
1677 /// represent the associated intrinsic operation.  This form is unlike the
1678 /// plain scalar form, in that it takes an entire vector (instead of a
1679 /// scalar) and leaves the top elements undefined.
1680 ///
1681 /// And, we have a special variant form for a full-vector intrinsic form.
1682 ///
1683 /// These four forms can each have a reg or a mem operand, so there are a
1684 /// total of eight "instructions".
1685 ///
1686 multiclass sse2_fp_unop_rm<bits<8> opc, string OpcodeStr,
1687                            SDNode OpNode,
1688                            Intrinsic F64Int,
1689                            Intrinsic V2F64Int,
1690                            bit Commutable = 0> {
1691   // Scalar operation, reg.
1692   def SDr : SDI<opc, MRMSrcReg, (outs FR64:$dst), (ins FR64:$src),
1693                 !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
1694                 [(set FR64:$dst, (OpNode FR64:$src))]> {
1695     let isCommutable = Commutable;
1696   }
1697
1698   // Scalar operation, mem.
1699   def SDm : SDI<opc, MRMSrcMem, (outs FR64:$dst), (ins f64mem:$src),
1700                 !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
1701                 [(set FR64:$dst, (OpNode (load addr:$src)))]>;
1702
1703   // Vector operation, reg.
1704   def PDr : PDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1705               !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
1706               [(set VR128:$dst, (v2f64 (OpNode VR128:$src)))]> {
1707     let isCommutable = Commutable;
1708   }
1709
1710   // Vector operation, mem.
1711   def PDm : PDI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1712                 !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
1713                 [(set VR128:$dst, (OpNode (memopv2f64 addr:$src)))]>;
1714
1715   // Intrinsic operation, reg.
1716   def SDr_Int : SDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1717                     !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
1718                     [(set VR128:$dst, (F64Int VR128:$src))]> {
1719     let isCommutable = Commutable;
1720   }
1721
1722   // Intrinsic operation, mem.
1723   def SDm_Int : SDI<opc, MRMSrcMem, (outs VR128:$dst), (ins sdmem:$src),
1724                     !strconcat(OpcodeStr, "sd\t{$src, $dst|$dst, $src}"),
1725                     [(set VR128:$dst, (F64Int sse_load_f64:$src))]>;
1726
1727   // Vector intrinsic operation, reg
1728   def PDr_Int : PDI<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1729                     !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
1730                     [(set VR128:$dst, (V2F64Int VR128:$src))]> {
1731     let isCommutable = Commutable;
1732   }
1733
1734   // Vector intrinsic operation, mem
1735   def PDm_Int : PDI<opc, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
1736                     !strconcat(OpcodeStr, "pd\t{$src, $dst|$dst, $src}"),
1737                     [(set VR128:$dst, (V2F64Int (memopv2f64 addr:$src)))]>;
1738 }
1739
1740 // Square root.
1741 defm SQRT  : sse2_fp_unop_rm<0x51, "sqrt",  fsqrt,
1742                              int_x86_sse2_sqrt_sd, int_x86_sse2_sqrt_pd>;
1743
1744 // There is no f64 version of the reciprocal approximation instructions.
1745
1746 // Logical
1747 let Constraints = "$src1 = $dst" in {
1748   let isCommutable = 1 in {
1749     def ANDPDrr : PDI<0x54, MRMSrcReg,
1750                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1751                       "andpd\t{$src2, $dst|$dst, $src2}",
1752                       [(set VR128:$dst,
1753                         (and (bc_v2i64 (v2f64 VR128:$src1)),
1754                          (bc_v2i64 (v2f64 VR128:$src2))))]>;
1755     def ORPDrr  : PDI<0x56, MRMSrcReg,
1756                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1757                       "orpd\t{$src2, $dst|$dst, $src2}",
1758                       [(set VR128:$dst,
1759                         (or (bc_v2i64 (v2f64 VR128:$src1)),
1760                          (bc_v2i64 (v2f64 VR128:$src2))))]>;
1761     def XORPDrr : PDI<0x57, MRMSrcReg,
1762                       (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1763                       "xorpd\t{$src2, $dst|$dst, $src2}",
1764                       [(set VR128:$dst,
1765                         (xor (bc_v2i64 (v2f64 VR128:$src1)),
1766                          (bc_v2i64 (v2f64 VR128:$src2))))]>;
1767   }
1768
1769   def ANDPDrm : PDI<0x54, MRMSrcMem,
1770                     (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
1771                     "andpd\t{$src2, $dst|$dst, $src2}",
1772                     [(set VR128:$dst,
1773                       (and (bc_v2i64 (v2f64 VR128:$src1)),
1774                        (memopv2i64 addr:$src2)))]>;
1775   def ORPDrm  : PDI<0x56, MRMSrcMem,
1776                     (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
1777                     "orpd\t{$src2, $dst|$dst, $src2}",
1778                     [(set VR128:$dst,
1779                       (or (bc_v2i64 (v2f64 VR128:$src1)),
1780                        (memopv2i64 addr:$src2)))]>;
1781   def XORPDrm : PDI<0x57, MRMSrcMem,
1782                     (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
1783                     "xorpd\t{$src2, $dst|$dst, $src2}",
1784                     [(set VR128:$dst,
1785                       (xor (bc_v2i64 (v2f64 VR128:$src1)),
1786                        (memopv2i64 addr:$src2)))]>;
1787   def ANDNPDrr : PDI<0x55, MRMSrcReg,
1788                      (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1789                      "andnpd\t{$src2, $dst|$dst, $src2}",
1790                      [(set VR128:$dst,
1791                        (and (vnot (bc_v2i64 (v2f64 VR128:$src1))),
1792                         (bc_v2i64 (v2f64 VR128:$src2))))]>;
1793   def ANDNPDrm : PDI<0x55, MRMSrcMem,
1794                      (outs VR128:$dst), (ins VR128:$src1,f128mem:$src2),
1795                      "andnpd\t{$src2, $dst|$dst, $src2}",
1796                      [(set VR128:$dst,
1797                        (and (vnot (bc_v2i64 (v2f64 VR128:$src1))),
1798                         (memopv2i64 addr:$src2)))]>;
1799 }
1800
1801 let Constraints = "$src1 = $dst" in {
1802   def CMPPDrri : PDIi8<0xC2, MRMSrcReg,
1803                     (outs VR128:$dst), (ins VR128:$src1, VR128:$src, SSECC:$cc),
1804                     "cmp${cc}pd\t{$src, $dst|$dst, $src}",
1805                     [(set VR128:$dst, (int_x86_sse2_cmp_pd VR128:$src1,
1806                                                         VR128:$src, imm:$cc))]>;
1807   def CMPPDrmi : PDIi8<0xC2, MRMSrcMem,
1808                   (outs VR128:$dst), (ins VR128:$src1, f128mem:$src, SSECC:$cc),
1809                   "cmp${cc}pd\t{$src, $dst|$dst, $src}",
1810                   [(set VR128:$dst, (int_x86_sse2_cmp_pd VR128:$src1,
1811                                                  (memop addr:$src), imm:$cc))]>;
1812 }
1813 def : Pat<(v2i64 (X86cmppd (v2f64 VR128:$src1), VR128:$src2, imm:$cc)),
1814           (CMPPDrri VR128:$src1, VR128:$src2, imm:$cc)>;
1815 def : Pat<(v2i64 (X86cmppd (v2f64 VR128:$src1), (memop addr:$src2), imm:$cc)),
1816           (CMPPDrmi VR128:$src1, addr:$src2, imm:$cc)>;
1817
1818 // Shuffle and unpack instructions
1819 let Constraints = "$src1 = $dst" in {
1820   def SHUFPDrri : PDIi8<0xC6, MRMSrcReg,
1821                  (outs VR128:$dst), (ins VR128:$src1, VR128:$src2, i8imm:$src3),
1822                  "shufpd\t{$src3, $src2, $dst|$dst, $src2, $src3}",
1823                  [(set VR128:$dst,
1824                    (v2f64 (shufp:$src3 VR128:$src1, VR128:$src2)))]>;
1825   def SHUFPDrmi : PDIi8<0xC6, MRMSrcMem,
1826                         (outs VR128:$dst), (ins VR128:$src1,
1827                          f128mem:$src2, i8imm:$src3),
1828                         "shufpd\t{$src3, $src2, $dst|$dst, $src2, $src3}",
1829                         [(set VR128:$dst,
1830                           (v2f64 (shufp:$src3
1831                                   VR128:$src1, (memopv2f64 addr:$src2))))]>;
1832
1833   let AddedComplexity = 10 in {
1834     def UNPCKHPDrr : PDI<0x15, MRMSrcReg,
1835                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1836                          "unpckhpd\t{$src2, $dst|$dst, $src2}",
1837                          [(set VR128:$dst,
1838                            (v2f64 (unpckh VR128:$src1, VR128:$src2)))]>;
1839     def UNPCKHPDrm : PDI<0x15, MRMSrcMem,
1840                          (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
1841                          "unpckhpd\t{$src2, $dst|$dst, $src2}",
1842                          [(set VR128:$dst,
1843                            (v2f64 (unpckh VR128:$src1,
1844                                           (memopv2f64 addr:$src2))))]>;
1845
1846     def UNPCKLPDrr : PDI<0x14, MRMSrcReg,
1847                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1848                          "unpcklpd\t{$src2, $dst|$dst, $src2}",
1849                          [(set VR128:$dst,
1850                            (v2f64 (unpckl VR128:$src1, VR128:$src2)))]>;
1851     def UNPCKLPDrm : PDI<0x14, MRMSrcMem,
1852                          (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
1853                          "unpcklpd\t{$src2, $dst|$dst, $src2}",
1854                          [(set VR128:$dst,
1855                            (unpckl VR128:$src1, (memopv2f64 addr:$src2)))]>;
1856   } // AddedComplexity
1857 } // Constraints = "$src1 = $dst"
1858
1859
1860 //===---------------------------------------------------------------------===//
1861 // SSE integer instructions
1862
1863 // Move Instructions
1864 let neverHasSideEffects = 1 in
1865 def MOVDQArr : PDI<0x6F, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
1866                    "movdqa\t{$src, $dst|$dst, $src}", []>;
1867 let canFoldAsLoad = 1, mayLoad = 1 in
1868 def MOVDQArm : PDI<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
1869                    "movdqa\t{$src, $dst|$dst, $src}",
1870                    [/*(set VR128:$dst, (alignedloadv2i64 addr:$src))*/]>;
1871 let mayStore = 1 in
1872 def MOVDQAmr : PDI<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
1873                    "movdqa\t{$src, $dst|$dst, $src}",
1874                    [/*(alignedstore (v2i64 VR128:$src), addr:$dst)*/]>;
1875 let canFoldAsLoad = 1, mayLoad = 1 in
1876 def MOVDQUrm :   I<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
1877                    "movdqu\t{$src, $dst|$dst, $src}",
1878                    [/*(set VR128:$dst, (loadv2i64 addr:$src))*/]>,
1879                  XS, Requires<[HasSSE2]>;
1880 let mayStore = 1 in
1881 def MOVDQUmr :   I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
1882                    "movdqu\t{$src, $dst|$dst, $src}",
1883                    [/*(store (v2i64 VR128:$src), addr:$dst)*/]>,
1884                  XS, Requires<[HasSSE2]>;
1885
1886 // Intrinsic forms of MOVDQU load and store
1887 let canFoldAsLoad = 1 in
1888 def MOVDQUrm_Int :   I<0x6F, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
1889                        "movdqu\t{$src, $dst|$dst, $src}",
1890                        [(set VR128:$dst, (int_x86_sse2_loadu_dq addr:$src))]>,
1891                  XS, Requires<[HasSSE2]>;
1892 def MOVDQUmr_Int :   I<0x7F, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
1893                        "movdqu\t{$src, $dst|$dst, $src}",
1894                        [(int_x86_sse2_storeu_dq addr:$dst, VR128:$src)]>,
1895                      XS, Requires<[HasSSE2]>;
1896
1897 let Constraints = "$src1 = $dst" in {
1898
1899 multiclass PDI_binop_rm_int<bits<8> opc, string OpcodeStr, Intrinsic IntId,
1900                             bit Commutable = 0> {
1901   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
1902                                (ins VR128:$src1, VR128:$src2),
1903                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1904                [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]> {
1905     let isCommutable = Commutable;
1906   }
1907   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
1908                                (ins VR128:$src1, i128mem:$src2),
1909                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1910                [(set VR128:$dst, (IntId VR128:$src1,
1911                                         (bitconvert (memopv2i64
1912                                                      addr:$src2))))]>;
1913 }
1914
1915 multiclass PDI_binop_rmi_int<bits<8> opc, bits<8> opc2, Format ImmForm,
1916                              string OpcodeStr,
1917                              Intrinsic IntId, Intrinsic IntId2> {
1918   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
1919                                (ins VR128:$src1, VR128:$src2),
1920                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1921                [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
1922   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
1923                                (ins VR128:$src1, i128mem:$src2),
1924                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1925                [(set VR128:$dst, (IntId VR128:$src1,
1926                                       (bitconvert (memopv2i64 addr:$src2))))]>;
1927   def ri : PDIi8<opc2, ImmForm, (outs VR128:$dst),
1928                                 (ins VR128:$src1, i32i8imm:$src2),
1929                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1930                [(set VR128:$dst, (IntId2 VR128:$src1, (i32 imm:$src2)))]>;
1931 }
1932
1933 /// PDI_binop_rm - Simple SSE2 binary operator.
1934 multiclass PDI_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
1935                         ValueType OpVT, bit Commutable = 0> {
1936   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
1937                                (ins VR128:$src1, VR128:$src2),
1938                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1939                [(set VR128:$dst, (OpVT (OpNode VR128:$src1, VR128:$src2)))]> {
1940     let isCommutable = Commutable;
1941   }
1942   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
1943                                (ins VR128:$src1, i128mem:$src2),
1944                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1945                [(set VR128:$dst, (OpVT (OpNode VR128:$src1,
1946                                      (bitconvert (memopv2i64 addr:$src2)))))]>;
1947 }
1948
1949 /// PDI_binop_rm_v2i64 - Simple SSE2 binary operator whose type is v2i64.
1950 ///
1951 /// FIXME: we could eliminate this and use PDI_binop_rm instead if tblgen knew
1952 /// to collapse (bitconvert VT to VT) into its operand.
1953 ///
1954 multiclass PDI_binop_rm_v2i64<bits<8> opc, string OpcodeStr, SDNode OpNode,
1955                               bit Commutable = 0> {
1956   def rr : PDI<opc, MRMSrcReg, (outs VR128:$dst),
1957                (ins VR128:$src1, VR128:$src2),
1958                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1959                [(set VR128:$dst, (v2i64 (OpNode VR128:$src1, VR128:$src2)))]> {
1960     let isCommutable = Commutable;
1961   }
1962   def rm : PDI<opc, MRMSrcMem, (outs VR128:$dst),
1963                (ins VR128:$src1, i128mem:$src2),
1964                !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1965                [(set VR128:$dst, (OpNode VR128:$src1,
1966                (memopv2i64 addr:$src2)))]>;
1967 }
1968
1969 } // Constraints = "$src1 = $dst"
1970
1971 // 128-bit Integer Arithmetic
1972
1973 defm PADDB : PDI_binop_rm<0xFC, "paddb", add, v16i8, 1>;
1974 defm PADDW : PDI_binop_rm<0xFD, "paddw", add, v8i16, 1>;
1975 defm PADDD : PDI_binop_rm<0xFE, "paddd", add, v4i32, 1>;
1976 defm PADDQ : PDI_binop_rm_v2i64<0xD4, "paddq", add, 1>;
1977
1978 defm PADDSB  : PDI_binop_rm_int<0xEC, "paddsb" , int_x86_sse2_padds_b, 1>;
1979 defm PADDSW  : PDI_binop_rm_int<0xED, "paddsw" , int_x86_sse2_padds_w, 1>;
1980 defm PADDUSB : PDI_binop_rm_int<0xDC, "paddusb", int_x86_sse2_paddus_b, 1>;
1981 defm PADDUSW : PDI_binop_rm_int<0xDD, "paddusw", int_x86_sse2_paddus_w, 1>;
1982
1983 defm PSUBB : PDI_binop_rm<0xF8, "psubb", sub, v16i8>;
1984 defm PSUBW : PDI_binop_rm<0xF9, "psubw", sub, v8i16>;
1985 defm PSUBD : PDI_binop_rm<0xFA, "psubd", sub, v4i32>;
1986 defm PSUBQ : PDI_binop_rm_v2i64<0xFB, "psubq", sub>;
1987
1988 defm PSUBSB  : PDI_binop_rm_int<0xE8, "psubsb" , int_x86_sse2_psubs_b>;
1989 defm PSUBSW  : PDI_binop_rm_int<0xE9, "psubsw" , int_x86_sse2_psubs_w>;
1990 defm PSUBUSB : PDI_binop_rm_int<0xD8, "psubusb", int_x86_sse2_psubus_b>;
1991 defm PSUBUSW : PDI_binop_rm_int<0xD9, "psubusw", int_x86_sse2_psubus_w>;
1992
1993 defm PMULLW : PDI_binop_rm<0xD5, "pmullw", mul, v8i16, 1>;
1994
1995 defm PMULHUW : PDI_binop_rm_int<0xE4, "pmulhuw", int_x86_sse2_pmulhu_w, 1>;
1996 defm PMULHW  : PDI_binop_rm_int<0xE5, "pmulhw" , int_x86_sse2_pmulh_w , 1>;
1997 defm PMULUDQ : PDI_binop_rm_int<0xF4, "pmuludq", int_x86_sse2_pmulu_dq, 1>;
1998
1999 defm PMADDWD : PDI_binop_rm_int<0xF5, "pmaddwd", int_x86_sse2_pmadd_wd, 1>;
2000
2001 defm PAVGB  : PDI_binop_rm_int<0xE0, "pavgb", int_x86_sse2_pavg_b, 1>;
2002 defm PAVGW  : PDI_binop_rm_int<0xE3, "pavgw", int_x86_sse2_pavg_w, 1>;
2003
2004
2005 defm PMINUB : PDI_binop_rm_int<0xDA, "pminub", int_x86_sse2_pminu_b, 1>;
2006 defm PMINSW : PDI_binop_rm_int<0xEA, "pminsw", int_x86_sse2_pmins_w, 1>;
2007 defm PMAXUB : PDI_binop_rm_int<0xDE, "pmaxub", int_x86_sse2_pmaxu_b, 1>;
2008 defm PMAXSW : PDI_binop_rm_int<0xEE, "pmaxsw", int_x86_sse2_pmaxs_w, 1>;
2009 defm PSADBW : PDI_binop_rm_int<0xF6, "psadbw", int_x86_sse2_psad_bw, 1>;
2010
2011
2012 defm PSLLW : PDI_binop_rmi_int<0xF1, 0x71, MRM6r, "psllw",
2013                                int_x86_sse2_psll_w, int_x86_sse2_pslli_w>;
2014 defm PSLLD : PDI_binop_rmi_int<0xF2, 0x72, MRM6r, "pslld",
2015                                int_x86_sse2_psll_d, int_x86_sse2_pslli_d>;
2016 defm PSLLQ : PDI_binop_rmi_int<0xF3, 0x73, MRM6r, "psllq",
2017                                int_x86_sse2_psll_q, int_x86_sse2_pslli_q>;
2018
2019 defm PSRLW : PDI_binop_rmi_int<0xD1, 0x71, MRM2r, "psrlw",
2020                                int_x86_sse2_psrl_w, int_x86_sse2_psrli_w>;
2021 defm PSRLD : PDI_binop_rmi_int<0xD2, 0x72, MRM2r, "psrld",
2022                                int_x86_sse2_psrl_d, int_x86_sse2_psrli_d>;
2023 defm PSRLQ : PDI_binop_rmi_int<0xD3, 0x73, MRM2r, "psrlq",
2024                                int_x86_sse2_psrl_q, int_x86_sse2_psrli_q>;
2025
2026 defm PSRAW : PDI_binop_rmi_int<0xE1, 0x71, MRM4r, "psraw",
2027                                int_x86_sse2_psra_w, int_x86_sse2_psrai_w>;
2028 defm PSRAD : PDI_binop_rmi_int<0xE2, 0x72, MRM4r, "psrad",
2029                                int_x86_sse2_psra_d, int_x86_sse2_psrai_d>;
2030
2031 // 128-bit logical shifts.
2032 let Constraints = "$src1 = $dst", neverHasSideEffects = 1 in {
2033   def PSLLDQri : PDIi8<0x73, MRM7r,
2034                        (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
2035                        "pslldq\t{$src2, $dst|$dst, $src2}", []>;
2036   def PSRLDQri : PDIi8<0x73, MRM3r,
2037                        (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
2038                        "psrldq\t{$src2, $dst|$dst, $src2}", []>;
2039   // PSRADQri doesn't exist in SSE[1-3].
2040 }
2041
2042 let Predicates = [HasSSE2] in {
2043   def : Pat<(int_x86_sse2_psll_dq VR128:$src1, imm:$src2),
2044             (v2i64 (PSLLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
2045   def : Pat<(int_x86_sse2_psrl_dq VR128:$src1, imm:$src2),
2046             (v2i64 (PSRLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
2047   def : Pat<(int_x86_sse2_psll_dq_bs VR128:$src1, imm:$src2),
2048             (v2i64 (PSLLDQri VR128:$src1, imm:$src2))>;
2049   def : Pat<(int_x86_sse2_psrl_dq_bs VR128:$src1, imm:$src2),
2050             (v2i64 (PSRLDQri VR128:$src1, imm:$src2))>;
2051   def : Pat<(v2f64 (X86fsrl VR128:$src1, i32immSExt8:$src2)),
2052             (v2f64 (PSRLDQri VR128:$src1, (BYTE_imm imm:$src2)))>;
2053
2054   // Shift up / down and insert zero's.
2055   def : Pat<(v2i64 (X86vshl  VR128:$src, (i8 imm:$amt))),
2056             (v2i64 (PSLLDQri VR128:$src, (BYTE_imm imm:$amt)))>;
2057   def : Pat<(v2i64 (X86vshr  VR128:$src, (i8 imm:$amt))),
2058             (v2i64 (PSRLDQri VR128:$src, (BYTE_imm imm:$amt)))>;
2059 }
2060
2061 // Logical
2062 defm PAND : PDI_binop_rm_v2i64<0xDB, "pand", and, 1>;
2063 defm POR  : PDI_binop_rm_v2i64<0xEB, "por" , or , 1>;
2064 defm PXOR : PDI_binop_rm_v2i64<0xEF, "pxor", xor, 1>;
2065
2066 let Constraints = "$src1 = $dst" in {
2067   def PANDNrr : PDI<0xDF, MRMSrcReg,
2068                     (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2069                     "pandn\t{$src2, $dst|$dst, $src2}",
2070                     [(set VR128:$dst, (v2i64 (and (vnot VR128:$src1),
2071                                               VR128:$src2)))]>;
2072
2073   def PANDNrm : PDI<0xDF, MRMSrcMem,
2074                     (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2075                     "pandn\t{$src2, $dst|$dst, $src2}",
2076                     [(set VR128:$dst, (v2i64 (and (vnot VR128:$src1),
2077                                               (memopv2i64 addr:$src2))))]>;
2078 }
2079
2080 // SSE2 Integer comparison
2081 defm PCMPEQB  : PDI_binop_rm_int<0x74, "pcmpeqb", int_x86_sse2_pcmpeq_b>;
2082 defm PCMPEQW  : PDI_binop_rm_int<0x75, "pcmpeqw", int_x86_sse2_pcmpeq_w>;
2083 defm PCMPEQD  : PDI_binop_rm_int<0x76, "pcmpeqd", int_x86_sse2_pcmpeq_d>;
2084 defm PCMPGTB  : PDI_binop_rm_int<0x64, "pcmpgtb", int_x86_sse2_pcmpgt_b>;
2085 defm PCMPGTW  : PDI_binop_rm_int<0x65, "pcmpgtw", int_x86_sse2_pcmpgt_w>;
2086 defm PCMPGTD  : PDI_binop_rm_int<0x66, "pcmpgtd", int_x86_sse2_pcmpgt_d>;
2087
2088 def : Pat<(v16i8 (X86pcmpeqb VR128:$src1, VR128:$src2)),
2089           (PCMPEQBrr VR128:$src1, VR128:$src2)>;
2090 def : Pat<(v16i8 (X86pcmpeqb VR128:$src1, (memop addr:$src2))),
2091           (PCMPEQBrm VR128:$src1, addr:$src2)>;
2092 def : Pat<(v8i16 (X86pcmpeqw VR128:$src1, VR128:$src2)),
2093           (PCMPEQWrr VR128:$src1, VR128:$src2)>;
2094 def : Pat<(v8i16 (X86pcmpeqw VR128:$src1, (memop addr:$src2))),
2095           (PCMPEQWrm VR128:$src1, addr:$src2)>;
2096 def : Pat<(v4i32 (X86pcmpeqd VR128:$src1, VR128:$src2)),
2097           (PCMPEQDrr VR128:$src1, VR128:$src2)>;
2098 def : Pat<(v4i32 (X86pcmpeqd VR128:$src1, (memop addr:$src2))),
2099           (PCMPEQDrm VR128:$src1, addr:$src2)>;
2100
2101 def : Pat<(v16i8 (X86pcmpgtb VR128:$src1, VR128:$src2)),
2102           (PCMPGTBrr VR128:$src1, VR128:$src2)>;
2103 def : Pat<(v16i8 (X86pcmpgtb VR128:$src1, (memop addr:$src2))),
2104           (PCMPGTBrm VR128:$src1, addr:$src2)>;
2105 def : Pat<(v8i16 (X86pcmpgtw VR128:$src1, VR128:$src2)),
2106           (PCMPGTWrr VR128:$src1, VR128:$src2)>;
2107 def : Pat<(v8i16 (X86pcmpgtw VR128:$src1, (memop addr:$src2))),
2108           (PCMPGTWrm VR128:$src1, addr:$src2)>;
2109 def : Pat<(v4i32 (X86pcmpgtd VR128:$src1, VR128:$src2)),
2110           (PCMPGTDrr VR128:$src1, VR128:$src2)>;
2111 def : Pat<(v4i32 (X86pcmpgtd VR128:$src1, (memop addr:$src2))),
2112           (PCMPGTDrm VR128:$src1, addr:$src2)>;
2113
2114
2115 // Pack instructions
2116 defm PACKSSWB : PDI_binop_rm_int<0x63, "packsswb", int_x86_sse2_packsswb_128>;
2117 defm PACKSSDW : PDI_binop_rm_int<0x6B, "packssdw", int_x86_sse2_packssdw_128>;
2118 defm PACKUSWB : PDI_binop_rm_int<0x67, "packuswb", int_x86_sse2_packuswb_128>;
2119
2120 // Shuffle and unpack instructions
2121 let AddedComplexity = 5 in {
2122 def PSHUFDri : PDIi8<0x70, MRMSrcReg,
2123                      (outs VR128:$dst), (ins VR128:$src1, i8imm:$src2),
2124                      "pshufd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2125                      [(set VR128:$dst, (v4i32 (pshufd:$src2
2126                                                VR128:$src1, (undef))))]>;
2127 def PSHUFDmi : PDIi8<0x70, MRMSrcMem,
2128                      (outs VR128:$dst), (ins i128mem:$src1, i8imm:$src2),
2129                      "pshufd\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2130                      [(set VR128:$dst, (v4i32 (pshufd:$src2
2131                                              (bc_v4i32 (memopv2i64 addr:$src1)),
2132                                              (undef))))]>;
2133 }
2134
2135 // SSE2 with ImmT == Imm8 and XS prefix.
2136 def PSHUFHWri : Ii8<0x70, MRMSrcReg,
2137                     (outs VR128:$dst), (ins VR128:$src1, i8imm:$src2),
2138                     "pshufhw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2139                     [(set VR128:$dst, (v8i16 (pshufhw:$src2 VR128:$src1,
2140                                                             (undef))))]>,
2141                 XS, Requires<[HasSSE2]>;
2142 def PSHUFHWmi : Ii8<0x70, MRMSrcMem,
2143                     (outs VR128:$dst), (ins i128mem:$src1, i8imm:$src2),
2144                     "pshufhw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2145                     [(set VR128:$dst, (v8i16 (pshufhw:$src2
2146                                             (bc_v8i16 (memopv2i64 addr:$src1)),
2147                                             (undef))))]>,
2148                 XS, Requires<[HasSSE2]>;
2149
2150 // SSE2 with ImmT == Imm8 and XD prefix.
2151 def PSHUFLWri : Ii8<0x70, MRMSrcReg,
2152                     (outs VR128:$dst), (ins VR128:$src1, i8imm:$src2),
2153                     "pshuflw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2154                     [(set VR128:$dst, (v8i16 (pshuflw:$src2 VR128:$src1,
2155                                                             (undef))))]>,
2156                 XD, Requires<[HasSSE2]>;
2157 def PSHUFLWmi : Ii8<0x70, MRMSrcMem,
2158                     (outs VR128:$dst), (ins i128mem:$src1, i8imm:$src2),
2159                     "pshuflw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2160                     [(set VR128:$dst, (v8i16 (pshuflw:$src2
2161                                              (bc_v8i16 (memopv2i64 addr:$src1)),
2162                                              (undef))))]>,
2163                 XD, Requires<[HasSSE2]>;
2164
2165
2166 let Constraints = "$src1 = $dst" in {
2167   def PUNPCKLBWrr : PDI<0x60, MRMSrcReg,
2168                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2169                         "punpcklbw\t{$src2, $dst|$dst, $src2}",
2170                         [(set VR128:$dst,
2171                           (v16i8 (unpckl VR128:$src1, VR128:$src2)))]>;
2172   def PUNPCKLBWrm : PDI<0x60, MRMSrcMem,
2173                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2174                         "punpcklbw\t{$src2, $dst|$dst, $src2}",
2175                         [(set VR128:$dst,
2176                           (unpckl VR128:$src1,
2177                                   (bc_v16i8 (memopv2i64 addr:$src2))))]>;
2178   def PUNPCKLWDrr : PDI<0x61, MRMSrcReg,
2179                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2180                         "punpcklwd\t{$src2, $dst|$dst, $src2}",
2181                         [(set VR128:$dst,
2182                           (v8i16 (unpckl VR128:$src1, VR128:$src2)))]>;
2183   def PUNPCKLWDrm : PDI<0x61, MRMSrcMem,
2184                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2185                         "punpcklwd\t{$src2, $dst|$dst, $src2}",
2186                         [(set VR128:$dst,
2187                           (unpckl VR128:$src1,
2188                                   (bc_v8i16 (memopv2i64 addr:$src2))))]>;
2189   def PUNPCKLDQrr : PDI<0x62, MRMSrcReg,
2190                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2191                         "punpckldq\t{$src2, $dst|$dst, $src2}",
2192                         [(set VR128:$dst,
2193                           (v4i32 (unpckl VR128:$src1, VR128:$src2)))]>;
2194   def PUNPCKLDQrm : PDI<0x62, MRMSrcMem,
2195                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2196                         "punpckldq\t{$src2, $dst|$dst, $src2}",
2197                         [(set VR128:$dst,
2198                           (unpckl VR128:$src1,
2199                                   (bc_v4i32 (memopv2i64 addr:$src2))))]>;
2200   def PUNPCKLQDQrr : PDI<0x6C, MRMSrcReg,
2201                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2202                          "punpcklqdq\t{$src2, $dst|$dst, $src2}",
2203                         [(set VR128:$dst,
2204                           (v2i64 (unpckl VR128:$src1, VR128:$src2)))]>;
2205   def PUNPCKLQDQrm : PDI<0x6C, MRMSrcMem,
2206                          (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2207                          "punpcklqdq\t{$src2, $dst|$dst, $src2}",
2208                         [(set VR128:$dst,
2209                           (v2i64 (unpckl VR128:$src1,
2210                                          (memopv2i64 addr:$src2))))]>;
2211
2212   def PUNPCKHBWrr : PDI<0x68, MRMSrcReg,
2213                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2214                         "punpckhbw\t{$src2, $dst|$dst, $src2}",
2215                         [(set VR128:$dst,
2216                           (v16i8 (unpckh VR128:$src1, VR128:$src2)))]>;
2217   def PUNPCKHBWrm : PDI<0x68, MRMSrcMem,
2218                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2219                         "punpckhbw\t{$src2, $dst|$dst, $src2}",
2220                         [(set VR128:$dst,
2221                           (unpckh VR128:$src1,
2222                                   (bc_v16i8 (memopv2i64 addr:$src2))))]>;
2223   def PUNPCKHWDrr : PDI<0x69, MRMSrcReg,
2224                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2225                         "punpckhwd\t{$src2, $dst|$dst, $src2}",
2226                         [(set VR128:$dst,
2227                           (v8i16 (unpckh VR128:$src1, VR128:$src2)))]>;
2228   def PUNPCKHWDrm : PDI<0x69, MRMSrcMem,
2229                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2230                         "punpckhwd\t{$src2, $dst|$dst, $src2}",
2231                         [(set VR128:$dst,
2232                           (unpckh VR128:$src1,
2233                                   (bc_v8i16 (memopv2i64 addr:$src2))))]>;
2234   def PUNPCKHDQrr : PDI<0x6A, MRMSrcReg,
2235                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2236                         "punpckhdq\t{$src2, $dst|$dst, $src2}",
2237                         [(set VR128:$dst,
2238                           (v4i32 (unpckh VR128:$src1, VR128:$src2)))]>;
2239   def PUNPCKHDQrm : PDI<0x6A, MRMSrcMem,
2240                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2241                         "punpckhdq\t{$src2, $dst|$dst, $src2}",
2242                         [(set VR128:$dst,
2243                           (unpckh VR128:$src1,
2244                                   (bc_v4i32 (memopv2i64 addr:$src2))))]>;
2245   def PUNPCKHQDQrr : PDI<0x6D, MRMSrcReg,
2246                          (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2247                          "punpckhqdq\t{$src2, $dst|$dst, $src2}",
2248                         [(set VR128:$dst,
2249                           (v2i64 (unpckh VR128:$src1, VR128:$src2)))]>;
2250   def PUNPCKHQDQrm : PDI<0x6D, MRMSrcMem,
2251                         (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
2252                         "punpckhqdq\t{$src2, $dst|$dst, $src2}",
2253                         [(set VR128:$dst,
2254                           (v2i64 (unpckh VR128:$src1,
2255                                          (memopv2i64 addr:$src2))))]>;
2256 }
2257
2258 // Extract / Insert
2259 def PEXTRWri : PDIi8<0xC5, MRMSrcReg,
2260                     (outs GR32:$dst), (ins VR128:$src1, i32i8imm:$src2),
2261                     "pextrw\t{$src2, $src1, $dst|$dst, $src1, $src2}",
2262                     [(set GR32:$dst, (X86pextrw (v8i16 VR128:$src1),
2263                                                 imm:$src2))]>;
2264 let Constraints = "$src1 = $dst" in {
2265   def PINSRWrri : PDIi8<0xC4, MRMSrcReg,
2266                        (outs VR128:$dst), (ins VR128:$src1,
2267                         GR32:$src2, i32i8imm:$src3),
2268                        "pinsrw\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2269                        [(set VR128:$dst,
2270                          (X86pinsrw VR128:$src1, GR32:$src2, imm:$src3))]>;
2271   def PINSRWrmi : PDIi8<0xC4, MRMSrcMem,
2272                        (outs VR128:$dst), (ins VR128:$src1,
2273                         i16mem:$src2, i32i8imm:$src3),
2274                        "pinsrw\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2275                        [(set VR128:$dst,
2276                          (X86pinsrw VR128:$src1, (extloadi16 addr:$src2),
2277                                     imm:$src3))]>;
2278 }
2279
2280 // Mask creation
2281 def PMOVMSKBrr : PDI<0xD7, MRMSrcReg, (outs GR32:$dst), (ins VR128:$src),
2282                      "pmovmskb\t{$src, $dst|$dst, $src}",
2283                      [(set GR32:$dst, (int_x86_sse2_pmovmskb_128 VR128:$src))]>;
2284
2285 // Conditional store
2286 let Uses = [EDI] in
2287 def MASKMOVDQU : PDI<0xF7, MRMSrcReg, (outs), (ins VR128:$src, VR128:$mask),
2288                      "maskmovdqu\t{$mask, $src|$src, $mask}",
2289                      [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, EDI)]>;
2290
2291 let Uses = [RDI] in
2292 def MASKMOVDQU64 : PDI<0xF7, MRMSrcReg, (outs), (ins VR128:$src, VR128:$mask),
2293                      "maskmovdqu\t{$mask, $src|$src, $mask}",
2294                      [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, RDI)]>;
2295
2296 // Non-temporal stores
2297 def MOVNTPDmr : PDI<0x2B, MRMDestMem, (outs), (ins i128mem:$dst, VR128:$src),
2298                     "movntpd\t{$src, $dst|$dst, $src}",
2299                     [(int_x86_sse2_movnt_pd addr:$dst, VR128:$src)]>;
2300 def MOVNTDQmr : PDI<0xE7, MRMDestMem, (outs), (ins f128mem:$dst, VR128:$src),
2301                     "movntdq\t{$src, $dst|$dst, $src}",
2302                     [(int_x86_sse2_movnt_dq addr:$dst, VR128:$src)]>;
2303 def MOVNTImr  :   I<0xC3, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
2304                     "movnti\t{$src, $dst|$dst, $src}",
2305                     [(int_x86_sse2_movnt_i addr:$dst, GR32:$src)]>,
2306                   TB, Requires<[HasSSE2]>;
2307
2308 // Flush cache
2309 def CLFLUSH : I<0xAE, MRM7m, (outs), (ins i8mem:$src),
2310                "clflush\t$src", [(int_x86_sse2_clflush addr:$src)]>,
2311               TB, Requires<[HasSSE2]>;
2312
2313 // Load, store, and memory fence
2314 def LFENCE : I<0xAE, MRM5r, (outs), (ins),
2315                "lfence", [(int_x86_sse2_lfence)]>, TB, Requires<[HasSSE2]>;
2316 def MFENCE : I<0xAE, MRM6r, (outs), (ins),
2317                "mfence", [(int_x86_sse2_mfence)]>, TB, Requires<[HasSSE2]>;
2318
2319 //TODO: custom lower this so as to never even generate the noop
2320 def : Pat<(membarrier (i8 imm:$ll), (i8 imm:$ls), (i8 imm:$sl), (i8 imm:$ss),
2321            (i8 0)), (NOOP)>;
2322 def : Pat<(membarrier (i8 0), (i8 0), (i8 0), (i8 1), (i8 1)), (SFENCE)>;
2323 def : Pat<(membarrier (i8 1), (i8 0), (i8 0), (i8 0), (i8 1)), (LFENCE)>;
2324 def : Pat<(membarrier (i8 imm:$ll), (i8 imm:$ls), (i8 imm:$sl), (i8 imm:$ss),
2325            (i8 1)), (MFENCE)>;
2326
2327 // Alias instructions that map zero vector to pxor / xorp* for sse.
2328 // We set canFoldAsLoad because this can be converted to a constant-pool
2329 // load of an all-ones value if folding it would be beneficial.
2330 let isReMaterializable = 1, isAsCheapAsAMove = 1, canFoldAsLoad = 1,
2331     isCodeGenOnly = 1 in
2332   def V_SETALLONES : PDI<0x76, MRMInitReg, (outs VR128:$dst), (ins),
2333                          "pcmpeqd\t$dst, $dst",
2334                          [(set VR128:$dst, (v4i32 immAllOnesV))]>;
2335
2336 // FR64 to 128-bit vector conversion.
2337 let isAsCheapAsAMove = 1 in
2338 def MOVSD2PDrr : SDI<0x10, MRMSrcReg, (outs VR128:$dst), (ins FR64:$src),
2339                       "movsd\t{$src, $dst|$dst, $src}",
2340                       [(set VR128:$dst,
2341                         (v2f64 (scalar_to_vector FR64:$src)))]>;
2342 def MOVSD2PDrm : SDI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
2343                      "movsd\t{$src, $dst|$dst, $src}",
2344                      [(set VR128:$dst,
2345                        (v2f64 (scalar_to_vector (loadf64 addr:$src))))]>;
2346
2347 def MOVDI2PDIrr : PDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
2348                       "movd\t{$src, $dst|$dst, $src}",
2349                       [(set VR128:$dst,
2350                         (v4i32 (scalar_to_vector GR32:$src)))]>;
2351 def MOVDI2PDIrm : PDI<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
2352                       "movd\t{$src, $dst|$dst, $src}",
2353                       [(set VR128:$dst,
2354                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))]>;
2355
2356 def MOVDI2SSrr  : PDI<0x6E, MRMSrcReg, (outs FR32:$dst), (ins GR32:$src),
2357                       "movd\t{$src, $dst|$dst, $src}",
2358                       [(set FR32:$dst, (bitconvert GR32:$src))]>;
2359
2360 def MOVDI2SSrm  : PDI<0x6E, MRMSrcMem, (outs FR32:$dst), (ins i32mem:$src),
2361                       "movd\t{$src, $dst|$dst, $src}",
2362                       [(set FR32:$dst, (bitconvert (loadi32 addr:$src)))]>;
2363
2364 // SSE2 instructions with XS prefix
2365 def MOVQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
2366                     "movq\t{$src, $dst|$dst, $src}",
2367                     [(set VR128:$dst,
2368                       (v2i64 (scalar_to_vector (loadi64 addr:$src))))]>, XS,
2369                   Requires<[HasSSE2]>;
2370 def MOVPQI2QImr : PDI<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
2371                       "movq\t{$src, $dst|$dst, $src}",
2372                       [(store (i64 (vector_extract (v2i64 VR128:$src),
2373                                     (iPTR 0))), addr:$dst)]>;
2374
2375 // FIXME: may not be able to eliminate this movss with coalescing the src and
2376 // dest register classes are different. We really want to write this pattern
2377 // like this:
2378 // def : Pat<(f32 (vector_extract (v4f32 VR128:$src), (iPTR 0))),
2379 //           (f32 FR32:$src)>;
2380 let isAsCheapAsAMove = 1 in
2381 def MOVPD2SDrr : SDI<0x10, MRMSrcReg, (outs FR64:$dst), (ins VR128:$src),
2382                      "movsd\t{$src, $dst|$dst, $src}",
2383                      [(set FR64:$dst, (vector_extract (v2f64 VR128:$src),
2384                                        (iPTR 0)))]>;
2385 def MOVPD2SDmr : SDI<0x11, MRMDestMem, (outs), (ins f64mem:$dst, VR128:$src),
2386                      "movsd\t{$src, $dst|$dst, $src}",
2387                      [(store (f64 (vector_extract (v2f64 VR128:$src),
2388                                    (iPTR 0))), addr:$dst)]>;
2389 def MOVPDI2DIrr  : PDI<0x7E, MRMDestReg, (outs GR32:$dst), (ins VR128:$src),
2390                        "movd\t{$src, $dst|$dst, $src}",
2391                        [(set GR32:$dst, (vector_extract (v4i32 VR128:$src),
2392                                         (iPTR 0)))]>;
2393 def MOVPDI2DImr  : PDI<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, VR128:$src),
2394                        "movd\t{$src, $dst|$dst, $src}",
2395                        [(store (i32 (vector_extract (v4i32 VR128:$src),
2396                                      (iPTR 0))), addr:$dst)]>;
2397
2398 def MOVSS2DIrr  : PDI<0x7E, MRMDestReg, (outs GR32:$dst), (ins FR32:$src),
2399                       "movd\t{$src, $dst|$dst, $src}",
2400                       [(set GR32:$dst, (bitconvert FR32:$src))]>;
2401 def MOVSS2DImr  : PDI<0x7E, MRMDestMem, (outs), (ins i32mem:$dst, FR32:$src),
2402                       "movd\t{$src, $dst|$dst, $src}",
2403                       [(store (i32 (bitconvert FR32:$src)), addr:$dst)]>;
2404
2405
2406 // Move to lower bits of a VR128, leaving upper bits alone.
2407 // Three operand (but two address) aliases.
2408 let Constraints = "$src1 = $dst" in {
2409   let neverHasSideEffects = 1 in
2410   def MOVLSD2PDrr : SDI<0x10, MRMSrcReg,
2411                         (outs VR128:$dst), (ins VR128:$src1, FR64:$src2),
2412                         "movsd\t{$src2, $dst|$dst, $src2}", []>;
2413
2414   let AddedComplexity = 15 in
2415     def MOVLPDrr : SDI<0x10, MRMSrcReg,
2416                        (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2417                        "movsd\t{$src2, $dst|$dst, $src2}",
2418                        [(set VR128:$dst,
2419                          (v2f64 (movl VR128:$src1, VR128:$src2)))]>;
2420 }
2421
2422 // Store / copy lower 64-bits of a XMM register.
2423 def MOVLQ128mr : PDI<0xD6, MRMDestMem, (outs), (ins i64mem:$dst, VR128:$src),
2424                      "movq\t{$src, $dst|$dst, $src}",
2425                      [(int_x86_sse2_storel_dq addr:$dst, VR128:$src)]>;
2426
2427 // Move to lower bits of a VR128 and zeroing upper bits.
2428 // Loading from memory automatically zeroing upper bits.
2429 let AddedComplexity = 20 in {
2430 def MOVZSD2PDrm : SDI<0x10, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
2431                       "movsd\t{$src, $dst|$dst, $src}",
2432                       [(set VR128:$dst,
2433                         (v2f64 (X86vzmovl (v2f64 (scalar_to_vector
2434                                                  (loadf64 addr:$src))))))]>;
2435
2436 def : Pat<(v2f64 (X86vzmovl (loadv2f64 addr:$src))),
2437             (MOVZSD2PDrm addr:$src)>;
2438 def : Pat<(v2f64 (X86vzmovl (bc_v2f64 (loadv4f32 addr:$src)))),
2439             (MOVZSD2PDrm addr:$src)>;
2440 def : Pat<(v2f64 (X86vzload addr:$src)), (MOVZSD2PDrm addr:$src)>;
2441 }
2442
2443 // movd / movq to XMM register zero-extends
2444 let AddedComplexity = 15 in {
2445 def MOVZDI2PDIrr : PDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR32:$src),
2446                        "movd\t{$src, $dst|$dst, $src}",
2447                        [(set VR128:$dst, (v4i32 (X86vzmovl
2448                                       (v4i32 (scalar_to_vector GR32:$src)))))]>;
2449 // This is X86-64 only.
2450 def MOVZQI2PQIrr : RPDI<0x6E, MRMSrcReg, (outs VR128:$dst), (ins GR64:$src),
2451                        "mov{d|q}\t{$src, $dst|$dst, $src}",
2452                        [(set VR128:$dst, (v2i64 (X86vzmovl
2453                                       (v2i64 (scalar_to_vector GR64:$src)))))]>;
2454 }
2455
2456 let AddedComplexity = 20 in {
2457 def MOVZDI2PDIrm : PDI<0x6E, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
2458                        "movd\t{$src, $dst|$dst, $src}",
2459                        [(set VR128:$dst,
2460                          (v4i32 (X86vzmovl (v4i32 (scalar_to_vector
2461                                                    (loadi32 addr:$src))))))]>;
2462
2463 def : Pat<(v4i32 (X86vzmovl (loadv4i32 addr:$src))),
2464             (MOVZDI2PDIrm addr:$src)>;
2465 def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv4f32 addr:$src)))),
2466             (MOVZDI2PDIrm addr:$src)>;
2467 def : Pat<(v4i32 (X86vzmovl (bc_v4i32 (loadv2i64 addr:$src)))),
2468             (MOVZDI2PDIrm addr:$src)>;
2469
2470 def MOVZQI2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
2471                      "movq\t{$src, $dst|$dst, $src}",
2472                      [(set VR128:$dst,
2473                        (v2i64 (X86vzmovl (v2i64 (scalar_to_vector
2474                                                  (loadi64 addr:$src))))))]>, XS,
2475                    Requires<[HasSSE2]>;
2476
2477 def : Pat<(v2i64 (X86vzmovl (loadv2i64 addr:$src))),
2478             (MOVZQI2PQIrm addr:$src)>;
2479 def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4f32 addr:$src)))),
2480             (MOVZQI2PQIrm addr:$src)>;
2481 def : Pat<(v2i64 (X86vzload addr:$src)), (MOVZQI2PQIrm addr:$src)>;
2482 }
2483
2484 // Moving from XMM to XMM and clear upper 64 bits. Note, there is a bug in
2485 // IA32 document. movq xmm1, xmm2 does clear the high bits.
2486 let AddedComplexity = 15 in
2487 def MOVZPQILo2PQIrr : I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2488                         "movq\t{$src, $dst|$dst, $src}",
2489                     [(set VR128:$dst, (v2i64 (X86vzmovl (v2i64 VR128:$src))))]>,
2490                       XS, Requires<[HasSSE2]>;
2491
2492 let AddedComplexity = 20 in {
2493 def MOVZPQILo2PQIrm : I<0x7E, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
2494                         "movq\t{$src, $dst|$dst, $src}",
2495                     [(set VR128:$dst, (v2i64 (X86vzmovl
2496                                              (loadv2i64 addr:$src))))]>,
2497                       XS, Requires<[HasSSE2]>;
2498
2499 def : Pat<(v2i64 (X86vzmovl (bc_v2i64 (loadv4i32 addr:$src)))),
2500             (MOVZPQILo2PQIrm addr:$src)>;
2501 }
2502
2503 // Instructions for the disassembler
2504 // xr = XMM register
2505 // xm = mem64
2506
2507 def MOVQxrxr : I<0x7E, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2508                  "movq\t{$src, $dst|$dst, $src}", []>, XS;
2509
2510 //===---------------------------------------------------------------------===//
2511 // SSE3 Instructions
2512 //===---------------------------------------------------------------------===//
2513
2514 // Move Instructions
2515 def MOVSHDUPrr : S3SI<0x16, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2516                       "movshdup\t{$src, $dst|$dst, $src}",
2517                       [(set VR128:$dst, (v4f32 (movshdup
2518                                                 VR128:$src, (undef))))]>;
2519 def MOVSHDUPrm : S3SI<0x16, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2520                       "movshdup\t{$src, $dst|$dst, $src}",
2521                       [(set VR128:$dst, (movshdup
2522                                          (memopv4f32 addr:$src), (undef)))]>;
2523
2524 def MOVSLDUPrr : S3SI<0x12, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2525                       "movsldup\t{$src, $dst|$dst, $src}",
2526                       [(set VR128:$dst, (v4f32 (movsldup
2527                                                 VR128:$src, (undef))))]>;
2528 def MOVSLDUPrm : S3SI<0x12, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
2529                       "movsldup\t{$src, $dst|$dst, $src}",
2530                       [(set VR128:$dst, (movsldup
2531                                          (memopv4f32 addr:$src), (undef)))]>;
2532
2533 def MOVDDUPrr  : S3DI<0x12, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
2534                       "movddup\t{$src, $dst|$dst, $src}",
2535                       [(set VR128:$dst,(v2f64 (movddup VR128:$src, (undef))))]>;
2536 def MOVDDUPrm  : S3DI<0x12, MRMSrcMem, (outs VR128:$dst), (ins f64mem:$src),
2537                       "movddup\t{$src, $dst|$dst, $src}",
2538                     [(set VR128:$dst,
2539                       (v2f64 (movddup (scalar_to_vector (loadf64 addr:$src)),
2540                                       (undef))))]>;
2541
2542 def : Pat<(movddup (bc_v2f64 (v2i64 (scalar_to_vector (loadi64 addr:$src)))),
2543                    (undef)),
2544           (MOVDDUPrm addr:$src)>, Requires<[HasSSE3]>;
2545
2546 let AddedComplexity = 5 in {
2547 def : Pat<(movddup (memopv2f64 addr:$src), (undef)),
2548           (MOVDDUPrm addr:$src)>, Requires<[HasSSE3]>;
2549 def : Pat<(movddup (bc_v4f32 (memopv2f64 addr:$src)), (undef)),
2550           (MOVDDUPrm addr:$src)>, Requires<[HasSSE3]>;
2551 def : Pat<(movddup (memopv2i64 addr:$src), (undef)),
2552           (MOVDDUPrm addr:$src)>, Requires<[HasSSE3]>;
2553 def : Pat<(movddup (bc_v4i32 (memopv2i64 addr:$src)), (undef)),
2554           (MOVDDUPrm addr:$src)>, Requires<[HasSSE3]>;
2555 }
2556
2557 // Arithmetic
2558 let Constraints = "$src1 = $dst" in {
2559   def ADDSUBPSrr : S3DI<0xD0, MRMSrcReg,
2560                         (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2561                         "addsubps\t{$src2, $dst|$dst, $src2}",
2562                         [(set VR128:$dst, (int_x86_sse3_addsub_ps VR128:$src1,
2563                                            VR128:$src2))]>;
2564   def ADDSUBPSrm : S3DI<0xD0, MRMSrcMem,
2565                         (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
2566                         "addsubps\t{$src2, $dst|$dst, $src2}",
2567                         [(set VR128:$dst, (int_x86_sse3_addsub_ps VR128:$src1,
2568                                            (memop addr:$src2)))]>;
2569   def ADDSUBPDrr : S3I<0xD0, MRMSrcReg,
2570                        (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2571                        "addsubpd\t{$src2, $dst|$dst, $src2}",
2572                        [(set VR128:$dst, (int_x86_sse3_addsub_pd VR128:$src1,
2573                                           VR128:$src2))]>;
2574   def ADDSUBPDrm : S3I<0xD0, MRMSrcMem,
2575                        (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
2576                        "addsubpd\t{$src2, $dst|$dst, $src2}",
2577                        [(set VR128:$dst, (int_x86_sse3_addsub_pd VR128:$src1,
2578                                           (memop addr:$src2)))]>;
2579 }
2580
2581 def LDDQUrm : S3DI<0xF0, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
2582                    "lddqu\t{$src, $dst|$dst, $src}",
2583                    [(set VR128:$dst, (int_x86_sse3_ldu_dq addr:$src))]>;
2584
2585 // Horizontal ops
2586 class S3D_Intrr<bits<8> o, string OpcodeStr, Intrinsic IntId>
2587   : S3DI<o, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2588          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2589          [(set VR128:$dst, (v4f32 (IntId VR128:$src1, VR128:$src2)))]>;
2590 class S3D_Intrm<bits<8> o, string OpcodeStr, Intrinsic IntId>
2591   : S3DI<o, MRMSrcMem, (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
2592          !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2593          [(set VR128:$dst, (v4f32 (IntId VR128:$src1, (memop addr:$src2))))]>;
2594 class S3_Intrr<bits<8> o, string OpcodeStr, Intrinsic IntId>
2595   : S3I<o, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
2596         !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2597         [(set VR128:$dst, (v2f64 (IntId VR128:$src1, VR128:$src2)))]>;
2598 class S3_Intrm<bits<8> o, string OpcodeStr, Intrinsic IntId>
2599   : S3I<o, MRMSrcMem, (outs VR128:$dst), (ins VR128:$src1, f128mem:$src2),
2600         !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2601       [(set VR128:$dst, (v2f64 (IntId VR128:$src1, (memopv2f64 addr:$src2))))]>;
2602
2603 let Constraints = "$src1 = $dst" in {
2604   def HADDPSrr : S3D_Intrr<0x7C, "haddps", int_x86_sse3_hadd_ps>;
2605   def HADDPSrm : S3D_Intrm<0x7C, "haddps", int_x86_sse3_hadd_ps>;
2606   def HADDPDrr : S3_Intrr <0x7C, "haddpd", int_x86_sse3_hadd_pd>;
2607   def HADDPDrm : S3_Intrm <0x7C, "haddpd", int_x86_sse3_hadd_pd>;
2608   def HSUBPSrr : S3D_Intrr<0x7D, "hsubps", int_x86_sse3_hsub_ps>;
2609   def HSUBPSrm : S3D_Intrm<0x7D, "hsubps", int_x86_sse3_hsub_ps>;
2610   def HSUBPDrr : S3_Intrr <0x7D, "hsubpd", int_x86_sse3_hsub_pd>;
2611   def HSUBPDrm : S3_Intrm <0x7D, "hsubpd", int_x86_sse3_hsub_pd>;
2612 }
2613
2614 // Thread synchronization
2615 def MONITOR : I<0x01, MRM1r, (outs), (ins), "monitor",
2616                 [(int_x86_sse3_monitor EAX, ECX, EDX)]>,TB, Requires<[HasSSE3]>;
2617 def MWAIT   : I<0x01, MRM1r, (outs), (ins), "mwait",
2618                 [(int_x86_sse3_mwait ECX, EAX)]>, TB, Requires<[HasSSE3]>;
2619
2620 // vector_shuffle v1, <undef> <1, 1, 3, 3>
2621 let AddedComplexity = 15 in
2622 def : Pat<(v4i32 (movshdup VR128:$src, (undef))),
2623           (MOVSHDUPrr VR128:$src)>, Requires<[HasSSE3]>;
2624 let AddedComplexity = 20 in
2625 def : Pat<(v4i32 (movshdup (bc_v4i32 (memopv2i64 addr:$src)), (undef))),
2626           (MOVSHDUPrm addr:$src)>, Requires<[HasSSE3]>;
2627
2628 // vector_shuffle v1, <undef> <0, 0, 2, 2>
2629 let AddedComplexity = 15 in
2630   def : Pat<(v4i32 (movsldup VR128:$src, (undef))),
2631             (MOVSLDUPrr VR128:$src)>, Requires<[HasSSE3]>;
2632 let AddedComplexity = 20 in
2633   def : Pat<(v4i32 (movsldup (bc_v4i32 (memopv2i64 addr:$src)), (undef))),
2634             (MOVSLDUPrm addr:$src)>, Requires<[HasSSE3]>;
2635
2636 //===---------------------------------------------------------------------===//
2637 // SSSE3 Instructions
2638 //===---------------------------------------------------------------------===//
2639
2640 /// SS3I_unop_rm_int_8 - Simple SSSE3 unary operator whose type is v*i8.
2641 multiclass SS3I_unop_rm_int_8<bits<8> opc, string OpcodeStr,
2642                               Intrinsic IntId64, Intrinsic IntId128> {
2643   def rr64 : SS38I<opc, MRMSrcReg, (outs VR64:$dst), (ins VR64:$src),
2644                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2645                    [(set VR64:$dst, (IntId64 VR64:$src))]>;
2646
2647   def rm64 : SS38I<opc, MRMSrcMem, (outs VR64:$dst), (ins i64mem:$src),
2648                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2649                    [(set VR64:$dst,
2650                      (IntId64 (bitconvert (memopv8i8 addr:$src))))]>;
2651
2652   def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
2653                     (ins VR128:$src),
2654                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2655                     [(set VR128:$dst, (IntId128 VR128:$src))]>,
2656                     OpSize;
2657
2658   def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
2659                     (ins i128mem:$src),
2660                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2661                     [(set VR128:$dst,
2662                       (IntId128
2663                        (bitconvert (memopv16i8 addr:$src))))]>, OpSize;
2664 }
2665
2666 /// SS3I_unop_rm_int_16 - Simple SSSE3 unary operator whose type is v*i16.
2667 multiclass SS3I_unop_rm_int_16<bits<8> opc, string OpcodeStr,
2668                                Intrinsic IntId64, Intrinsic IntId128> {
2669   def rr64 : SS38I<opc, MRMSrcReg, (outs VR64:$dst),
2670                    (ins VR64:$src),
2671                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2672                    [(set VR64:$dst, (IntId64 VR64:$src))]>;
2673
2674   def rm64 : SS38I<opc, MRMSrcMem, (outs VR64:$dst),
2675                    (ins i64mem:$src),
2676                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2677                    [(set VR64:$dst,
2678                      (IntId64
2679                       (bitconvert (memopv4i16 addr:$src))))]>;
2680
2681   def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
2682                     (ins VR128:$src),
2683                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2684                     [(set VR128:$dst, (IntId128 VR128:$src))]>,
2685                     OpSize;
2686
2687   def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
2688                     (ins i128mem:$src),
2689                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2690                     [(set VR128:$dst,
2691                       (IntId128
2692                        (bitconvert (memopv8i16 addr:$src))))]>, OpSize;
2693 }
2694
2695 /// SS3I_unop_rm_int_32 - Simple SSSE3 unary operator whose type is v*i32.
2696 multiclass SS3I_unop_rm_int_32<bits<8> opc, string OpcodeStr,
2697                                Intrinsic IntId64, Intrinsic IntId128> {
2698   def rr64 : SS38I<opc, MRMSrcReg, (outs VR64:$dst),
2699                    (ins VR64:$src),
2700                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2701                    [(set VR64:$dst, (IntId64 VR64:$src))]>;
2702
2703   def rm64 : SS38I<opc, MRMSrcMem, (outs VR64:$dst),
2704                    (ins i64mem:$src),
2705                    !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2706                    [(set VR64:$dst,
2707                      (IntId64
2708                       (bitconvert (memopv2i32 addr:$src))))]>;
2709
2710   def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
2711                     (ins VR128:$src),
2712                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2713                     [(set VR128:$dst, (IntId128 VR128:$src))]>,
2714                     OpSize;
2715
2716   def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
2717                     (ins i128mem:$src),
2718                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
2719                     [(set VR128:$dst,
2720                       (IntId128
2721                        (bitconvert (memopv4i32 addr:$src))))]>, OpSize;
2722 }
2723
2724 defm PABSB       : SS3I_unop_rm_int_8 <0x1C, "pabsb",
2725                                        int_x86_ssse3_pabs_b,
2726                                        int_x86_ssse3_pabs_b_128>;
2727 defm PABSW       : SS3I_unop_rm_int_16<0x1D, "pabsw",
2728                                        int_x86_ssse3_pabs_w,
2729                                        int_x86_ssse3_pabs_w_128>;
2730 defm PABSD       : SS3I_unop_rm_int_32<0x1E, "pabsd",
2731                                        int_x86_ssse3_pabs_d,
2732                                        int_x86_ssse3_pabs_d_128>;
2733
2734 /// SS3I_binop_rm_int_8 - Simple SSSE3 binary operator whose type is v*i8.
2735 let Constraints = "$src1 = $dst" in {
2736   multiclass SS3I_binop_rm_int_8<bits<8> opc, string OpcodeStr,
2737                                  Intrinsic IntId64, Intrinsic IntId128,
2738                                  bit Commutable = 0> {
2739     def rr64 : SS38I<opc, MRMSrcReg, (outs VR64:$dst),
2740                      (ins VR64:$src1, VR64:$src2),
2741                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2742                      [(set VR64:$dst, (IntId64 VR64:$src1, VR64:$src2))]> {
2743       let isCommutable = Commutable;
2744     }
2745     def rm64 : SS38I<opc, MRMSrcMem, (outs VR64:$dst),
2746                      (ins VR64:$src1, i64mem:$src2),
2747                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2748                      [(set VR64:$dst,
2749                        (IntId64 VR64:$src1,
2750                         (bitconvert (memopv8i8 addr:$src2))))]>;
2751
2752     def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
2753                       (ins VR128:$src1, VR128:$src2),
2754                       !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2755                       [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
2756                       OpSize {
2757       let isCommutable = Commutable;
2758     }
2759     def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
2760                       (ins VR128:$src1, i128mem:$src2),
2761                       !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2762                       [(set VR128:$dst,
2763                         (IntId128 VR128:$src1,
2764                          (bitconvert (memopv16i8 addr:$src2))))]>, OpSize;
2765   }
2766 }
2767
2768 /// SS3I_binop_rm_int_16 - Simple SSSE3 binary operator whose type is v*i16.
2769 let Constraints = "$src1 = $dst" in {
2770   multiclass SS3I_binop_rm_int_16<bits<8> opc, string OpcodeStr,
2771                                   Intrinsic IntId64, Intrinsic IntId128,
2772                                   bit Commutable = 0> {
2773     def rr64 : SS38I<opc, MRMSrcReg, (outs VR64:$dst),
2774                      (ins VR64:$src1, VR64:$src2),
2775                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2776                      [(set VR64:$dst, (IntId64 VR64:$src1, VR64:$src2))]> {
2777       let isCommutable = Commutable;
2778     }
2779     def rm64 : SS38I<opc, MRMSrcMem, (outs VR64:$dst),
2780                      (ins VR64:$src1, i64mem:$src2),
2781                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2782                      [(set VR64:$dst,
2783                        (IntId64 VR64:$src1,
2784                         (bitconvert (memopv4i16 addr:$src2))))]>;
2785
2786     def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
2787                       (ins VR128:$src1, VR128:$src2),
2788                       !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2789                       [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
2790                       OpSize {
2791       let isCommutable = Commutable;
2792     }
2793     def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
2794                       (ins VR128:$src1, i128mem:$src2),
2795                       !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2796                       [(set VR128:$dst,
2797                         (IntId128 VR128:$src1,
2798                          (bitconvert (memopv8i16 addr:$src2))))]>, OpSize;
2799   }
2800 }
2801
2802 /// SS3I_binop_rm_int_32 - Simple SSSE3 binary operator whose type is v*i32.
2803 let Constraints = "$src1 = $dst" in {
2804   multiclass SS3I_binop_rm_int_32<bits<8> opc, string OpcodeStr,
2805                                   Intrinsic IntId64, Intrinsic IntId128,
2806                                   bit Commutable = 0> {
2807     def rr64 : SS38I<opc, MRMSrcReg, (outs VR64:$dst),
2808                      (ins VR64:$src1, VR64:$src2),
2809                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2810                      [(set VR64:$dst, (IntId64 VR64:$src1, VR64:$src2))]> {
2811       let isCommutable = Commutable;
2812     }
2813     def rm64 : SS38I<opc, MRMSrcMem, (outs VR64:$dst),
2814                      (ins VR64:$src1, i64mem:$src2),
2815                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2816                      [(set VR64:$dst,
2817                        (IntId64 VR64:$src1,
2818                         (bitconvert (memopv2i32 addr:$src2))))]>;
2819
2820     def rr128 : SS38I<opc, MRMSrcReg, (outs VR128:$dst),
2821                       (ins VR128:$src1, VR128:$src2),
2822                       !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2823                       [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
2824                       OpSize {
2825       let isCommutable = Commutable;
2826     }
2827     def rm128 : SS38I<opc, MRMSrcMem, (outs VR128:$dst),
2828                       (ins VR128:$src1, i128mem:$src2),
2829                       !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
2830                       [(set VR128:$dst,
2831                         (IntId128 VR128:$src1,
2832                          (bitconvert (memopv4i32 addr:$src2))))]>, OpSize;
2833   }
2834 }
2835
2836 defm PHADDW      : SS3I_binop_rm_int_16<0x01, "phaddw",
2837                                         int_x86_ssse3_phadd_w,
2838                                         int_x86_ssse3_phadd_w_128>;
2839 defm PHADDD      : SS3I_binop_rm_int_32<0x02, "phaddd",
2840                                         int_x86_ssse3_phadd_d,
2841                                         int_x86_ssse3_phadd_d_128>;
2842 defm PHADDSW     : SS3I_binop_rm_int_16<0x03, "phaddsw",
2843                                         int_x86_ssse3_phadd_sw,
2844                                         int_x86_ssse3_phadd_sw_128>;
2845 defm PHSUBW      : SS3I_binop_rm_int_16<0x05, "phsubw",
2846                                         int_x86_ssse3_phsub_w,
2847                                         int_x86_ssse3_phsub_w_128>;
2848 defm PHSUBD      : SS3I_binop_rm_int_32<0x06, "phsubd",
2849                                         int_x86_ssse3_phsub_d,
2850                                         int_x86_ssse3_phsub_d_128>;
2851 defm PHSUBSW     : SS3I_binop_rm_int_16<0x07, "phsubsw",
2852                                         int_x86_ssse3_phsub_sw,
2853                                         int_x86_ssse3_phsub_sw_128>;
2854 defm PMADDUBSW   : SS3I_binop_rm_int_8 <0x04, "pmaddubsw",
2855                                         int_x86_ssse3_pmadd_ub_sw,
2856                                         int_x86_ssse3_pmadd_ub_sw_128>;
2857 defm PMULHRSW    : SS3I_binop_rm_int_16<0x0B, "pmulhrsw",
2858                                         int_x86_ssse3_pmul_hr_sw,
2859                                         int_x86_ssse3_pmul_hr_sw_128, 1>;
2860 defm PSHUFB      : SS3I_binop_rm_int_8 <0x00, "pshufb",
2861                                         int_x86_ssse3_pshuf_b,
2862                                         int_x86_ssse3_pshuf_b_128>;
2863 defm PSIGNB      : SS3I_binop_rm_int_8 <0x08, "psignb",
2864                                         int_x86_ssse3_psign_b,
2865                                         int_x86_ssse3_psign_b_128>;
2866 defm PSIGNW      : SS3I_binop_rm_int_16<0x09, "psignw",
2867                                         int_x86_ssse3_psign_w,
2868                                         int_x86_ssse3_psign_w_128>;
2869 defm PSIGND      : SS3I_binop_rm_int_32<0x0A, "psignd",
2870                                         int_x86_ssse3_psign_d,
2871                                         int_x86_ssse3_psign_d_128>;
2872
2873 let Constraints = "$src1 = $dst" in {
2874   def PALIGNR64rr  : SS3AI<0x0F, MRMSrcReg, (outs VR64:$dst),
2875                            (ins VR64:$src1, VR64:$src2, i8imm:$src3),
2876                            "palignr\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2877                            []>;
2878   def PALIGNR64rm  : SS3AI<0x0F, MRMSrcMem, (outs VR64:$dst),
2879                            (ins VR64:$src1, i64mem:$src2, i8imm:$src3),
2880                            "palignr\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2881                            []>;
2882
2883   def PALIGNR128rr : SS3AI<0x0F, MRMSrcReg, (outs VR128:$dst),
2884                            (ins VR128:$src1, VR128:$src2, i8imm:$src3),
2885                            "palignr\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2886                            []>, OpSize;
2887   def PALIGNR128rm : SS3AI<0x0F, MRMSrcMem, (outs VR128:$dst),
2888                            (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
2889                            "palignr\t{$src3, $src2, $dst|$dst, $src2, $src3}",
2890                            []>, OpSize;
2891 }
2892
2893 // palignr patterns.
2894 def : Pat<(int_x86_ssse3_palign_r VR64:$src1, VR64:$src2, (i8 imm:$src3)),
2895           (PALIGNR64rr VR64:$src1, VR64:$src2, (BYTE_imm imm:$src3))>,
2896           Requires<[HasSSSE3]>;
2897 def : Pat<(int_x86_ssse3_palign_r VR64:$src1,
2898                                       (memop64 addr:$src2),
2899                                       (i8 imm:$src3)),
2900           (PALIGNR64rm VR64:$src1, addr:$src2, (BYTE_imm imm:$src3))>,
2901           Requires<[HasSSSE3]>;
2902
2903 def : Pat<(int_x86_ssse3_palign_r_128 VR128:$src1, VR128:$src2, (i8 imm:$src3)),
2904           (PALIGNR128rr VR128:$src1, VR128:$src2, (BYTE_imm imm:$src3))>,
2905           Requires<[HasSSSE3]>;
2906 def : Pat<(int_x86_ssse3_palign_r_128 VR128:$src1,
2907                                       (memopv2i64 addr:$src2),
2908                                       (i8 imm:$src3)),
2909           (PALIGNR128rm VR128:$src1, addr:$src2, (BYTE_imm imm:$src3))>,
2910           Requires<[HasSSSE3]>;
2911
2912 let AddedComplexity = 5 in {
2913 def : Pat<(v4i32 (palign:$src3 VR128:$src1, VR128:$src2)),
2914           (PALIGNR128rr VR128:$src2, VR128:$src1,
2915                         (SHUFFLE_get_palign_imm VR128:$src3))>,
2916       Requires<[HasSSSE3]>;
2917 def : Pat<(v4f32 (palign:$src3 VR128:$src1, VR128:$src2)),
2918           (PALIGNR128rr VR128:$src2, VR128:$src1,
2919                         (SHUFFLE_get_palign_imm VR128:$src3))>,
2920       Requires<[HasSSSE3]>;
2921 def : Pat<(v8i16 (palign:$src3 VR128:$src1, VR128:$src2)),
2922           (PALIGNR128rr VR128:$src2, VR128:$src1,
2923                         (SHUFFLE_get_palign_imm VR128:$src3))>,
2924       Requires<[HasSSSE3]>;
2925 def : Pat<(v16i8 (palign:$src3 VR128:$src1, VR128:$src2)),
2926           (PALIGNR128rr VR128:$src2, VR128:$src1,
2927                         (SHUFFLE_get_palign_imm VR128:$src3))>,
2928       Requires<[HasSSSE3]>;
2929 }
2930
2931 def : Pat<(X86pshufb VR128:$src, VR128:$mask),
2932           (PSHUFBrr128 VR128:$src, VR128:$mask)>, Requires<[HasSSSE3]>;
2933 def : Pat<(X86pshufb VR128:$src, (bc_v16i8 (memopv2i64 addr:$mask))),
2934           (PSHUFBrm128 VR128:$src, addr:$mask)>, Requires<[HasSSSE3]>;
2935
2936 //===---------------------------------------------------------------------===//
2937 // Non-Instruction Patterns
2938 //===---------------------------------------------------------------------===//
2939
2940 // extload f32 -> f64.  This matches load+fextend because we have a hack in
2941 // the isel (PreprocessForFPConvert) that can introduce loads after dag
2942 // combine.
2943 // Since these loads aren't folded into the fextend, we have to match it
2944 // explicitly here.
2945 let Predicates = [HasSSE2] in
2946  def : Pat<(fextend (loadf32 addr:$src)),
2947            (CVTSS2SDrm addr:$src)>;
2948
2949 // bit_convert
2950 let Predicates = [HasSSE2] in {
2951   def : Pat<(v2i64 (bitconvert (v4i32 VR128:$src))), (v2i64 VR128:$src)>;
2952   def : Pat<(v2i64 (bitconvert (v8i16 VR128:$src))), (v2i64 VR128:$src)>;
2953   def : Pat<(v2i64 (bitconvert (v16i8 VR128:$src))), (v2i64 VR128:$src)>;
2954   def : Pat<(v2i64 (bitconvert (v2f64 VR128:$src))), (v2i64 VR128:$src)>;
2955   def : Pat<(v2i64 (bitconvert (v4f32 VR128:$src))), (v2i64 VR128:$src)>;
2956   def : Pat<(v4i32 (bitconvert (v2i64 VR128:$src))), (v4i32 VR128:$src)>;
2957   def : Pat<(v4i32 (bitconvert (v8i16 VR128:$src))), (v4i32 VR128:$src)>;
2958   def : Pat<(v4i32 (bitconvert (v16i8 VR128:$src))), (v4i32 VR128:$src)>;
2959   def : Pat<(v4i32 (bitconvert (v2f64 VR128:$src))), (v4i32 VR128:$src)>;
2960   def : Pat<(v4i32 (bitconvert (v4f32 VR128:$src))), (v4i32 VR128:$src)>;
2961   def : Pat<(v8i16 (bitconvert (v2i64 VR128:$src))), (v8i16 VR128:$src)>;
2962   def : Pat<(v8i16 (bitconvert (v4i32 VR128:$src))), (v8i16 VR128:$src)>;
2963   def : Pat<(v8i16 (bitconvert (v16i8 VR128:$src))), (v8i16 VR128:$src)>;
2964   def : Pat<(v8i16 (bitconvert (v2f64 VR128:$src))), (v8i16 VR128:$src)>;
2965   def : Pat<(v8i16 (bitconvert (v4f32 VR128:$src))), (v8i16 VR128:$src)>;
2966   def : Pat<(v16i8 (bitconvert (v2i64 VR128:$src))), (v16i8 VR128:$src)>;
2967   def : Pat<(v16i8 (bitconvert (v4i32 VR128:$src))), (v16i8 VR128:$src)>;
2968   def : Pat<(v16i8 (bitconvert (v8i16 VR128:$src))), (v16i8 VR128:$src)>;
2969   def : Pat<(v16i8 (bitconvert (v2f64 VR128:$src))), (v16i8 VR128:$src)>;
2970   def : Pat<(v16i8 (bitconvert (v4f32 VR128:$src))), (v16i8 VR128:$src)>;
2971   def : Pat<(v4f32 (bitconvert (v2i64 VR128:$src))), (v4f32 VR128:$src)>;
2972   def : Pat<(v4f32 (bitconvert (v4i32 VR128:$src))), (v4f32 VR128:$src)>;
2973   def : Pat<(v4f32 (bitconvert (v8i16 VR128:$src))), (v4f32 VR128:$src)>;
2974   def : Pat<(v4f32 (bitconvert (v16i8 VR128:$src))), (v4f32 VR128:$src)>;
2975   def : Pat<(v4f32 (bitconvert (v2f64 VR128:$src))), (v4f32 VR128:$src)>;
2976   def : Pat<(v2f64 (bitconvert (v2i64 VR128:$src))), (v2f64 VR128:$src)>;
2977   def : Pat<(v2f64 (bitconvert (v4i32 VR128:$src))), (v2f64 VR128:$src)>;
2978   def : Pat<(v2f64 (bitconvert (v8i16 VR128:$src))), (v2f64 VR128:$src)>;
2979   def : Pat<(v2f64 (bitconvert (v16i8 VR128:$src))), (v2f64 VR128:$src)>;
2980   def : Pat<(v2f64 (bitconvert (v4f32 VR128:$src))), (v2f64 VR128:$src)>;
2981 }
2982
2983 // Move scalar to XMM zero-extended
2984 // movd to XMM register zero-extends
2985 let AddedComplexity = 15 in {
2986 // Zeroing a VR128 then do a MOVS{S|D} to the lower bits.
2987 def : Pat<(v2f64 (X86vzmovl (v2f64 (scalar_to_vector FR64:$src)))),
2988           (MOVLSD2PDrr (V_SET0), FR64:$src)>, Requires<[HasSSE2]>;
2989 def : Pat<(v4f32 (X86vzmovl (v4f32 (scalar_to_vector FR32:$src)))),
2990           (MOVLSS2PSrr (V_SET0), FR32:$src)>, Requires<[HasSSE1]>;
2991 def : Pat<(v4f32 (X86vzmovl (v4f32 VR128:$src))),
2992           (MOVLPSrr (V_SET0), VR128:$src)>, Requires<[HasSSE1]>;
2993 def : Pat<(v4i32 (X86vzmovl (v4i32 VR128:$src))),
2994           (MOVLPSrr (V_SET0), VR128:$src)>, Requires<[HasSSE1]>;
2995 }
2996
2997 // Splat v2f64 / v2i64
2998 let AddedComplexity = 10 in {
2999 def : Pat<(splat_lo (v2f64 VR128:$src), (undef)),
3000           (UNPCKLPDrr VR128:$src, VR128:$src)>,   Requires<[HasSSE2]>;
3001 def : Pat<(unpckh (v2f64 VR128:$src), (undef)),
3002           (UNPCKHPDrr VR128:$src, VR128:$src)>,   Requires<[HasSSE2]>;
3003 def : Pat<(splat_lo (v2i64 VR128:$src), (undef)),
3004           (PUNPCKLQDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3005 def : Pat<(unpckh (v2i64 VR128:$src), (undef)),
3006           (PUNPCKHQDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3007 }
3008
3009 // Special unary SHUFPSrri case.
3010 def : Pat<(v4f32 (pshufd:$src3 VR128:$src1, (undef))),
3011           (SHUFPSrri VR128:$src1, VR128:$src1,
3012                      (SHUFFLE_get_shuf_imm VR128:$src3))>,
3013       Requires<[HasSSE1]>;
3014 let AddedComplexity = 5 in
3015 def : Pat<(v4f32 (pshufd:$src2 VR128:$src1, (undef))),
3016           (PSHUFDri VR128:$src1, (SHUFFLE_get_shuf_imm VR128:$src2))>,
3017       Requires<[HasSSE2]>;
3018 // Special unary SHUFPDrri case.
3019 def : Pat<(v2i64 (pshufd:$src3 VR128:$src1, (undef))),
3020           (SHUFPDrri VR128:$src1, VR128:$src1,
3021                      (SHUFFLE_get_shuf_imm VR128:$src3))>,
3022       Requires<[HasSSE2]>;
3023 // Special unary SHUFPDrri case.
3024 def : Pat<(v2f64 (pshufd:$src3 VR128:$src1, (undef))),
3025           (SHUFPDrri VR128:$src1, VR128:$src1,
3026                      (SHUFFLE_get_shuf_imm VR128:$src3))>,
3027       Requires<[HasSSE2]>;
3028 // Unary v4f32 shuffle with PSHUF* in order to fold a load.
3029 def : Pat<(pshufd:$src2 (bc_v4i32 (memopv4f32 addr:$src1)), (undef)),
3030           (PSHUFDmi addr:$src1, (SHUFFLE_get_shuf_imm VR128:$src2))>,
3031       Requires<[HasSSE2]>;
3032
3033 // Special binary v4i32 shuffle cases with SHUFPS.
3034 def : Pat<(v4i32 (shufp:$src3 VR128:$src1, (v4i32 VR128:$src2))),
3035           (SHUFPSrri VR128:$src1, VR128:$src2,
3036                      (SHUFFLE_get_shuf_imm VR128:$src3))>,
3037            Requires<[HasSSE2]>;
3038 def : Pat<(v4i32 (shufp:$src3 VR128:$src1, (bc_v4i32 (memopv2i64 addr:$src2)))),
3039           (SHUFPSrmi VR128:$src1, addr:$src2,
3040                     (SHUFFLE_get_shuf_imm VR128:$src3))>,
3041            Requires<[HasSSE2]>;
3042 // Special binary v2i64 shuffle cases using SHUFPDrri.
3043 def : Pat<(v2i64 (shufp:$src3 VR128:$src1, VR128:$src2)),
3044           (SHUFPDrri VR128:$src1, VR128:$src2,
3045                      (SHUFFLE_get_shuf_imm VR128:$src3))>,
3046           Requires<[HasSSE2]>;
3047
3048 // vector_shuffle v1, <undef>, <0, 0, 1, 1, ...>
3049 let AddedComplexity = 15 in {
3050 def : Pat<(v4i32 (unpckl_undef:$src2 VR128:$src, (undef))),
3051           (PSHUFDri VR128:$src, (SHUFFLE_get_shuf_imm VR128:$src2))>,
3052           Requires<[OptForSpeed, HasSSE2]>;
3053 def : Pat<(v4f32 (unpckl_undef:$src2 VR128:$src, (undef))),
3054           (PSHUFDri VR128:$src, (SHUFFLE_get_shuf_imm VR128:$src2))>,
3055           Requires<[OptForSpeed, HasSSE2]>;
3056 }
3057 let AddedComplexity = 10 in {
3058 def : Pat<(v4f32 (unpckl_undef VR128:$src, (undef))),
3059           (UNPCKLPSrr VR128:$src, VR128:$src)>, Requires<[HasSSE1]>;
3060 def : Pat<(v16i8 (unpckl_undef VR128:$src, (undef))),
3061           (PUNPCKLBWrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3062 def : Pat<(v8i16 (unpckl_undef VR128:$src, (undef))),
3063           (PUNPCKLWDrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3064 def : Pat<(v4i32 (unpckl_undef VR128:$src, (undef))),
3065           (PUNPCKLDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3066 }
3067
3068 // vector_shuffle v1, <undef>, <2, 2, 3, 3, ...>
3069 let AddedComplexity = 15 in {
3070 def : Pat<(v4i32 (unpckh_undef:$src2 VR128:$src, (undef))),
3071           (PSHUFDri VR128:$src, (SHUFFLE_get_shuf_imm VR128:$src2))>,
3072           Requires<[OptForSpeed, HasSSE2]>;
3073 def : Pat<(v4f32 (unpckh_undef:$src2 VR128:$src, (undef))),
3074           (PSHUFDri VR128:$src, (SHUFFLE_get_shuf_imm VR128:$src2))>,
3075           Requires<[OptForSpeed, HasSSE2]>;
3076 }
3077 let AddedComplexity = 10 in {
3078 def : Pat<(v4f32 (unpckh_undef VR128:$src, (undef))),
3079           (UNPCKHPSrr VR128:$src, VR128:$src)>, Requires<[HasSSE1]>;
3080 def : Pat<(v16i8 (unpckh_undef VR128:$src, (undef))),
3081           (PUNPCKHBWrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3082 def : Pat<(v8i16 (unpckh_undef VR128:$src, (undef))),
3083           (PUNPCKHWDrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3084 def : Pat<(v4i32 (unpckh_undef VR128:$src, (undef))),
3085           (PUNPCKHDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
3086 }
3087
3088 let AddedComplexity = 20 in {
3089 // vector_shuffle v1, v2 <0, 1, 4, 5> using MOVLHPS
3090 def : Pat<(v4i32 (movlhps VR128:$src1, VR128:$src2)),
3091           (MOVLHPSrr VR128:$src1, VR128:$src2)>;
3092
3093 // vector_shuffle v1, v2 <6, 7, 2, 3> using MOVHLPS
3094 def : Pat<(v4i32 (movhlps VR128:$src1, VR128:$src2)),
3095           (MOVHLPSrr VR128:$src1, VR128:$src2)>;
3096
3097 // vector_shuffle v1, undef <2, ?, ?, ?> using MOVHLPS
3098 def : Pat<(v4f32 (movhlps_undef VR128:$src1, (undef))),
3099           (MOVHLPSrr VR128:$src1, VR128:$src1)>;
3100 def : Pat<(v4i32 (movhlps_undef VR128:$src1, (undef))),
3101           (MOVHLPSrr VR128:$src1, VR128:$src1)>;
3102 }
3103
3104 let AddedComplexity = 20 in {
3105 // vector_shuffle v1, (load v2) <4, 5, 2, 3> using MOVLPS
3106 def : Pat<(v4f32 (movlp VR128:$src1, (load addr:$src2))),
3107           (MOVLPSrm VR128:$src1, addr:$src2)>, Requires<[HasSSE1]>;
3108 def : Pat<(v2f64 (movlp VR128:$src1, (load addr:$src2))),
3109           (MOVLPDrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
3110 def : Pat<(v4i32 (movlp VR128:$src1, (load addr:$src2))),
3111           (MOVLPSrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
3112 def : Pat<(v2i64 (movlp VR128:$src1, (load addr:$src2))),
3113           (MOVLPDrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
3114 }
3115
3116 // (store (vector_shuffle (load addr), v2, <4, 5, 2, 3>), addr) using MOVLPS
3117 def : Pat<(store (v4f32 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
3118           (MOVLPSmr addr:$src1, VR128:$src2)>, Requires<[HasSSE1]>;
3119 def : Pat<(store (v2f64 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
3120           (MOVLPDmr addr:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3121 def : Pat<(store (v4i32 (movlp (bc_v4i32 (loadv2i64 addr:$src1)), VR128:$src2)),
3122                  addr:$src1),
3123           (MOVLPSmr addr:$src1, VR128:$src2)>, Requires<[HasSSE1]>;
3124 def : Pat<(store (v2i64 (movlp (load addr:$src1), VR128:$src2)), addr:$src1),
3125           (MOVLPDmr addr:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3126
3127 let AddedComplexity = 15 in {
3128 // Setting the lowest element in the vector.
3129 def : Pat<(v4i32 (movl VR128:$src1, VR128:$src2)),
3130           (MOVLPSrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3131 def : Pat<(v2i64 (movl VR128:$src1, VR128:$src2)),
3132           (MOVLPDrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3133
3134 // vector_shuffle v1, v2 <4, 5, 2, 3> using MOVLPDrr (movsd)
3135 def : Pat<(v4f32 (movlp VR128:$src1, VR128:$src2)),
3136           (MOVLPDrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3137 def : Pat<(v4i32 (movlp VR128:$src1, VR128:$src2)),
3138           (MOVLPDrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3139 }
3140
3141 // vector_shuffle v1, v2 <4, 5, 2, 3> using SHUFPSrri (we prefer movsd, but
3142 // fall back to this for SSE1)
3143 def : Pat<(v4f32 (movlp:$src3 VR128:$src1, (v4f32 VR128:$src2))),
3144           (SHUFPSrri VR128:$src2, VR128:$src1,
3145                      (SHUFFLE_get_shuf_imm VR128:$src3))>, Requires<[HasSSE1]>;
3146
3147 // Set lowest element and zero upper elements.
3148 let AddedComplexity = 15 in
3149 def : Pat<(v2f64 (movl immAllZerosV_bc, VR128:$src)),
3150           (MOVZPQILo2PQIrr VR128:$src)>, Requires<[HasSSE2]>;
3151 def : Pat<(v2f64 (X86vzmovl (v2f64 VR128:$src))),
3152           (MOVZPQILo2PQIrr VR128:$src)>, Requires<[HasSSE2]>;
3153
3154 // Some special case pandn patterns.
3155 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v4i32 immAllOnesV))),
3156                   VR128:$src2)),
3157           (PANDNrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3158 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v8i16 immAllOnesV))),
3159                   VR128:$src2)),
3160           (PANDNrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3161 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v16i8 immAllOnesV))),
3162                   VR128:$src2)),
3163           (PANDNrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
3164
3165 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v4i32 immAllOnesV))),
3166                   (memop addr:$src2))),
3167           (PANDNrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
3168 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v8i16 immAllOnesV))),
3169                   (memop addr:$src2))),
3170           (PANDNrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
3171 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v16i8 immAllOnesV))),
3172                   (memop addr:$src2))),
3173           (PANDNrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
3174
3175 // vector -> vector casts
3176 def : Pat<(v4f32 (sint_to_fp (v4i32 VR128:$src))),
3177           (Int_CVTDQ2PSrr VR128:$src)>, Requires<[HasSSE2]>;
3178 def : Pat<(v4i32 (fp_to_sint (v4f32 VR128:$src))),
3179           (Int_CVTTPS2DQrr VR128:$src)>, Requires<[HasSSE2]>;
3180 def : Pat<(v2f64 (sint_to_fp (v2i32 VR64:$src))),
3181           (Int_CVTPI2PDrr VR64:$src)>, Requires<[HasSSE2]>;
3182 def : Pat<(v2i32 (fp_to_sint (v2f64 VR128:$src))),
3183           (Int_CVTTPD2PIrr VR128:$src)>, Requires<[HasSSE2]>;
3184
3185 // Use movaps / movups for SSE integer load / store (one byte shorter).
3186 def : Pat<(alignedloadv4i32 addr:$src),
3187           (MOVAPSrm addr:$src)>, Requires<[HasSSE1]>;
3188 def : Pat<(loadv4i32 addr:$src),
3189           (MOVUPSrm addr:$src)>, Requires<[HasSSE1]>;
3190 def : Pat<(alignedloadv2i64 addr:$src),
3191           (MOVAPSrm addr:$src)>, Requires<[HasSSE2]>;
3192 def : Pat<(loadv2i64 addr:$src),
3193           (MOVUPSrm addr:$src)>, Requires<[HasSSE2]>;
3194
3195 def : Pat<(alignedstore (v2i64 VR128:$src), addr:$dst),
3196           (MOVAPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3197 def : Pat<(alignedstore (v4i32 VR128:$src), addr:$dst),
3198           (MOVAPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3199 def : Pat<(alignedstore (v8i16 VR128:$src), addr:$dst),
3200           (MOVAPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3201 def : Pat<(alignedstore (v16i8 VR128:$src), addr:$dst),
3202           (MOVAPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3203 def : Pat<(store (v2i64 VR128:$src), addr:$dst),
3204           (MOVUPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3205 def : Pat<(store (v4i32 VR128:$src), addr:$dst),
3206           (MOVUPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3207 def : Pat<(store (v8i16 VR128:$src), addr:$dst),
3208           (MOVUPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3209 def : Pat<(store (v16i8 VR128:$src), addr:$dst),
3210           (MOVUPSmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
3211
3212 //===----------------------------------------------------------------------===//
3213 // SSE4.1 Instructions
3214 //===----------------------------------------------------------------------===//
3215
3216 multiclass sse41_fp_unop_rm<bits<8> opcps, bits<8> opcpd,
3217                             string OpcodeStr,
3218                             Intrinsic V4F32Int,
3219                             Intrinsic V2F64Int> {
3220   // Intrinsic operation, reg.
3221   // Vector intrinsic operation, reg
3222   def PSr_Int : SS4AIi8<opcps, MRMSrcReg,
3223                     (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
3224                     !strconcat(OpcodeStr,
3225                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3226                     [(set VR128:$dst, (V4F32Int VR128:$src1, imm:$src2))]>,
3227                     OpSize;
3228
3229   // Vector intrinsic operation, mem
3230   def PSm_Int : Ii8<opcps, MRMSrcMem,
3231                     (outs VR128:$dst), (ins f128mem:$src1, i32i8imm:$src2),
3232                     !strconcat(OpcodeStr,
3233                     "ps\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3234                     [(set VR128:$dst,
3235                           (V4F32Int (memopv4f32 addr:$src1),imm:$src2))]>,
3236                     TA, OpSize,
3237                 Requires<[HasSSE41]>;
3238
3239   // Vector intrinsic operation, reg
3240   def PDr_Int : SS4AIi8<opcpd, MRMSrcReg,
3241                     (outs VR128:$dst), (ins VR128:$src1, i32i8imm:$src2),
3242                     !strconcat(OpcodeStr,
3243                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3244                     [(set VR128:$dst, (V2F64Int VR128:$src1, imm:$src2))]>,
3245                     OpSize;
3246
3247   // Vector intrinsic operation, mem
3248   def PDm_Int : SS4AIi8<opcpd, MRMSrcMem,
3249                     (outs VR128:$dst), (ins f128mem:$src1, i32i8imm:$src2),
3250                     !strconcat(OpcodeStr,
3251                     "pd\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3252                     [(set VR128:$dst,
3253                           (V2F64Int (memopv2f64 addr:$src1),imm:$src2))]>,
3254                     OpSize;
3255 }
3256
3257 let Constraints = "$src1 = $dst" in {
3258 multiclass sse41_fp_binop_rm<bits<8> opcss, bits<8> opcsd,
3259                             string OpcodeStr,
3260                             Intrinsic F32Int,
3261                             Intrinsic F64Int> {
3262   // Intrinsic operation, reg.
3263   def SSr_Int : SS4AIi8<opcss, MRMSrcReg,
3264                     (outs VR128:$dst),
3265                                  (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
3266                     !strconcat(OpcodeStr,
3267                     "ss\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3268                     [(set VR128:$dst,
3269                             (F32Int VR128:$src1, VR128:$src2, imm:$src3))]>,
3270                     OpSize;
3271
3272   // Intrinsic operation, mem.
3273   def SSm_Int : SS4AIi8<opcss, MRMSrcMem,
3274                     (outs VR128:$dst),
3275                                 (ins VR128:$src1, ssmem:$src2, i32i8imm:$src3),
3276                     !strconcat(OpcodeStr,
3277                     "ss\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3278                     [(set VR128:$dst,
3279                          (F32Int VR128:$src1, sse_load_f32:$src2, imm:$src3))]>,
3280                     OpSize;
3281
3282   // Intrinsic operation, reg.
3283   def SDr_Int : SS4AIi8<opcsd, MRMSrcReg,
3284                     (outs VR128:$dst),
3285                             (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
3286                     !strconcat(OpcodeStr,
3287                     "sd\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3288                     [(set VR128:$dst,
3289                             (F64Int VR128:$src1, VR128:$src2, imm:$src3))]>,
3290                     OpSize;
3291
3292   // Intrinsic operation, mem.
3293   def SDm_Int : SS4AIi8<opcsd, MRMSrcMem,
3294                     (outs VR128:$dst),
3295                             (ins VR128:$src1, sdmem:$src2, i32i8imm:$src3),
3296                     !strconcat(OpcodeStr,
3297                     "sd\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3298                     [(set VR128:$dst,
3299                         (F64Int VR128:$src1, sse_load_f64:$src2, imm:$src3))]>,
3300                     OpSize;
3301 }
3302 }
3303
3304 // FP round - roundss, roundps, roundsd, roundpd
3305 defm ROUND  : sse41_fp_unop_rm<0x08, 0x09, "round",
3306                                int_x86_sse41_round_ps, int_x86_sse41_round_pd>;
3307 defm ROUND  : sse41_fp_binop_rm<0x0A, 0x0B, "round",
3308                                int_x86_sse41_round_ss, int_x86_sse41_round_sd>;
3309
3310 // SS41I_unop_rm_int_v16 - SSE 4.1 unary operator whose type is v8i16.
3311 multiclass SS41I_unop_rm_int_v16<bits<8> opc, string OpcodeStr,
3312                                  Intrinsic IntId128> {
3313   def rr128 : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
3314                     (ins VR128:$src),
3315                     !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3316                     [(set VR128:$dst, (IntId128 VR128:$src))]>, OpSize;
3317   def rm128 : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
3318                      (ins i128mem:$src),
3319                      !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3320                      [(set VR128:$dst,
3321                        (IntId128
3322                        (bitconvert (memopv8i16 addr:$src))))]>, OpSize;
3323 }
3324
3325 defm PHMINPOSUW : SS41I_unop_rm_int_v16 <0x41, "phminposuw",
3326                                          int_x86_sse41_phminposuw>;
3327
3328 /// SS41I_binop_rm_int - Simple SSE 4.1 binary operator
3329 let Constraints = "$src1 = $dst" in {
3330   multiclass SS41I_binop_rm_int<bits<8> opc, string OpcodeStr,
3331                                 Intrinsic IntId128, bit Commutable = 0> {
3332     def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
3333                    (ins VR128:$src1, VR128:$src2),
3334                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3335                    [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
3336                    OpSize {
3337       let isCommutable = Commutable;
3338     }
3339     def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
3340                    (ins VR128:$src1, i128mem:$src2),
3341                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3342                    [(set VR128:$dst,
3343                      (IntId128 VR128:$src1,
3344                       (bitconvert (memopv16i8 addr:$src2))))]>, OpSize;
3345   }
3346 }
3347
3348 defm PCMPEQQ      : SS41I_binop_rm_int<0x29, "pcmpeqq",
3349                                        int_x86_sse41_pcmpeqq, 1>;
3350 defm PACKUSDW     : SS41I_binop_rm_int<0x2B, "packusdw",
3351                                        int_x86_sse41_packusdw, 0>;
3352 defm PMINSB       : SS41I_binop_rm_int<0x38, "pminsb",
3353                                        int_x86_sse41_pminsb, 1>;
3354 defm PMINSD       : SS41I_binop_rm_int<0x39, "pminsd",
3355                                        int_x86_sse41_pminsd, 1>;
3356 defm PMINUD       : SS41I_binop_rm_int<0x3B, "pminud",
3357                                        int_x86_sse41_pminud, 1>;
3358 defm PMINUW       : SS41I_binop_rm_int<0x3A, "pminuw",
3359                                        int_x86_sse41_pminuw, 1>;
3360 defm PMAXSB       : SS41I_binop_rm_int<0x3C, "pmaxsb",
3361                                        int_x86_sse41_pmaxsb, 1>;
3362 defm PMAXSD       : SS41I_binop_rm_int<0x3D, "pmaxsd",
3363                                        int_x86_sse41_pmaxsd, 1>;
3364 defm PMAXUD       : SS41I_binop_rm_int<0x3F, "pmaxud",
3365                                        int_x86_sse41_pmaxud, 1>;
3366 defm PMAXUW       : SS41I_binop_rm_int<0x3E, "pmaxuw",
3367                                        int_x86_sse41_pmaxuw, 1>;
3368
3369 defm PMULDQ       : SS41I_binop_rm_int<0x28, "pmuldq", int_x86_sse41_pmuldq, 1>;
3370
3371 def : Pat<(v2i64 (X86pcmpeqq VR128:$src1, VR128:$src2)),
3372           (PCMPEQQrr VR128:$src1, VR128:$src2)>;
3373 def : Pat<(v2i64 (X86pcmpeqq VR128:$src1, (memop addr:$src2))),
3374           (PCMPEQQrm VR128:$src1, addr:$src2)>;
3375
3376 /// SS41I_binop_rm_int - Simple SSE 4.1 binary operator
3377 let Constraints = "$src1 = $dst" in {
3378   multiclass SS41I_binop_patint<bits<8> opc, string OpcodeStr, ValueType OpVT,
3379                                 SDNode OpNode, Intrinsic IntId128,
3380                                 bit Commutable = 0> {
3381     def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
3382                    (ins VR128:$src1, VR128:$src2),
3383                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3384                    [(set VR128:$dst, (OpNode (OpVT VR128:$src1),
3385                                                    VR128:$src2))]>, OpSize {
3386       let isCommutable = Commutable;
3387     }
3388     def rr_int : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
3389                       (ins VR128:$src1, VR128:$src2),
3390                       !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3391                       [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
3392                       OpSize {
3393       let isCommutable = Commutable;
3394     }
3395     def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
3396                    (ins VR128:$src1, i128mem:$src2),
3397                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3398                    [(set VR128:$dst,
3399                      (OpNode VR128:$src1, (memop addr:$src2)))]>, OpSize;
3400     def rm_int : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
3401                        (ins VR128:$src1, i128mem:$src2),
3402                        !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3403                        [(set VR128:$dst,
3404                         (IntId128 VR128:$src1, (memop addr:$src2)))]>,
3405                        OpSize;
3406   }
3407 }
3408 defm PMULLD       : SS41I_binop_patint<0x40, "pmulld", v4i32, mul,
3409                                        int_x86_sse41_pmulld, 1>;
3410
3411 /// SS41I_binop_rmi_int - SSE 4.1 binary operator with 8-bit immediate
3412 let Constraints = "$src1 = $dst" in {
3413   multiclass SS41I_binop_rmi_int<bits<8> opc, string OpcodeStr,
3414                                  Intrinsic IntId128, bit Commutable = 0> {
3415     def rri : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
3416                     (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
3417                     !strconcat(OpcodeStr,
3418                      "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3419                     [(set VR128:$dst,
3420                       (IntId128 VR128:$src1, VR128:$src2, imm:$src3))]>,
3421                     OpSize {
3422       let isCommutable = Commutable;
3423     }
3424     def rmi : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
3425                     (ins VR128:$src1, i128mem:$src2, i32i8imm:$src3),
3426                     !strconcat(OpcodeStr,
3427                      "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3428                     [(set VR128:$dst,
3429                       (IntId128 VR128:$src1,
3430                        (bitconvert (memopv16i8 addr:$src2)), imm:$src3))]>,
3431                     OpSize;
3432   }
3433 }
3434
3435 defm BLENDPS      : SS41I_binop_rmi_int<0x0C, "blendps",
3436                                         int_x86_sse41_blendps, 0>;
3437 defm BLENDPD      : SS41I_binop_rmi_int<0x0D, "blendpd",
3438                                         int_x86_sse41_blendpd, 0>;
3439 defm PBLENDW      : SS41I_binop_rmi_int<0x0E, "pblendw",
3440                                         int_x86_sse41_pblendw, 0>;
3441 defm DPPS         : SS41I_binop_rmi_int<0x40, "dpps",
3442                                         int_x86_sse41_dpps, 1>;
3443 defm DPPD         : SS41I_binop_rmi_int<0x41, "dppd",
3444                                         int_x86_sse41_dppd, 1>;
3445 defm MPSADBW      : SS41I_binop_rmi_int<0x42, "mpsadbw",
3446                                         int_x86_sse41_mpsadbw, 1>;
3447
3448
3449 /// SS41I_ternary_int - SSE 4.1 ternary operator
3450 let Uses = [XMM0], Constraints = "$src1 = $dst" in {
3451   multiclass SS41I_ternary_int<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
3452     def rr0 : SS48I<opc, MRMSrcReg, (outs VR128:$dst),
3453                     (ins VR128:$src1, VR128:$src2),
3454                     !strconcat(OpcodeStr,
3455                      "\t{%xmm0, $src2, $dst|$dst, $src2, %xmm0}"),
3456                     [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2, XMM0))]>,
3457                     OpSize;
3458
3459     def rm0 : SS48I<opc, MRMSrcMem, (outs VR128:$dst),
3460                     (ins VR128:$src1, i128mem:$src2),
3461                     !strconcat(OpcodeStr,
3462                      "\t{%xmm0, $src2, $dst|$dst, $src2, %xmm0}"),
3463                     [(set VR128:$dst,
3464                       (IntId VR128:$src1,
3465                        (bitconvert (memopv16i8 addr:$src2)), XMM0))]>, OpSize;
3466   }
3467 }
3468
3469 defm BLENDVPD     : SS41I_ternary_int<0x15, "blendvpd", int_x86_sse41_blendvpd>;
3470 defm BLENDVPS     : SS41I_ternary_int<0x14, "blendvps", int_x86_sse41_blendvps>;
3471 defm PBLENDVB     : SS41I_ternary_int<0x10, "pblendvb", int_x86_sse41_pblendvb>;
3472
3473
3474 multiclass SS41I_binop_rm_int8<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
3475   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3476                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3477                  [(set VR128:$dst, (IntId VR128:$src))]>, OpSize;
3478
3479   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst), (ins i64mem:$src),
3480                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3481        [(set VR128:$dst,
3482          (IntId (bitconvert (v2i64 (scalar_to_vector (loadi64 addr:$src))))))]>,
3483        OpSize;
3484 }
3485
3486 defm PMOVSXBW   : SS41I_binop_rm_int8<0x20, "pmovsxbw", int_x86_sse41_pmovsxbw>;
3487 defm PMOVSXWD   : SS41I_binop_rm_int8<0x23, "pmovsxwd", int_x86_sse41_pmovsxwd>;
3488 defm PMOVSXDQ   : SS41I_binop_rm_int8<0x25, "pmovsxdq", int_x86_sse41_pmovsxdq>;
3489 defm PMOVZXBW   : SS41I_binop_rm_int8<0x30, "pmovzxbw", int_x86_sse41_pmovzxbw>;
3490 defm PMOVZXWD   : SS41I_binop_rm_int8<0x33, "pmovzxwd", int_x86_sse41_pmovzxwd>;
3491 defm PMOVZXDQ   : SS41I_binop_rm_int8<0x35, "pmovzxdq", int_x86_sse41_pmovzxdq>;
3492
3493 // Common patterns involving scalar load.
3494 def : Pat<(int_x86_sse41_pmovsxbw (vzmovl_v2i64 addr:$src)),
3495           (PMOVSXBWrm addr:$src)>, Requires<[HasSSE41]>;
3496 def : Pat<(int_x86_sse41_pmovsxbw (vzload_v2i64 addr:$src)),
3497           (PMOVSXBWrm addr:$src)>, Requires<[HasSSE41]>;
3498
3499 def : Pat<(int_x86_sse41_pmovsxwd (vzmovl_v2i64 addr:$src)),
3500           (PMOVSXWDrm addr:$src)>, Requires<[HasSSE41]>;
3501 def : Pat<(int_x86_sse41_pmovsxwd (vzload_v2i64 addr:$src)),
3502           (PMOVSXWDrm addr:$src)>, Requires<[HasSSE41]>;
3503
3504 def : Pat<(int_x86_sse41_pmovsxdq (vzmovl_v2i64 addr:$src)),
3505           (PMOVSXDQrm addr:$src)>, Requires<[HasSSE41]>;
3506 def : Pat<(int_x86_sse41_pmovsxdq (vzload_v2i64 addr:$src)),
3507           (PMOVSXDQrm addr:$src)>, Requires<[HasSSE41]>;
3508
3509 def : Pat<(int_x86_sse41_pmovzxbw (vzmovl_v2i64 addr:$src)),
3510           (PMOVZXBWrm addr:$src)>, Requires<[HasSSE41]>;
3511 def : Pat<(int_x86_sse41_pmovzxbw (vzload_v2i64 addr:$src)),
3512           (PMOVZXBWrm addr:$src)>, Requires<[HasSSE41]>;
3513
3514 def : Pat<(int_x86_sse41_pmovzxwd (vzmovl_v2i64 addr:$src)),
3515           (PMOVZXWDrm addr:$src)>, Requires<[HasSSE41]>;
3516 def : Pat<(int_x86_sse41_pmovzxwd (vzload_v2i64 addr:$src)),
3517           (PMOVZXWDrm addr:$src)>, Requires<[HasSSE41]>;
3518
3519 def : Pat<(int_x86_sse41_pmovzxdq (vzmovl_v2i64 addr:$src)),
3520           (PMOVZXDQrm addr:$src)>, Requires<[HasSSE41]>;
3521 def : Pat<(int_x86_sse41_pmovzxdq (vzload_v2i64 addr:$src)),
3522           (PMOVZXDQrm addr:$src)>, Requires<[HasSSE41]>;
3523
3524
3525 multiclass SS41I_binop_rm_int4<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
3526   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3527                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3528                  [(set VR128:$dst, (IntId VR128:$src))]>, OpSize;
3529
3530   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst), (ins i32mem:$src),
3531                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3532        [(set VR128:$dst,
3533          (IntId (bitconvert (v4i32 (scalar_to_vector (loadi32 addr:$src))))))]>,
3534           OpSize;
3535 }
3536
3537 defm PMOVSXBD   : SS41I_binop_rm_int4<0x21, "pmovsxbd", int_x86_sse41_pmovsxbd>;
3538 defm PMOVSXWQ   : SS41I_binop_rm_int4<0x24, "pmovsxwq", int_x86_sse41_pmovsxwq>;
3539 defm PMOVZXBD   : SS41I_binop_rm_int4<0x31, "pmovzxbd", int_x86_sse41_pmovzxbd>;
3540 defm PMOVZXWQ   : SS41I_binop_rm_int4<0x34, "pmovzxwq", int_x86_sse41_pmovzxwq>;
3541
3542 // Common patterns involving scalar load
3543 def : Pat<(int_x86_sse41_pmovsxbd (vzmovl_v4i32 addr:$src)),
3544           (PMOVSXBDrm addr:$src)>, Requires<[HasSSE41]>;
3545 def : Pat<(int_x86_sse41_pmovsxwq (vzmovl_v4i32 addr:$src)),
3546           (PMOVSXWQrm addr:$src)>, Requires<[HasSSE41]>;
3547
3548 def : Pat<(int_x86_sse41_pmovzxbd (vzmovl_v4i32 addr:$src)),
3549           (PMOVZXBDrm addr:$src)>, Requires<[HasSSE41]>;
3550 def : Pat<(int_x86_sse41_pmovzxwq (vzmovl_v4i32 addr:$src)),
3551           (PMOVZXWQrm addr:$src)>, Requires<[HasSSE41]>;
3552
3553
3554 multiclass SS41I_binop_rm_int2<bits<8> opc, string OpcodeStr, Intrinsic IntId> {
3555   def rr : SS48I<opc, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
3556                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3557                  [(set VR128:$dst, (IntId VR128:$src))]>, OpSize;
3558
3559   // Expecting a i16 load any extended to i32 value.
3560   def rm : SS48I<opc, MRMSrcMem, (outs VR128:$dst), (ins i16mem:$src),
3561                  !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
3562                  [(set VR128:$dst, (IntId (bitconvert
3563                      (v4i32 (scalar_to_vector (loadi16_anyext addr:$src))))))]>,
3564                  OpSize;
3565 }
3566
3567 defm PMOVSXBQ   : SS41I_binop_rm_int2<0x22, "pmovsxbq", int_x86_sse41_pmovsxbq>;
3568 defm PMOVZXBQ   : SS41I_binop_rm_int2<0x32, "pmovzxbq", int_x86_sse41_pmovzxbq>;
3569
3570 // Common patterns involving scalar load
3571 def : Pat<(int_x86_sse41_pmovsxbq
3572             (bitconvert (v4i32 (X86vzmovl
3573                              (v4i32 (scalar_to_vector (loadi32 addr:$src))))))),
3574           (PMOVSXBQrm addr:$src)>, Requires<[HasSSE41]>;
3575
3576 def : Pat<(int_x86_sse41_pmovzxbq
3577             (bitconvert (v4i32 (X86vzmovl
3578                              (v4i32 (scalar_to_vector (loadi32 addr:$src))))))),
3579           (PMOVZXBQrm addr:$src)>, Requires<[HasSSE41]>;
3580
3581
3582 /// SS41I_binop_ext8 - SSE 4.1 extract 8 bits to 32 bit reg or 8 bit mem
3583 multiclass SS41I_extract8<bits<8> opc, string OpcodeStr> {
3584   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32:$dst),
3585                  (ins VR128:$src1, i32i8imm:$src2),
3586                  !strconcat(OpcodeStr,
3587                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3588                  [(set GR32:$dst, (X86pextrb (v16i8 VR128:$src1), imm:$src2))]>,
3589                  OpSize;
3590   def mr : SS4AIi8<opc, MRMDestMem, (outs),
3591                  (ins i8mem:$dst, VR128:$src1, i32i8imm:$src2),
3592                  !strconcat(OpcodeStr,
3593                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3594                  []>, OpSize;
3595 // FIXME:
3596 // There's an AssertZext in the way of writing the store pattern
3597 // (store (i8 (trunc (X86pextrb (v16i8 VR128:$src1), imm:$src2))), addr:$dst)
3598 }
3599
3600 defm PEXTRB      : SS41I_extract8<0x14, "pextrb">;
3601
3602
3603 /// SS41I_extract16 - SSE 4.1 extract 16 bits to memory destination
3604 multiclass SS41I_extract16<bits<8> opc, string OpcodeStr> {
3605   def mr : SS4AIi8<opc, MRMDestMem, (outs),
3606                  (ins i16mem:$dst, VR128:$src1, i32i8imm:$src2),
3607                  !strconcat(OpcodeStr,
3608                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3609                  []>, OpSize;
3610 // FIXME:
3611 // There's an AssertZext in the way of writing the store pattern
3612 // (store (i16 (trunc (X86pextrw (v16i8 VR128:$src1), imm:$src2))), addr:$dst)
3613 }
3614
3615 defm PEXTRW      : SS41I_extract16<0x15, "pextrw">;
3616
3617
3618 /// SS41I_extract32 - SSE 4.1 extract 32 bits to int reg or memory destination
3619 multiclass SS41I_extract32<bits<8> opc, string OpcodeStr> {
3620   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32:$dst),
3621                  (ins VR128:$src1, i32i8imm:$src2),
3622                  !strconcat(OpcodeStr,
3623                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3624                  [(set GR32:$dst,
3625                   (extractelt (v4i32 VR128:$src1), imm:$src2))]>, OpSize;
3626   def mr : SS4AIi8<opc, MRMDestMem, (outs),
3627                  (ins i32mem:$dst, VR128:$src1, i32i8imm:$src2),
3628                  !strconcat(OpcodeStr,
3629                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3630                  [(store (extractelt (v4i32 VR128:$src1), imm:$src2),
3631                           addr:$dst)]>, OpSize;
3632 }
3633
3634 defm PEXTRD      : SS41I_extract32<0x16, "pextrd">;
3635
3636
3637 /// SS41I_extractf32 - SSE 4.1 extract 32 bits fp value to int reg or memory
3638 /// destination
3639 multiclass SS41I_extractf32<bits<8> opc, string OpcodeStr> {
3640   def rr : SS4AIi8<opc, MRMDestReg, (outs GR32:$dst),
3641                  (ins VR128:$src1, i32i8imm:$src2),
3642                  !strconcat(OpcodeStr,
3643                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3644                  [(set GR32:$dst,
3645                     (extractelt (bc_v4i32 (v4f32 VR128:$src1)), imm:$src2))]>,
3646            OpSize;
3647   def mr : SS4AIi8<opc, MRMDestMem, (outs),
3648                  (ins f32mem:$dst, VR128:$src1, i32i8imm:$src2),
3649                  !strconcat(OpcodeStr,
3650                   "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
3651                  [(store (extractelt (bc_v4i32 (v4f32 VR128:$src1)), imm:$src2),
3652                           addr:$dst)]>, OpSize;
3653 }
3654
3655 defm EXTRACTPS   : SS41I_extractf32<0x17, "extractps">;
3656
3657 // Also match an EXTRACTPS store when the store is done as f32 instead of i32.
3658 def : Pat<(store (f32 (bitconvert (extractelt (bc_v4i32 (v4f32 VR128:$src1)),
3659                                               imm:$src2))),
3660                  addr:$dst),
3661           (EXTRACTPSmr addr:$dst, VR128:$src1, imm:$src2)>,
3662          Requires<[HasSSE41]>;
3663
3664 let Constraints = "$src1 = $dst" in {
3665   multiclass SS41I_insert8<bits<8> opc, string OpcodeStr> {
3666     def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
3667                    (ins VR128:$src1, GR32:$src2, i32i8imm:$src3),
3668                    !strconcat(OpcodeStr,
3669                     "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3670                    [(set VR128:$dst,
3671                      (X86pinsrb VR128:$src1, GR32:$src2, imm:$src3))]>, OpSize;
3672     def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
3673                    (ins VR128:$src1, i8mem:$src2, i32i8imm:$src3),
3674                    !strconcat(OpcodeStr,
3675                     "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3676                    [(set VR128:$dst,
3677                      (X86pinsrb VR128:$src1, (extloadi8 addr:$src2),
3678                                 imm:$src3))]>, OpSize;
3679   }
3680 }
3681
3682 defm PINSRB      : SS41I_insert8<0x20, "pinsrb">;
3683
3684 let Constraints = "$src1 = $dst" in {
3685   multiclass SS41I_insert32<bits<8> opc, string OpcodeStr> {
3686     def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
3687                    (ins VR128:$src1, GR32:$src2, i32i8imm:$src3),
3688                    !strconcat(OpcodeStr,
3689                     "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3690                    [(set VR128:$dst,
3691                      (v4i32 (insertelt VR128:$src1, GR32:$src2, imm:$src3)))]>,
3692                    OpSize;
3693     def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
3694                    (ins VR128:$src1, i32mem:$src2, i32i8imm:$src3),
3695                    !strconcat(OpcodeStr,
3696                     "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3697                    [(set VR128:$dst,
3698                      (v4i32 (insertelt VR128:$src1, (loadi32 addr:$src2),
3699                                        imm:$src3)))]>, OpSize;
3700   }
3701 }
3702
3703 defm PINSRD      : SS41I_insert32<0x22, "pinsrd">;
3704
3705 // insertps has a few different modes, there's the first two here below which
3706 // are optimized inserts that won't zero arbitrary elements in the destination
3707 // vector. The next one matches the intrinsic and could zero arbitrary elements
3708 // in the target vector.
3709 let Constraints = "$src1 = $dst" in {
3710   multiclass SS41I_insertf32<bits<8> opc, string OpcodeStr> {
3711     def rr : SS4AIi8<opc, MRMSrcReg, (outs VR128:$dst),
3712                    (ins VR128:$src1, VR128:$src2, i32i8imm:$src3),
3713                    !strconcat(OpcodeStr,
3714                     "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3715                    [(set VR128:$dst,
3716                      (X86insrtps VR128:$src1, VR128:$src2, imm:$src3))]>,
3717       OpSize;
3718     def rm : SS4AIi8<opc, MRMSrcMem, (outs VR128:$dst),
3719                    (ins VR128:$src1, f32mem:$src2, i32i8imm:$src3),
3720                    !strconcat(OpcodeStr,
3721                     "\t{$src3, $src2, $dst|$dst, $src2, $src3}"),
3722                    [(set VR128:$dst,
3723                      (X86insrtps VR128:$src1,
3724                                 (v4f32 (scalar_to_vector (loadf32 addr:$src2))),
3725                                  imm:$src3))]>, OpSize;
3726   }
3727 }
3728
3729 defm INSERTPS    : SS41I_insertf32<0x21, "insertps">;
3730
3731 def : Pat<(int_x86_sse41_insertps VR128:$src1, VR128:$src2, imm:$src3),
3732           (INSERTPSrr VR128:$src1, VR128:$src2, imm:$src3)>;
3733
3734 // ptest instruction we'll lower to this in X86ISelLowering primarily from
3735 // the intel intrinsic that corresponds to this.
3736 let Defs = [EFLAGS] in {
3737 def PTESTrr : SS48I<0x17, MRMSrcReg, (outs), (ins VR128:$src1, VR128:$src2),
3738                     "ptest \t{$src2, $src1|$src1, $src2}",
3739                     [(X86ptest VR128:$src1, VR128:$src2),
3740                       (implicit EFLAGS)]>, OpSize;
3741 def PTESTrm : SS48I<0x17, MRMSrcMem, (outs), (ins VR128:$src1, i128mem:$src2),
3742                     "ptest \t{$src2, $src1|$src1, $src2}",
3743                     [(X86ptest VR128:$src1, (load addr:$src2)),
3744                         (implicit EFLAGS)]>, OpSize;
3745 }
3746
3747 def MOVNTDQArm : SS48I<0x2A, MRMSrcMem, (outs VR128:$dst), (ins i128mem:$src),
3748                        "movntdqa\t{$src, $dst|$dst, $src}",
3749                        [(set VR128:$dst, (int_x86_sse41_movntdqa addr:$src))]>;
3750
3751
3752 //===----------------------------------------------------------------------===//
3753 // SSE4.2 Instructions
3754 //===----------------------------------------------------------------------===//
3755
3756 /// SS42I_binop_rm_int - Simple SSE 4.2 binary operator
3757 let Constraints = "$src1 = $dst" in {
3758   multiclass SS42I_binop_rm_int<bits<8> opc, string OpcodeStr,
3759                                 Intrinsic IntId128, bit Commutable = 0> {
3760     def rr : SS428I<opc, MRMSrcReg, (outs VR128:$dst),
3761                    (ins VR128:$src1, VR128:$src2),
3762                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3763                    [(set VR128:$dst, (IntId128 VR128:$src1, VR128:$src2))]>,
3764                    OpSize {
3765       let isCommutable = Commutable;
3766     }
3767     def rm : SS428I<opc, MRMSrcMem, (outs VR128:$dst),
3768                    (ins VR128:$src1, i128mem:$src2),
3769                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
3770                    [(set VR128:$dst,
3771                      (IntId128 VR128:$src1,
3772                       (bitconvert (memopv16i8 addr:$src2))))]>, OpSize;
3773   }
3774 }
3775
3776 defm PCMPGTQ      : SS42I_binop_rm_int<0x37, "pcmpgtq", int_x86_sse42_pcmpgtq>;
3777
3778 def : Pat<(v2i64 (X86pcmpgtq VR128:$src1, VR128:$src2)),
3779           (PCMPGTQrr VR128:$src1, VR128:$src2)>;
3780 def : Pat<(v2i64 (X86pcmpgtq VR128:$src1, (memop addr:$src2))),
3781           (PCMPGTQrm VR128:$src1, addr:$src2)>;
3782
3783 // crc intrinsic instruction
3784 // This set of instructions are only rm, the only difference is the size
3785 // of r and m.
3786 let Constraints = "$src1 = $dst" in {
3787   def CRC32m8  : SS42FI<0xF0, MRMSrcMem, (outs GR32:$dst),
3788                       (ins GR32:$src1, i8mem:$src2),
3789                       "crc32 \t{$src2, $src1|$src1, $src2}",
3790                        [(set GR32:$dst,
3791                          (int_x86_sse42_crc32_8 GR32:$src1,
3792                          (load addr:$src2)))]>, OpSize;
3793   def CRC32r8  : SS42FI<0xF0, MRMSrcReg, (outs GR32:$dst),
3794                       (ins GR32:$src1, GR8:$src2),
3795                       "crc32 \t{$src2, $src1|$src1, $src2}",
3796                        [(set GR32:$dst,
3797                          (int_x86_sse42_crc32_8 GR32:$src1, GR8:$src2))]>,
3798                          OpSize;
3799   def CRC32m16  : SS42FI<0xF1, MRMSrcMem, (outs GR32:$dst),
3800                       (ins GR32:$src1, i16mem:$src2),
3801                       "crc32 \t{$src2, $src1|$src1, $src2}",
3802                        [(set GR32:$dst,
3803                          (int_x86_sse42_crc32_16 GR32:$src1,
3804                          (load addr:$src2)))]>,
3805                          OpSize;
3806   def CRC32r16  : SS42FI<0xF1, MRMSrcReg, (outs GR32:$dst),
3807                       (ins GR32:$src1, GR16:$src2),
3808                       "crc32 \t{$src2, $src1|$src1, $src2}",
3809                        [(set GR32:$dst,
3810                          (int_x86_sse42_crc32_16 GR32:$src1, GR16:$src2))]>,
3811                          OpSize;
3812   def CRC32m32  : SS42FI<0xF1, MRMSrcMem, (outs GR32:$dst),
3813                       (ins GR32:$src1, i32mem:$src2),
3814                       "crc32 \t{$src2, $src1|$src1, $src2}",
3815                        [(set GR32:$dst,
3816                          (int_x86_sse42_crc32_32 GR32:$src1,
3817                          (load addr:$src2)))]>, OpSize;
3818   def CRC32r32  : SS42FI<0xF1, MRMSrcReg, (outs GR32:$dst),
3819                       (ins GR32:$src1, GR32:$src2),
3820                       "crc32 \t{$src2, $src1|$src1, $src2}",
3821                        [(set GR32:$dst,
3822                          (int_x86_sse42_crc32_32 GR32:$src1, GR32:$src2))]>,
3823                          OpSize;
3824   def CRC64m64  : SS42FI<0xF0, MRMSrcMem, (outs GR64:$dst),
3825                       (ins GR64:$src1, i64mem:$src2),
3826                       "crc32 \t{$src2, $src1|$src1, $src2}",
3827                        [(set GR64:$dst,
3828                          (int_x86_sse42_crc32_64 GR64:$src1,
3829                          (load addr:$src2)))]>,
3830                          OpSize, REX_W;
3831   def CRC64r64  : SS42FI<0xF0, MRMSrcReg, (outs GR64:$dst),
3832                       (ins GR64:$src1, GR64:$src2),
3833                       "crc32 \t{$src2, $src1|$src1, $src2}",
3834                        [(set GR64:$dst,
3835                          (int_x86_sse42_crc32_64 GR64:$src1, GR64:$src2))]>,
3836                          OpSize, REX_W;
3837 }
3838
3839 // String/text processing instructions.
3840 let Defs = [EFLAGS], usesCustomInserter = 1 in {
3841 def PCMPISTRM128REG : SS42AI<0, Pseudo, (outs VR128:$dst),
3842   (ins VR128:$src1, VR128:$src2, i8imm:$src3),
3843   "#PCMPISTRM128rr PSEUDO!",
3844   [(set VR128:$dst, (int_x86_sse42_pcmpistrm128 VR128:$src1, VR128:$src2,
3845                                                 imm:$src3))]>, OpSize;
3846 def PCMPISTRM128MEM : SS42AI<0, Pseudo, (outs VR128:$dst),
3847   (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
3848   "#PCMPISTRM128rm PSEUDO!",
3849   [(set VR128:$dst, (int_x86_sse42_pcmpistrm128 VR128:$src1, (load addr:$src2),
3850                                                 imm:$src3))]>, OpSize;
3851 }
3852
3853 let Defs = [XMM0, EFLAGS] in {
3854 def PCMPISTRM128rr : SS42AI<0x62, MRMSrcReg, (outs),
3855   (ins VR128:$src1, VR128:$src2, i8imm:$src3),
3856    "pcmpistrm\t{$src3, $src2, $src1|$src1, $src2, $src3}", []>, OpSize;
3857 def PCMPISTRM128rm : SS42AI<0x62, MRMSrcMem, (outs),
3858   (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
3859   "pcmpistrm\t{$src3, $src2, $src1|$src1, $src2, $src3}", []>, OpSize;
3860 }
3861
3862 let Defs = [EFLAGS], Uses = [EAX, EDX], usesCustomInserter = 1 in {
3863 def PCMPESTRM128REG : SS42AI<0, Pseudo, (outs VR128:$dst),
3864   (ins VR128:$src1, VR128:$src3, i8imm:$src5),
3865   "#PCMPESTRM128rr PSEUDO!",
3866   [(set VR128:$dst,
3867         (int_x86_sse42_pcmpestrm128
3868          VR128:$src1, EAX, VR128:$src3, EDX, imm:$src5))]>, OpSize;
3869
3870 def PCMPESTRM128MEM : SS42AI<0, Pseudo, (outs VR128:$dst),
3871   (ins VR128:$src1, i128mem:$src3, i8imm:$src5),
3872   "#PCMPESTRM128rm PSEUDO!",
3873   [(set VR128:$dst, (int_x86_sse42_pcmpestrm128
3874                      VR128:$src1, EAX, (load addr:$src3), EDX, imm:$src5))]>,
3875   OpSize;
3876 }
3877
3878 let Defs = [XMM0, EFLAGS], Uses = [EAX, EDX] in {
3879 def PCMPESTRM128rr : SS42AI<0x60, MRMSrcReg, (outs),
3880   (ins VR128:$src1, VR128:$src3, i8imm:$src5),
3881   "pcmpestrm\t{$src5, $src3, $src1|$src1, $src3, $src5}", []>, OpSize;
3882 def PCMPESTRM128rm : SS42AI<0x60, MRMSrcMem, (outs),
3883   (ins VR128:$src1, i128mem:$src3, i8imm:$src5),
3884   "pcmpestrm\t{$src5, $src3, $src1|$src1, $src3, $src5}", []>, OpSize;
3885 }
3886
3887 let Defs = [ECX, EFLAGS] in {
3888   multiclass SS42AI_pcmpistri<Intrinsic IntId128> {
3889     def rr : SS42AI<0x63, MRMSrcReg, (outs),
3890       (ins VR128:$src1, VR128:$src2, i8imm:$src3),
3891       "pcmpistri\t{$src3, $src2, $src1|$src1, $src2, $src3}",
3892       [(set ECX, (IntId128 VR128:$src1, VR128:$src2, imm:$src3)),
3893        (implicit EFLAGS)]>, OpSize;
3894     def rm : SS42AI<0x63, MRMSrcMem, (outs),
3895       (ins VR128:$src1, i128mem:$src2, i8imm:$src3),
3896       "pcmpistri\t{$src3, $src2, $src1|$src1, $src2, $src3}",
3897       [(set ECX, (IntId128 VR128:$src1, (load addr:$src2), imm:$src3)),
3898        (implicit EFLAGS)]>, OpSize;
3899   }
3900 }
3901
3902 defm PCMPISTRI  : SS42AI_pcmpistri<int_x86_sse42_pcmpistri128>;
3903 defm PCMPISTRIA : SS42AI_pcmpistri<int_x86_sse42_pcmpistria128>;
3904 defm PCMPISTRIC : SS42AI_pcmpistri<int_x86_sse42_pcmpistric128>;
3905 defm PCMPISTRIO : SS42AI_pcmpistri<int_x86_sse42_pcmpistrio128>;
3906 defm PCMPISTRIS : SS42AI_pcmpistri<int_x86_sse42_pcmpistris128>;
3907 defm PCMPISTRIZ : SS42AI_pcmpistri<int_x86_sse42_pcmpistriz128>;
3908
3909 let Defs = [ECX, EFLAGS] in {
3910 let Uses = [EAX, EDX] in {
3911   multiclass SS42AI_pcmpestri<Intrinsic IntId128> {
3912     def rr : SS42AI<0x61, MRMSrcReg, (outs),
3913       (ins VR128:$src1, VR128:$src3, i8imm:$src5),
3914       "pcmpestri\t{$src5, $src3, $src1|$src1, $src3, $src5}",
3915       [(set ECX, (IntId128 VR128:$src1, EAX, VR128:$src3, EDX, imm:$src5)),
3916        (implicit EFLAGS)]>, OpSize;
3917     def rm : SS42AI<0x61, MRMSrcMem, (outs),
3918       (ins VR128:$src1, i128mem:$src3, i8imm:$src5),
3919        "pcmpestri\t{$src5, $src3, $src1|$src1, $src3, $src5}",
3920        [(set ECX,
3921              (IntId128 VR128:$src1, EAX, (load addr:$src3), EDX, imm:$src5)),
3922         (implicit EFLAGS)]>, OpSize;
3923   }
3924 }
3925 }
3926
3927 defm PCMPESTRI  : SS42AI_pcmpestri<int_x86_sse42_pcmpestri128>;
3928 defm PCMPESTRIA : SS42AI_pcmpestri<int_x86_sse42_pcmpestria128>;
3929 defm PCMPESTRIC : SS42AI_pcmpestri<int_x86_sse42_pcmpestric128>;
3930 defm PCMPESTRIO : SS42AI_pcmpestri<int_x86_sse42_pcmpestrio128>;
3931 defm PCMPESTRIS : SS42AI_pcmpestri<int_x86_sse42_pcmpestris128>;
3932 defm PCMPESTRIZ : SS42AI_pcmpestri<int_x86_sse42_pcmpestriz128>;