lib/Target/X86/X86InstrSSE.td

   1 //====- X86InstrSSE.td - Describe the X86 Instruction Set -------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Evan Cheng and is distributed under the University
   6 // of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the X86 SSE instruction set, defining the instructions,
  11 // and properties of the instructions which are needed for code generation,
  12 // machine code emission, and analysis.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16
  17 //===----------------------------------------------------------------------===//
  18 // SSE specific DAG Nodes.
  19 //===----------------------------------------------------------------------===//
  20
  21 def SDTX86FPShiftOp : SDTypeProfile<1, 2, [ SDTCisSameAs<0, 1>,
  22                                             SDTCisFP<0>, SDTCisInt<2> ]>;
  23
  24 def X86loadp   : SDNode<"X86ISD::LOAD_PACK", SDTLoad, [SDNPHasChain]>;
  25 def X86loadu   : SDNode<"X86ISD::LOAD_UA",   SDTLoad, [SDNPHasChain]>;
  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 X86fsrl    : SDNode<"X86ISD::FSRL",      SDTX86FPShiftOp>;
  35 def X86comi    : SDNode<"X86ISD::COMI",      SDTX86CmpTest,
  36                         [SDNPHasChain, SDNPOutFlag]>;
  37 def X86ucomi   : SDNode<"X86ISD::UCOMI",     SDTX86CmpTest,
  38                         [SDNPHasChain, SDNPOutFlag]>;
  39 def X86s2vec   : SDNode<"X86ISD::S2VEC",  SDTypeProfile<1, 1, []>, []>;
  40 def X86pextrw  : SDNode<"X86ISD::PEXTRW", SDTypeProfile<1, 2, []>, []>;
  41 def X86pinsrw  : SDNode<"X86ISD::PINSRW", SDTypeProfile<1, 3, []>, []>;
  42
  43 //===----------------------------------------------------------------------===//
  44 // SSE 'Special' Instructions
  45 //===----------------------------------------------------------------------===//
  46
  47 def IMPLICIT_DEF_VR128 : I<0, Pseudo, (ops VR128:$dst),
  48                            "#IMPLICIT_DEF $dst",
  49                            [(set VR128:$dst, (v4f32 (undef)))]>,
  50                          Requires<[HasSSE1]>;
  51 def IMPLICIT_DEF_FR32  : I<0, Pseudo, (ops FR32:$dst),
  52                            "#IMPLICIT_DEF $dst",
  53                            [(set FR32:$dst, (undef))]>, Requires<[HasSSE2]>;
  54 def IMPLICIT_DEF_FR64  : I<0, Pseudo, (ops FR64:$dst),
  55                            "#IMPLICIT_DEF $dst",
  56                            [(set FR64:$dst, (undef))]>, Requires<[HasSSE2]>;
  57
  58 //===----------------------------------------------------------------------===//
  59 // SSE Complex Patterns
  60 //===----------------------------------------------------------------------===//
  61
  62 // These are 'extloads' from a scalar to the low element of a vector, zeroing
  63 // the top elements.  These are used for the SSE 'ss' and 'sd' instruction
  64 // forms.
  65 def sse_load_f32 : ComplexPattern<v4f32, 4, "SelectScalarSSELoad", [],
  66                                   [SDNPHasChain]>;
  67 def sse_load_f64 : ComplexPattern<v2f64, 4, "SelectScalarSSELoad", [],
  68                                   [SDNPHasChain]>;
  69
  70 def ssmem : Operand<v4f32> {
  71   let PrintMethod = "printf32mem";
  72   let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc, i32imm);
  73 }
  74 def sdmem : Operand<v2f64> {
  75   let PrintMethod = "printf64mem";
  76   let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc, i32imm);
  77 }
  78
  79 //===----------------------------------------------------------------------===//
  80 // SSE pattern fragments
  81 //===----------------------------------------------------------------------===//
  82
  83 def X86loadpf32  : PatFrag<(ops node:$ptr), (f32   (X86loadp node:$ptr))>;
  84 def X86loadpf64  : PatFrag<(ops node:$ptr), (f64   (X86loadp node:$ptr))>;
  85
  86 def loadv4f32    : PatFrag<(ops node:$ptr), (v4f32 (load node:$ptr))>;
  87 def loadv2f64    : PatFrag<(ops node:$ptr), (v2f64 (load node:$ptr))>;
  88 def loadv4i32    : PatFrag<(ops node:$ptr), (v4i32 (load node:$ptr))>;
  89 def loadv2i64    : PatFrag<(ops node:$ptr), (v2i64 (load node:$ptr))>;
  90
  91 def bc_v4f32 : PatFrag<(ops node:$in), (v4f32 (bitconvert node:$in))>;
  92 def bc_v2f64 : PatFrag<(ops node:$in), (v2f64 (bitconvert node:$in))>;
  93 def bc_v16i8 : PatFrag<(ops node:$in), (v16i8 (bitconvert node:$in))>;
  94 def bc_v8i16 : PatFrag<(ops node:$in), (v8i16 (bitconvert node:$in))>;
  95 def bc_v4i32 : PatFrag<(ops node:$in), (v4i32 (bitconvert node:$in))>;
  96 def bc_v2i64 : PatFrag<(ops node:$in), (v2i64 (bitconvert node:$in))>;
  97
  98 def fp32imm0 : PatLeaf<(f32 fpimm), [{
  99   return N->isExactlyValue(+0.0);
 100 }]>;
 101
 102 def PSxLDQ_imm  : SDNodeXForm<imm, [{
 103   // Transformation function: imm >> 3
 104   return getI32Imm(N->getValue() >> 3);
 105 }]>;
 106
 107 // SHUFFLE_get_shuf_imm xform function: convert vector_shuffle mask to PSHUF*,
 108 // SHUFP* etc. imm.
 109 def SHUFFLE_get_shuf_imm : SDNodeXForm<build_vector, [{
 110   return getI8Imm(X86::getShuffleSHUFImmediate(N));
 111 }]>;
 112
 113 // SHUFFLE_get_pshufhw_imm xform function: convert vector_shuffle mask to
 114 // PSHUFHW imm.
 115 def SHUFFLE_get_pshufhw_imm : SDNodeXForm<build_vector, [{
 116   return getI8Imm(X86::getShufflePSHUFHWImmediate(N));
 117 }]>;
 118
 119 // SHUFFLE_get_pshuflw_imm xform function: convert vector_shuffle mask to
 120 // PSHUFLW imm.
 121 def SHUFFLE_get_pshuflw_imm : SDNodeXForm<build_vector, [{
 122   return getI8Imm(X86::getShufflePSHUFLWImmediate(N));
 123 }]>;
 124
 125 def SSE_splat_mask : PatLeaf<(build_vector), [{
 126   return X86::isSplatMask(N);
 127 }], SHUFFLE_get_shuf_imm>;
 128
 129 def SSE_splat_lo_mask : PatLeaf<(build_vector), [{
 130   return X86::isSplatLoMask(N);
 131 }]>;
 132
 133 def MOVHLPS_shuffle_mask : PatLeaf<(build_vector), [{
 134   return X86::isMOVHLPSMask(N);
 135 }]>;
 136
 137 def MOVHLPS_v_undef_shuffle_mask : PatLeaf<(build_vector), [{
 138   return X86::isMOVHLPS_v_undef_Mask(N);
 139 }]>;
 140
 141 def MOVHP_shuffle_mask : PatLeaf<(build_vector), [{
 142   return X86::isMOVHPMask(N);
 143 }]>;
 144
 145 def MOVLP_shuffle_mask : PatLeaf<(build_vector), [{
 146   return X86::isMOVLPMask(N);
 147 }]>;
 148
 149 def MOVL_shuffle_mask : PatLeaf<(build_vector), [{
 150   return X86::isMOVLMask(N);
 151 }]>;
 152
 153 def MOVSHDUP_shuffle_mask : PatLeaf<(build_vector), [{
 154   return X86::isMOVSHDUPMask(N);
 155 }]>;
 156
 157 def MOVSLDUP_shuffle_mask : PatLeaf<(build_vector), [{
 158   return X86::isMOVSLDUPMask(N);
 159 }]>;
 160
 161 def UNPCKL_shuffle_mask : PatLeaf<(build_vector), [{
 162   return X86::isUNPCKLMask(N);
 163 }]>;
 164
 165 def UNPCKH_shuffle_mask : PatLeaf<(build_vector), [{
 166   return X86::isUNPCKHMask(N);
 167 }]>;
 168
 169 def UNPCKL_v_undef_shuffle_mask : PatLeaf<(build_vector), [{
 170   return X86::isUNPCKL_v_undef_Mask(N);
 171 }]>;
 172
 173 def UNPCKH_v_undef_shuffle_mask : PatLeaf<(build_vector), [{
 174   return X86::isUNPCKH_v_undef_Mask(N);
 175 }]>;
 176
 177 def PSHUFD_shuffle_mask : PatLeaf<(build_vector), [{
 178   return X86::isPSHUFDMask(N);
 179 }], SHUFFLE_get_shuf_imm>;
 180
 181 def PSHUFHW_shuffle_mask : PatLeaf<(build_vector), [{
 182   return X86::isPSHUFHWMask(N);
 183 }], SHUFFLE_get_pshufhw_imm>;
 184
 185 def PSHUFLW_shuffle_mask : PatLeaf<(build_vector), [{
 186   return X86::isPSHUFLWMask(N);
 187 }], SHUFFLE_get_pshuflw_imm>;
 188
 189 def SHUFP_unary_shuffle_mask : PatLeaf<(build_vector), [{
 190   return X86::isPSHUFDMask(N);
 191 }], SHUFFLE_get_shuf_imm>;
 192
 193 def SHUFP_shuffle_mask : PatLeaf<(build_vector), [{
 194   return X86::isSHUFPMask(N);
 195 }], SHUFFLE_get_shuf_imm>;
 196
 197 def PSHUFD_binary_shuffle_mask : PatLeaf<(build_vector), [{
 198   return X86::isSHUFPMask(N);
 199 }], SHUFFLE_get_shuf_imm>;
 200
 201 //===----------------------------------------------------------------------===//
 202 // SSE scalar FP Instructions
 203 //===----------------------------------------------------------------------===//
 204
 205 // CMOV* - Used to implement the SSE SELECT DAG operation.  Expanded by the
 206 // scheduler into a branch sequence.
 207 let usesCustomDAGSchedInserter = 1 in {  // Expanded by the scheduler.
 208   def CMOV_FR32 : I<0, Pseudo,
 209                     (ops FR32:$dst, FR32:$t, FR32:$f, i8imm:$cond),
 210                     "#CMOV_FR32 PSEUDO!",
 211                     [(set FR32:$dst, (X86cmov FR32:$t, FR32:$f, imm:$cond))]>;
 212   def CMOV_FR64 : I<0, Pseudo,
 213                     (ops FR64:$dst, FR64:$t, FR64:$f, i8imm:$cond),
 214                     "#CMOV_FR64 PSEUDO!",
 215                     [(set FR64:$dst, (X86cmov FR64:$t, FR64:$f, imm:$cond))]>;
 216   def CMOV_V4F32 : I<0, Pseudo,
 217                     (ops VR128:$dst, VR128:$t, VR128:$f, i8imm:$cond),
 218                     "#CMOV_V4F32 PSEUDO!",
 219                     [(set VR128:$dst,
 220                       (v4f32 (X86cmov VR128:$t, VR128:$f, imm:$cond)))]>;
 221   def CMOV_V2F64 : I<0, Pseudo,
 222                     (ops VR128:$dst, VR128:$t, VR128:$f, i8imm:$cond),
 223                     "#CMOV_V2F64 PSEUDO!",
 224                     [(set VR128:$dst,
 225                       (v2f64 (X86cmov VR128:$t, VR128:$f, imm:$cond)))]>;
 226   def CMOV_V2I64 : I<0, Pseudo,
 227                     (ops VR128:$dst, VR128:$t, VR128:$f, i8imm:$cond),
 228                     "#CMOV_V2I64 PSEUDO!",
 229                     [(set VR128:$dst,
 230                       (v2i64 (X86cmov VR128:$t, VR128:$f, imm:$cond)))]>;
 231 }
 232
 233 //===----------------------------------------------------------------------===//
 234 // SSE1 Instructions
 235 //===----------------------------------------------------------------------===//
 236
 237 // SSE1 Instruction Templates:
 238 //
 239 //   SSI   - SSE1 instructions with XS prefix.
 240 //   PSI   - SSE1 instructions with TB prefix.
 241 //   PSIi8 - SSE1 instructions with ImmT == Imm8 and TB prefix.
 242
 243 class SSI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 244       : I<o, F, ops, asm, pattern>, XS, Requires<[HasSSE1]>;
 245 class PSI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 246       : I<o, F, ops, asm, pattern>, TB, Requires<[HasSSE1]>;
 247 class PSIi8<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 248       : Ii8<o, F, ops, asm, pattern>, TB, Requires<[HasSSE1]>;
 249
 250 // Helpers for defining instructions that directly correspond to intrinsics.
 251 multiclass SS_IntUnary<bits<8> o, string OpcodeStr, Intrinsic IntId> {
 252   def r : SSI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 253               !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
 254               [(set VR128:$dst, (v4f32 (IntId VR128:$src)))]>;
 255   def m : SSI<o, MRMSrcMem, (ops VR128:$dst, ssmem:$src),
 256               !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
 257               [(set VR128:$dst, (v4f32 (IntId sse_load_f32:$src)))]>;
 258 }
 259
 260 // Move Instructions
 261 def MOVSSrr : SSI<0x10, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 262                   "movss {$src, $dst|$dst, $src}", []>;
 263 def MOVSSrm : SSI<0x10, MRMSrcMem, (ops FR32:$dst, f32mem:$src),
 264                   "movss {$src, $dst|$dst, $src}",
 265                   [(set FR32:$dst, (loadf32 addr:$src))]>;
 266 def MOVSSmr : SSI<0x11, MRMDestMem, (ops f32mem:$dst, FR32:$src),
 267                   "movss {$src, $dst|$dst, $src}",
 268                   [(store FR32:$src, addr:$dst)]>;
 269
 270 def SQRTSSr : SSI<0x51, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 271                   "sqrtss {$src, $dst|$dst, $src}",
 272                   [(set FR32:$dst, (fsqrt FR32:$src))]>;
 273 def SQRTSSm : SSI<0x51, MRMSrcMem, (ops FR32:$dst, f32mem:$src),
 274                   "sqrtss {$src, $dst|$dst, $src}",
 275                   [(set FR32:$dst, (fsqrt (loadf32 addr:$src)))]>;
 276
 277 // Aliases to match intrinsics which expect XMM operand(s).
 278 defm SQRTSS_Int  : SS_IntUnary<0x51, "sqrtss" , int_x86_sse_sqrt_ss>;
 279 defm RSQRTSS_Int : SS_IntUnary<0x52, "rsqrtss", int_x86_sse_rsqrt_ss>;
 280 defm RCPSS_Int   : SS_IntUnary<0x53, "rcpss"  , int_x86_sse_rcp_ss>;
 281
 282 // Conversion instructions
 283 def CVTTSS2SIrr : SSI<0x2C, MRMSrcReg, (ops GR32:$dst, FR32:$src),
 284                       "cvttss2si {$src, $dst|$dst, $src}",
 285                       [(set GR32:$dst, (fp_to_sint FR32:$src))]>;
 286 def CVTTSS2SIrm : SSI<0x2C, MRMSrcMem, (ops GR32:$dst, f32mem:$src),
 287                       "cvttss2si {$src, $dst|$dst, $src}",
 288                       [(set GR32:$dst, (fp_to_sint (loadf32 addr:$src)))]>;
 289 def CVTSI2SSrr  : SSI<0x2A, MRMSrcReg, (ops FR32:$dst, GR32:$src),
 290                       "cvtsi2ss {$src, $dst|$dst, $src}",
 291                       [(set FR32:$dst, (sint_to_fp GR32:$src))]>;
 292 def CVTSI2SSrm  : SSI<0x2A, MRMSrcMem, (ops FR32:$dst, i32mem:$src),
 293                       "cvtsi2ss {$src, $dst|$dst, $src}",
 294                       [(set FR32:$dst, (sint_to_fp (loadi32 addr:$src)))]>;
 295
 296 // Match intrinsics which expect XMM operand(s).
 297 def Int_CVTSS2SIrr : SSI<0x2D, MRMSrcReg, (ops GR32:$dst, VR128:$src),
 298                          "cvtss2si {$src, $dst|$dst, $src}",
 299                          [(set GR32:$dst, (int_x86_sse_cvtss2si VR128:$src))]>;
 300 def Int_CVTSS2SIrm : SSI<0x2D, MRMSrcMem, (ops GR32:$dst, f32mem:$src),
 301                          "cvtss2si {$src, $dst|$dst, $src}",
 302                          [(set GR32:$dst, (int_x86_sse_cvtss2si
 303                                            (load addr:$src)))]>;
 304
 305 // Aliases for intrinsics
 306 def Int_CVTTSS2SIrr : SSI<0x2C, MRMSrcReg, (ops GR32:$dst, VR128:$src),
 307                           "cvttss2si {$src, $dst|$dst, $src}",
 308                           [(set GR32:$dst,
 309                             (int_x86_sse_cvttss2si VR128:$src))]>;
 310 def Int_CVTTSS2SIrm : SSI<0x2C, MRMSrcMem, (ops GR32:$dst, f32mem:$src),
 311                           "cvttss2si {$src, $dst|$dst, $src}",
 312                           [(set GR32:$dst,
 313                             (int_x86_sse_cvttss2si(load addr:$src)))]>;
 314
 315 let isTwoAddress = 1 in {
 316   def Int_CVTSI2SSrr : SSI<0x2A, MRMSrcReg,
 317                            (ops VR128:$dst, VR128:$src1, GR32:$src2),
 318                            "cvtsi2ss {$src2, $dst|$dst, $src2}",
 319                            [(set VR128:$dst, (int_x86_sse_cvtsi2ss VR128:$src1,
 320                                               GR32:$src2))]>;
 321   def Int_CVTSI2SSrm : SSI<0x2A, MRMSrcMem,
 322                            (ops VR128:$dst, VR128:$src1, i32mem:$src2),
 323                            "cvtsi2ss {$src2, $dst|$dst, $src2}",
 324                            [(set VR128:$dst, (int_x86_sse_cvtsi2ss VR128:$src1,
 325                                               (loadi32 addr:$src2)))]>;
 326 }
 327
 328 // Comparison instructions
 329 let isTwoAddress = 1 in {
 330   def CMPSSrr : SSI<0xC2, MRMSrcReg,
 331                     (ops FR32:$dst, FR32:$src1, FR32:$src, SSECC:$cc),
 332                     "cmp${cc}ss {$src, $dst|$dst, $src}",
 333                     []>;
 334   def CMPSSrm : SSI<0xC2, MRMSrcMem,
 335                     (ops FR32:$dst, FR32:$src1, f32mem:$src, SSECC:$cc),
 336                     "cmp${cc}ss {$src, $dst|$dst, $src}", []>;
 337 }
 338
 339 def UCOMISSrr: PSI<0x2E, MRMSrcReg, (ops FR32:$src1, FR32:$src2),
 340                    "ucomiss {$src2, $src1|$src1, $src2}",
 341                    [(X86cmp FR32:$src1, FR32:$src2)]>;
 342 def UCOMISSrm: PSI<0x2E, MRMSrcMem, (ops FR32:$src1, f32mem:$src2),
 343                    "ucomiss {$src2, $src1|$src1, $src2}",
 344                    [(X86cmp FR32:$src1, (loadf32 addr:$src2))]>;
 345
 346 // Aliases to match intrinsics which expect XMM operand(s).
 347 let isTwoAddress = 1 in {
 348   def Int_CMPSSrr : SSI<0xC2, MRMSrcReg,
 349                         (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
 350                         "cmp${cc}ss {$src, $dst|$dst, $src}",
 351                         [(set VR128:$dst, (int_x86_sse_cmp_ss VR128:$src1,
 352                                            VR128:$src, imm:$cc))]>;
 353   def Int_CMPSSrm : SSI<0xC2, MRMSrcMem,
 354                         (ops VR128:$dst, VR128:$src1, f32mem:$src, SSECC:$cc),
 355                         "cmp${cc}ss {$src, $dst|$dst, $src}",
 356                         [(set VR128:$dst, (int_x86_sse_cmp_ss VR128:$src1,
 357                                            (load addr:$src), imm:$cc))]>;
 358 }
 359
 360 def Int_UCOMISSrr: PSI<0x2E, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 361                        "ucomiss {$src2, $src1|$src1, $src2}",
 362                        [(X86ucomi (v4f32 VR128:$src1), VR128:$src2)]>;
 363 def Int_UCOMISSrm: PSI<0x2E, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 364                        "ucomiss {$src2, $src1|$src1, $src2}",
 365                        [(X86ucomi (v4f32 VR128:$src1), (load addr:$src2))]>;
 366
 367 def Int_COMISSrr: PSI<0x2F, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 368                       "comiss {$src2, $src1|$src1, $src2}",
 369                       [(X86comi (v4f32 VR128:$src1), VR128:$src2)]>;
 370 def Int_COMISSrm: PSI<0x2F, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 371                       "comiss {$src2, $src1|$src1, $src2}",
 372                       [(X86comi (v4f32 VR128:$src1), (load addr:$src2))]>;
 373
 374 // Aliases of packed SSE1 instructions for scalar use. These all have names that
 375 // start with 'Fs'.
 376
 377 // Alias instructions that map fld0 to pxor for sse.
 378 def FsFLD0SS : I<0xEF, MRMInitReg, (ops FR32:$dst),
 379                  "pxor $dst, $dst", [(set FR32:$dst, fp32imm0)]>,
 380                Requires<[HasSSE1]>, TB, OpSize;
 381
 382 // Alias instruction to do FR32 reg-to-reg copy using movaps. Upper bits are
 383 // disregarded.
 384 def FsMOVAPSrr : PSI<0x28, MRMSrcReg, (ops FR32:$dst, FR32:$src),
 385                      "movaps {$src, $dst|$dst, $src}", []>;
 386
 387 // Alias instruction to load FR32 from f128mem using movaps. Upper bits are
 388 // disregarded.
 389 def FsMOVAPSrm : PSI<0x28, MRMSrcMem, (ops FR32:$dst, f128mem:$src),
 390                      "movaps {$src, $dst|$dst, $src}",
 391                      [(set FR32:$dst, (X86loadpf32 addr:$src))]>;
 392
 393 // Alias bitwise logical operations using SSE logical ops on packed FP values.
 394 let isTwoAddress = 1 in {
 395 let isCommutable = 1 in {
 396   def FsANDPSrr : PSI<0x54, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 397                       "andps {$src2, $dst|$dst, $src2}",
 398                       [(set FR32:$dst, (X86fand FR32:$src1, FR32:$src2))]>;
 399   def FsORPSrr  : PSI<0x56, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 400                       "orps {$src2, $dst|$dst, $src2}",
 401                       [(set FR32:$dst, (X86for FR32:$src1, FR32:$src2))]>;
 402   def FsXORPSrr : PSI<0x57, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 403                       "xorps {$src2, $dst|$dst, $src2}",
 404                       [(set FR32:$dst, (X86fxor FR32:$src1, FR32:$src2))]>;
 405 }
 406
 407 def FsANDPSrm : PSI<0x54, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 408                     "andps {$src2, $dst|$dst, $src2}",
 409                     [(set FR32:$dst, (X86fand FR32:$src1,
 410                                       (X86loadpf32 addr:$src2)))]>;
 411 def FsORPSrm  : PSI<0x56, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 412                     "orps {$src2, $dst|$dst, $src2}",
 413                     [(set FR32:$dst, (X86for FR32:$src1,
 414                                       (X86loadpf32 addr:$src2)))]>;
 415 def FsXORPSrm : PSI<0x57, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 416                     "xorps {$src2, $dst|$dst, $src2}",
 417                     [(set FR32:$dst, (X86fxor FR32:$src1,
 418                                       (X86loadpf32 addr:$src2)))]>;
 419
 420 def FsANDNPSrr : PSI<0x55, MRMSrcReg,
 421                      (ops FR32:$dst, FR32:$src1, FR32:$src2),
 422                      "andnps {$src2, $dst|$dst, $src2}", []>;
 423 def FsANDNPSrm : PSI<0x55, MRMSrcMem,
 424                      (ops FR32:$dst, FR32:$src1, f128mem:$src2),
 425                      "andnps {$src2, $dst|$dst, $src2}", []>;
 426 }
 427
 428 /// scalar_sse1_fp_binop_rm - Scalar SSE1 binops come in three basic forms:
 429 ///
 430 ///  1. f32 - This comes in SSE1 form for floats.
 431 ///  2. rr vs rm - They include a reg+reg form and a reg+mem form.
 432 ///
 433 /// In addition, scalar SSE ops have an intrinsic form.  This form is unlike the
 434 /// normal form, in that they take an entire vector (instead of a scalar) and
 435 /// leave the top elements undefined.  This adds another two variants of the
 436 /// above permutations, giving us 8 forms for 'instruction'.
 437 ///
 438 let isTwoAddress = 1 in {
 439 multiclass scalar_sse1_fp_binop_rm<bits<8> opc, string OpcodeStr,
 440                                    SDNode OpNode, Intrinsic F32Int,
 441                                    bit Commutable = 0> {
 442   // Scalar operation, reg+reg.
 443   def SSrr : SSI<opc, MRMSrcReg, (ops FR32:$dst, FR32:$src1, FR32:$src2),
 444                  !strconcat(OpcodeStr, "ss {$src2, $dst|$dst, $src2}"),
 445                  [(set FR32:$dst, (OpNode FR32:$src1, FR32:$src2))]> {
 446     let isCommutable = Commutable;
 447   }
 448
 449   // Scalar operation, reg+mem.
 450   def SSrm : SSI<opc, MRMSrcMem, (ops FR32:$dst, FR32:$src1, f32mem:$src2),
 451                  !strconcat(OpcodeStr, "ss {$src2, $dst|$dst, $src2}"),
 452                  [(set FR32:$dst, (OpNode FR32:$src1, (load addr:$src2)))]>;
 453
 454   // Vector intrinsic operation, reg+reg.
 455   def SSrr_Int : SSI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 456                      !strconcat(OpcodeStr, "ss {$src2, $dst|$dst, $src2}"),
 457                      [(set VR128:$dst, (F32Int VR128:$src1, VR128:$src2))]> {
 458     let isCommutable = Commutable;
 459   }
 460
 461   // Vector intrinsic operation, reg+mem.
 462   def SSrm_Int : SSI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, ssmem:$src2),
 463                      !strconcat(OpcodeStr, "ss {$src2, $dst|$dst, $src2}"),
 464                      [(set VR128:$dst, (F32Int VR128:$src1,
 465                                                sse_load_f32:$src2))]>;
 466 }
 467 }
 468
 469 // Arithmetic instructions
 470 defm ADD : scalar_sse1_fp_binop_rm<0x58, "add", fadd, int_x86_sse_add_ss, 1>;
 471 defm MUL : scalar_sse1_fp_binop_rm<0x59, "mul", fmul, int_x86_sse_mul_ss, 1>;
 472 defm SUB : scalar_sse1_fp_binop_rm<0x5C, "sub", fsub, int_x86_sse_sub_ss>;
 473 defm DIV : scalar_sse1_fp_binop_rm<0x5E, "div", fdiv, int_x86_sse_div_ss>;
 474
 475 defm MAX : scalar_sse1_fp_binop_rm<0x5F, "max", X86fmax, int_x86_sse_max_ss>;
 476 defm MIN : scalar_sse1_fp_binop_rm<0x5D, "min", X86fmin, int_x86_sse_min_ss>;
 477
 478 //===----------------------------------------------------------------------===//
 479 // SSE packed FP Instructions
 480
 481 // Move Instructions
 482 def MOVAPSrr : PSI<0x28, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 483                    "movaps {$src, $dst|$dst, $src}", []>;
 484 def MOVAPSrm : PSI<0x28, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 485                    "movaps {$src, $dst|$dst, $src}",
 486                    [(set VR128:$dst, (loadv4f32 addr:$src))]>;
 487
 488 def MOVAPSmr : PSI<0x29, MRMDestMem, (ops f128mem:$dst, VR128:$src),
 489                    "movaps {$src, $dst|$dst, $src}",
 490                    [(store (v4f32 VR128:$src), addr:$dst)]>;
 491
 492 def MOVUPSrr : PSI<0x10, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 493                    "movups {$src, $dst|$dst, $src}", []>;
 494 def MOVUPSrm : PSI<0x10, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
 495                    "movups {$src, $dst|$dst, $src}",
 496                    [(set VR128:$dst, (int_x86_sse_loadu_ps addr:$src))]>;
 497 def MOVUPSmr : PSI<0x11, MRMDestMem, (ops f128mem:$dst, VR128:$src),
 498                    "movups {$src, $dst|$dst, $src}",
 499                    [(int_x86_sse_storeu_ps addr:$dst, VR128:$src)]>;
 500
 501 let isTwoAddress = 1 in {
 502   let AddedComplexity = 20 in {
 503     def MOVLPSrm : PSI<0x12, MRMSrcMem,
 504                        (ops VR128:$dst, VR128:$src1, f64mem:$src2),
 505                        "movlps {$src2, $dst|$dst, $src2}",
 506                        [(set VR128:$dst,
 507                          (v4f32 (vector_shuffle VR128:$src1,
 508                          (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2)))),
 509                                  MOVLP_shuffle_mask)))]>;
 510     def MOVHPSrm : PSI<0x16, MRMSrcMem,
 511                        (ops VR128:$dst, VR128:$src1, f64mem:$src2),
 512                        "movhps {$src2, $dst|$dst, $src2}",
 513                        [(set VR128:$dst,
 514                          (v4f32 (vector_shuffle VR128:$src1,
 515                          (bc_v4f32 (v2f64 (scalar_to_vector (loadf64 addr:$src2)))),
 516                                  MOVHP_shuffle_mask)))]>;
 517   } // AddedComplexity
 518 } // isTwoAddress
 519
 520 def MOVLPSmr : PSI<0x13, MRMDestMem, (ops f64mem:$dst, VR128:$src),
 521                    "movlps {$src, $dst|$dst, $src}",
 522                    [(store (f64 (vector_extract (bc_v2f64 (v4f32 VR128:$src)),
 523                                  (iPTR 0))), addr:$dst)]>;
 524
 525 // v2f64 extract element 1 is always custom lowered to unpack high to low
 526 // and extract element 0 so the non-store version isn't too horrible.
 527 def MOVHPSmr : PSI<0x17, MRMDestMem, (ops f64mem:$dst, VR128:$src),
 528                    "movhps {$src, $dst|$dst, $src}",
 529                    [(store (f64 (vector_extract
 530                                  (v2f64 (vector_shuffle
 531                                          (bc_v2f64 (v4f32 VR128:$src)), (undef),
 532                                          UNPCKH_shuffle_mask)), (iPTR 0))),
 533                      addr:$dst)]>;
 534
 535 let isTwoAddress = 1 in {
 536 let AddedComplexity = 15 in {
 537 def MOVLHPSrr : PSI<0x16, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 538                     "movlhps {$src2, $dst|$dst, $src2}",
 539                     [(set VR128:$dst,
 540                       (v4f32 (vector_shuffle VR128:$src1, VR128:$src2,
 541                               MOVHP_shuffle_mask)))]>;
 542
 543 def MOVHLPSrr : PSI<0x12, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 544                     "movhlps {$src2, $dst|$dst, $src2}",
 545                     [(set VR128:$dst,
 546                       (v4f32 (vector_shuffle VR128:$src1, VR128:$src2,
 547                               MOVHLPS_shuffle_mask)))]>;
 548 } // AddedComplexity
 549 } // isTwoAddress
 550
 551
 552
 553 /// packed_sse1_fp_binop_rm - Packed SSE binops come in three basic forms:
 554 ///  1. v4f32    - This comes in SSE1 form for float.
 555 ///  2. rr vs rm - They include a reg+reg form and a ref+mem form.
 556 ///
 557 let isTwoAddress = 1 in {
 558 multiclass packed_sse1_fp_binop_rm<bits<8> opc, string OpcodeStr,
 559                                    SDNode OpNode, bit Commutable = 0> {
 560   // Packed operation, reg+reg.
 561   def PSrr : PSI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 562                !strconcat(OpcodeStr, "ps {$src2, $dst|$dst, $src2}"),
 563                [(set VR128:$dst, (v4f32 (OpNode VR128:$src1, VR128:$src2)))]> {
 564     let isCommutable = Commutable;
 565   }
 566
 567   // Packed operation, reg+mem.
 568   def PSrm : PSI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 569                  !strconcat(OpcodeStr, "ps {$src2, $dst|$dst, $src2}"),
 570                  [(set VR128:$dst, (OpNode VR128:$src1, (loadv4f32 addr:$src2)))]>;
 571 }
 572 }
 573
 574 defm ADD : packed_sse1_fp_binop_rm<0x58, "add", fadd, 1>;
 575 defm MUL : packed_sse1_fp_binop_rm<0x59, "mul", fmul, 1>;
 576 defm DIV : packed_sse1_fp_binop_rm<0x5E, "div", fdiv>;
 577 defm SUB : packed_sse1_fp_binop_rm<0x5C, "sub", fsub>;
 578
 579 // Arithmetic
 580
 581 class PS_Intr<bits<8> o, string OpcodeStr, Intrinsic IntId>
 582   : PSI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 583         !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
 584         [(set VR128:$dst, (IntId VR128:$src))]>;
 585 class PS_Intm<bits<8> o, string OpcodeStr, Intrinsic IntId>
 586   : PSI<o, MRMSrcMem, (ops VR128:$dst, f32mem:$src),
 587         !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
 588         [(set VR128:$dst, (IntId (load addr:$src)))]>;
 589
 590 class PS_Intrr<bits<8> o, string OpcodeStr, Intrinsic IntId>
 591   : PSI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
 592         !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
 593         [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
 594 class PS_Intrm<bits<8> o, string OpcodeStr, Intrinsic IntId>
 595   : PSI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f32mem:$src2),
 596         !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
 597         [(set VR128:$dst, (IntId VR128:$src1, (load addr:$src2)))]>;
 598
 599 def SQRTPSr  : PS_Intr<0x51, "sqrtps", int_x86_sse_sqrt_ps>;
 600 def SQRTPSm  : PS_Intm<0x51, "sqrtps", int_x86_sse_sqrt_ps>;
 601
 602 def RSQRTPSr : PS_Intr<0x52, "rsqrtps", int_x86_sse_rsqrt_ps>;
 603 def RSQRTPSm : PS_Intm<0x52, "rsqrtps", int_x86_sse_rsqrt_ps>;
 604 def RCPPSr   : PS_Intr<0x53, "rcpps", int_x86_sse_rcp_ps>;
 605 def RCPPSm   : PS_Intm<0x53, "rcpps", int_x86_sse_rcp_ps>;
 606
 607 let isTwoAddress = 1 in {
 608   let isCommutable = 1 in {
 609     def MAXPSrr  : PS_Intrr<0x5F, "maxps", int_x86_sse_max_ps>;
 610     def MINPSrr  : PS_Intrr<0x5D, "minps", int_x86_sse_min_ps>;
 611   }
 612
 613   def MAXPSrm  : PS_Intrm<0x5F, "maxps", int_x86_sse_max_ps>;
 614   def MINPSrm  : PS_Intrm<0x5D, "minps", int_x86_sse_min_ps>;
 615 }
 616
 617 // Logical
 618 let isTwoAddress = 1 in {
 619   let isCommutable = 1 in {
 620     def ANDPSrr : PSI<0x54, MRMSrcReg,
 621                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
 622                       "andps {$src2, $dst|$dst, $src2}",
 623                       [(set VR128:$dst, (v2i64
 624                                          (and VR128:$src1, VR128:$src2)))]>;
 625     def ORPSrr  : PSI<0x56, MRMSrcReg,
 626                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
 627                       "orps {$src2, $dst|$dst, $src2}",
 628                       [(set VR128:$dst, (v2i64
 629                                          (or VR128:$src1, VR128:$src2)))]>;
 630     def XORPSrr : PSI<0x57, MRMSrcReg,
 631                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
 632                       "xorps {$src2, $dst|$dst, $src2}",
 633                       [(set VR128:$dst, (v2i64
 634                                          (xor VR128:$src1, VR128:$src2)))]>;
 635   }
 636
 637   def ANDPSrm : PSI<0x54, MRMSrcMem,
 638                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 639                     "andps {$src2, $dst|$dst, $src2}",
 640                     [(set VR128:$dst, (and VR128:$src1,
 641                                        (bc_v2i64 (loadv4f32 addr:$src2))))]>;
 642   def ORPSrm  : PSI<0x56, MRMSrcMem,
 643                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 644                     "orps {$src2, $dst|$dst, $src2}",
 645                     [(set VR128:$dst, (or VR128:$src1,
 646                                        (bc_v2i64 (loadv4f32 addr:$src2))))]>;
 647   def XORPSrm : PSI<0x57, MRMSrcMem,
 648                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 649                     "xorps {$src2, $dst|$dst, $src2}",
 650                     [(set VR128:$dst, (xor VR128:$src1,
 651                                        (bc_v2i64 (loadv4f32 addr:$src2))))]>;
 652   def ANDNPSrr : PSI<0x55, MRMSrcReg,
 653                      (ops VR128:$dst, VR128:$src1, VR128:$src2),
 654                      "andnps {$src2, $dst|$dst, $src2}",
 655                      [(set VR128:$dst,
 656                        (v2i64 (and (xor VR128:$src1,
 657                                     (bc_v2i64 (v4i32 immAllOnesV))),
 658                                VR128:$src2)))]>;
 659   def ANDNPSrm : PSI<0x55, MRMSrcMem,
 660                      (ops VR128:$dst, VR128:$src1,f128mem:$src2),
 661                      "andnps {$src2, $dst|$dst, $src2}",
 662                      [(set VR128:$dst,
 663                        (v2i64 (and (xor VR128:$src1,
 664                                     (bc_v2i64 (v4i32 immAllOnesV))),
 665                                (bc_v2i64 (loadv4f32 addr:$src2)))))]>;
 666 }
 667
 668 let isTwoAddress = 1 in {
 669   def CMPPSrri : PSIi8<0xC2, MRMSrcReg,
 670                       (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
 671                       "cmp${cc}ps {$src, $dst|$dst, $src}",
 672                       [(set VR128:$dst, (int_x86_sse_cmp_ps VR128:$src1,
 673                                          VR128:$src, imm:$cc))]>;
 674   def CMPPSrmi : PSIi8<0xC2, MRMSrcMem,
 675                       (ops VR128:$dst, VR128:$src1, f128mem:$src, SSECC:$cc),
 676                       "cmp${cc}ps {$src, $dst|$dst, $src}",
 677                       [(set VR128:$dst, (int_x86_sse_cmp_ps VR128:$src1,
 678                                          (load addr:$src), imm:$cc))]>;
 679 }
 680
 681 // Shuffle and unpack instructions
 682 let isTwoAddress = 1 in {
 683   let isConvertibleToThreeAddress = 1 in // Convert to pshufd
 684     def SHUFPSrri : PSIi8<0xC6, MRMSrcReg,
 685                           (ops VR128:$dst, VR128:$src1,
 686                            VR128:$src2, i32i8imm:$src3),
 687                           "shufps {$src3, $src2, $dst|$dst, $src2, $src3}",
 688                           [(set VR128:$dst,
 689                             (v4f32 (vector_shuffle
 690                                     VR128:$src1, VR128:$src2,
 691                                     SHUFP_shuffle_mask:$src3)))]>;
 692   def SHUFPSrmi : PSIi8<0xC6, MRMSrcMem,
 693                         (ops VR128:$dst, VR128:$src1,
 694                          f128mem:$src2, i32i8imm:$src3),
 695                         "shufps {$src3, $src2, $dst|$dst, $src2, $src3}",
 696                         [(set VR128:$dst,
 697                           (v4f32 (vector_shuffle
 698                                   VR128:$src1, (load addr:$src2),
 699                                   SHUFP_shuffle_mask:$src3)))]>;
 700
 701   let AddedComplexity = 10 in {
 702     def UNPCKHPSrr : PSI<0x15, MRMSrcReg,
 703                          (ops VR128:$dst, VR128:$src1, VR128:$src2),
 704                          "unpckhps {$src2, $dst|$dst, $src2}",
 705                          [(set VR128:$dst,
 706                            (v4f32 (vector_shuffle
 707                                    VR128:$src1, VR128:$src2,
 708                                    UNPCKH_shuffle_mask)))]>;
 709     def UNPCKHPSrm : PSI<0x15, MRMSrcMem,
 710                          (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 711                          "unpckhps {$src2, $dst|$dst, $src2}",
 712                          [(set VR128:$dst,
 713                            (v4f32 (vector_shuffle
 714                                    VR128:$src1, (load addr:$src2),
 715                                    UNPCKH_shuffle_mask)))]>;
 716
 717     def UNPCKLPSrr : PSI<0x14, MRMSrcReg,
 718                          (ops VR128:$dst, VR128:$src1, VR128:$src2),
 719                          "unpcklps {$src2, $dst|$dst, $src2}",
 720                          [(set VR128:$dst,
 721                            (v4f32 (vector_shuffle
 722                                    VR128:$src1, VR128:$src2,
 723                                    UNPCKL_shuffle_mask)))]>;
 724     def UNPCKLPSrm : PSI<0x14, MRMSrcMem,
 725                          (ops VR128:$dst, VR128:$src1, f128mem:$src2),
 726                          "unpcklps {$src2, $dst|$dst, $src2}",
 727                          [(set VR128:$dst,
 728                            (v4f32 (vector_shuffle
 729                                    VR128:$src1, (load addr:$src2),
 730                                    UNPCKL_shuffle_mask)))]>;
 731   } // AddedComplexity
 732 } // isTwoAddress
 733
 734 // Mask creation
 735 def MOVMSKPSrr : PSI<0x50, MRMSrcReg, (ops GR32:$dst, VR128:$src),
 736                      "movmskps {$src, $dst|$dst, $src}",
 737                      [(set GR32:$dst, (int_x86_sse_movmsk_ps VR128:$src))]>;
 738 def MOVMSKPDrr : PSI<0x50, MRMSrcReg, (ops GR32:$dst, VR128:$src),
 739                      "movmskpd {$src, $dst|$dst, $src}",
 740                      [(set GR32:$dst, (int_x86_sse2_movmsk_pd VR128:$src))]>;
 741
 742 // Prefetching loads.
 743 // TODO: no intrinsics for these?
 744 def PREFETCHT0   : PSI<0x18, MRM1m, (ops i8mem:$src), "prefetcht0 $src", []>;
 745 def PREFETCHT1   : PSI<0x18, MRM2m, (ops i8mem:$src), "prefetcht1 $src", []>;
 746 def PREFETCHT2   : PSI<0x18, MRM3m, (ops i8mem:$src), "prefetcht2 $src", []>;
 747 def PREFETCHNTA  : PSI<0x18, MRM0m, (ops i8mem:$src), "prefetchnta $src", []>;
 748
 749 // Non-temporal stores
 750 def MOVNTPSmr : PSI<0x2B, MRMDestMem, (ops i128mem:$dst, VR128:$src),
 751                     "movntps {$src, $dst|$dst, $src}",
 752                     [(int_x86_sse_movnt_ps addr:$dst, VR128:$src)]>;
 753
 754 // Load, store, and memory fence
 755 def SFENCE : PSI<0xAE, MRM7m, (ops), "sfence", [(int_x86_sse_sfence)]>;
 756
 757 // MXCSR register
 758 def LDMXCSR : PSI<0xAE, MRM2m, (ops i32mem:$src),
 759                   "ldmxcsr $src", [(int_x86_sse_ldmxcsr addr:$src)]>;
 760 def STMXCSR : PSI<0xAE, MRM3m, (ops i32mem:$dst),
 761                   "stmxcsr $dst", [(int_x86_sse_stmxcsr addr:$dst)]>;
 762
 763 // Alias instructions that map zero vector to pxor / xorp* for sse.
 764 // FIXME: remove when we can teach regalloc that xor reg, reg is ok.
 765 let isReMaterializable = 1 in
 766 def V_SET0 : PSI<0x57, MRMInitReg, (ops VR128:$dst),
 767                  "xorps $dst, $dst",
 768                  [(set VR128:$dst, (v4f32 immAllZerosV))]>;
 769
 770 // FR32 to 128-bit vector conversion.
 771 def MOVSS2PSrr : SSI<0x10, MRMSrcReg, (ops VR128:$dst, FR32:$src),
 772                       "movss {$src, $dst|$dst, $src}",
 773                       [(set VR128:$dst,
 774                         (v4f32 (scalar_to_vector FR32:$src)))]>;
 775 def MOVSS2PSrm : SSI<0x10, MRMSrcMem, (ops VR128:$dst, f32mem:$src),
 776                      "movss {$src, $dst|$dst, $src}",
 777                      [(set VR128:$dst,
 778                        (v4f32 (scalar_to_vector (loadf32 addr:$src))))]>;
 779
 780 // FIXME: may not be able to eliminate this movss with coalescing the src and
 781 // dest register classes are different. We really want to write this pattern
 782 // like this:
 783 // def : Pat<(f32 (vector_extract (v4f32 VR128:$src), (iPTR 0))),
 784 //           (f32 FR32:$src)>;
 785 def MOVPS2SSrr : SSI<0x10, MRMSrcReg, (ops FR32:$dst, VR128:$src),
 786                      "movss {$src, $dst|$dst, $src}",
 787                      [(set FR32:$dst, (vector_extract (v4f32 VR128:$src),
 788                                        (iPTR 0)))]>;
 789 def MOVPS2SSmr : SSI<0x11, MRMDestMem, (ops f32mem:$dst, VR128:$src),
 790                      "movss {$src, $dst|$dst, $src}",
 791                      [(store (f32 (vector_extract (v4f32 VR128:$src),
 792                                    (iPTR 0))), addr:$dst)]>;
 793
 794
 795 // Move to lower bits of a VR128, leaving upper bits alone.
 796 // Three operand (but two address) aliases.
 797 let isTwoAddress = 1 in {
 798   def MOVLSS2PSrr : SSI<0x10, MRMSrcReg,
 799                         (ops VR128:$dst, VR128:$src1, FR32:$src2),
 800                         "movss {$src2, $dst|$dst, $src2}", []>;
 801
 802   let AddedComplexity = 15 in
 803     def MOVLPSrr : SSI<0x10, MRMSrcReg,
 804                        (ops VR128:$dst, VR128:$src1, VR128:$src2),
 805                        "movss {$src2, $dst|$dst, $src2}",
 806                        [(set VR128:$dst,
 807                          (v4f32 (vector_shuffle VR128:$src1, VR128:$src2,
 808                                  MOVL_shuffle_mask)))]>;
 809 }
 810
 811 // Move to lower bits of a VR128 and zeroing upper bits.
 812 // Loading from memory automatically zeroing upper bits.
 813 let AddedComplexity = 20 in
 814 def MOVZSS2PSrm : SSI<0x10, MRMSrcMem, (ops VR128:$dst, f32mem:$src),
 815                       "movss {$src, $dst|$dst, $src}",
 816                       [(set VR128:$dst, (v4f32 (vector_shuffle immAllZerosV,
 817                                  (v4f32 (scalar_to_vector (loadf32 addr:$src))),
 818                                                 MOVL_shuffle_mask)))]>;
 819
 820
 821 //===----------------------------------------------------------------------===//
 822 // SSE2 Instructions
 823 //===----------------------------------------------------------------------===//
 824
 825 // SSE2 Instruction Templates:
 826 //
 827 //   SDI   - SSE2 instructions with XD prefix.
 828 //   PDI   - SSE2 instructions with TB and OpSize prefixes.
 829 //   PDIi8 - SSE2 instructions with ImmT == Imm8 and TB and OpSize prefixes.
 830
 831 class SDI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 832       : I<o, F, ops, asm, pattern>, XD, Requires<[HasSSE2]>;
 833 class PDI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 834       : I<o, F, ops, asm, pattern>, TB, OpSize, Requires<[HasSSE2]>;
 835 class PDIi8<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
 836       : Ii8<o, F, ops, asm, pattern>, TB, OpSize, Requires<[HasSSE2]>;
 837
 838 // Helpers for defining instructions that directly correspond to intrinsics.
 839 multiclass SD_IntUnary<bits<8> o, string OpcodeStr, Intrinsic IntId> {
 840   def r : SDI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src),
 841               !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
 842               [(set VR128:$dst, (v2f64 (IntId VR128:$src)))]>;
 843   def m : SDI<o, MRMSrcMem, (ops VR128:$dst, sdmem:$src),
 844               !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
 845               [(set VR128:$dst, (v2f64 (IntId sse_load_f64:$src)))]>;
 846 }
 847
 848 // Move Instructions
 849 def MOVSDrr : SDI<0x10, MRMSrcReg, (ops FR64:$dst, FR64:$src),
 850                   "movsd {$src, $dst|$dst, $src}", []>;
 851 def MOVSDrm : SDI<0x10, MRMSrcMem, (ops FR64:$dst, f64mem:$src),
 852                   "movsd {$src, $dst|$dst, $src}",
 853                   [(set FR64:$dst, (loadf64 addr:$src))]>;
 854 def MOVSDmr : SDI<0x11, MRMDestMem, (ops f64mem:$dst, FR64:$src),
 855                   "movsd {$src, $dst|$dst, $src}",
 856                   [(store FR64:$src, addr:$dst)]>;
 857
 858 def SQRTSDr : SDI<0x51, MRMSrcReg, (ops FR64:$dst, FR64:$src),
 859                   "sqrtsd {$src, $dst|$dst, $src}",
 860                   [(set FR64:$dst, (fsqrt FR64:$src))]>;
 861 def SQRTSDm : SDI<0x51, MRMSrcMem, (ops FR64:$dst, f64mem:$src),
 862                   "sqrtsd {$src, $dst|$dst, $src}",
 863                   [(set FR64:$dst, (fsqrt (loadf64 addr:$src)))]>;
 864
 865 // Aliases to match intrinsics which expect XMM operand(s).
 866 defm SQRTSD_Int : SD_IntUnary<0x51, "sqrtsd" , int_x86_sse2_sqrt_sd>;
 867
 868 // Conversion instructions
 869 def CVTTSD2SIrr : SDI<0x2C, MRMSrcReg, (ops GR32:$dst, FR64:$src),
 870                       "cvttsd2si {$src, $dst|$dst, $src}",
 871                       [(set GR32:$dst, (fp_to_sint FR64:$src))]>;
 872 def CVTTSD2SIrm : SDI<0x2C, MRMSrcMem, (ops GR32:$dst, f64mem:$src),
 873                       "cvttsd2si {$src, $dst|$dst, $src}",
 874                       [(set GR32:$dst, (fp_to_sint (loadf64 addr:$src)))]>;
 875 def CVTSD2SSrr  : SDI<0x5A, MRMSrcReg, (ops FR32:$dst, FR64:$src),
 876                       "cvtsd2ss {$src, $dst|$dst, $src}",
 877                       [(set FR32:$dst, (fround FR64:$src))]>;
 878 def CVTSD2SSrm  : SDI<0x5A, MRMSrcMem, (ops FR32:$dst, f64mem:$src),
 879                       "cvtsd2ss {$src, $dst|$dst, $src}",
 880                       [(set FR32:$dst, (fround (loadf64 addr:$src)))]>;
 881 def CVTSI2SDrr  : SDI<0x2A, MRMSrcReg, (ops FR64:$dst, GR32:$src),
 882                       "cvtsi2sd {$src, $dst|$dst, $src}",
 883                       [(set FR64:$dst, (sint_to_fp GR32:$src))]>;
 884 def CVTSI2SDrm  : SDI<0x2A, MRMSrcMem, (ops FR64:$dst, i32mem:$src),
 885                       "cvtsi2sd {$src, $dst|$dst, $src}",
 886                       [(set FR64:$dst, (sint_to_fp (loadi32 addr:$src)))]>;
 887
 888 // SSE2 instructions with XS prefix
 889 def CVTSS2SDrr : I<0x5A, MRMSrcReg, (ops FR64:$dst, FR32:$src),
 890                    "cvtss2sd {$src, $dst|$dst, $src}",
 891                    [(set FR64:$dst, (fextend FR32:$src))]>, XS,
 892                  Requires<[HasSSE2]>;
 893 def CVTSS2SDrm : I<0x5A, MRMSrcMem, (ops FR64:$dst, f32mem:$src),
 894                    "cvtss2sd {$src, $dst|$dst, $src}",
 895                    [(set FR64:$dst, (extloadf32 addr:$src))]>, XS,
 896                  Requires<[HasSSE2]>;
 897
 898 // Match intrinsics which expect XMM operand(s).
 899 def Int_CVTSD2SIrr : SDI<0x2D, MRMSrcReg, (ops GR32:$dst, VR128:$src),
 900                          "cvtsd2si {$src, $dst|$dst, $src}",
 901                          [(set GR32:$dst, (int_x86_sse2_cvtsd2si VR128:$src))]>;
 902 def Int_CVTSD2SIrm : SDI<0x2D, MRMSrcMem, (ops GR32:$dst, f128mem:$src),
 903                          "cvtsd2si {$src, $dst|$dst, $src}",
 904                          [(set GR32:$dst, (int_x86_sse2_cvtsd2si
 905                                            (load addr:$src)))]>;
 906
 907 // Aliases for intrinsics
 908 def Int_CVTTSD2SIrr : SDI<0x2C, MRMSrcReg, (ops GR32:$dst, VR128:$src),
 909                           "cvttsd2si {$src, $dst|$dst, $src}",
 910                           [(set GR32:$dst,
 911                             (int_x86_sse2_cvttsd2si VR128:$src))]>;
 912 def Int_CVTTSD2SIrm : SDI<0x2C, MRMSrcMem, (ops GR32:$dst, f128mem:$src),
 913                           "cvttsd2si {$src, $dst|$dst, $src}",
 914                           [(set GR32:$dst, (int_x86_sse2_cvttsd2si
 915                                             (load addr:$src)))]>;
 916
 917 // Comparison instructions
 918 let isTwoAddress = 1 in {
 919   def CMPSDrr : SDI<0xC2, MRMSrcReg,
 920                     (ops FR64:$dst, FR64:$src1, FR64:$src, SSECC:$cc),
 921                     "cmp${cc}sd {$src, $dst|$dst, $src}", []>;
 922   def CMPSDrm : SDI<0xC2, MRMSrcMem,
 923                     (ops FR64:$dst, FR64:$src1, f64mem:$src, SSECC:$cc),
 924                     "cmp${cc}sd {$src, $dst|$dst, $src}", []>;
 925 }
 926
 927 def UCOMISDrr: PDI<0x2E, MRMSrcReg, (ops FR64:$src1, FR64:$src2),
 928                    "ucomisd {$src2, $src1|$src1, $src2}",
 929                    [(X86cmp FR64:$src1, FR64:$src2)]>;
 930 def UCOMISDrm: PDI<0x2E, MRMSrcMem, (ops FR64:$src1, f64mem:$src2),
 931                    "ucomisd {$src2, $src1|$src1, $src2}",
 932                    [(X86cmp FR64:$src1, (loadf64 addr:$src2))]>;
 933
 934 // Aliases to match intrinsics which expect XMM operand(s).
 935 let isTwoAddress = 1 in {
 936   def Int_CMPSDrr : SDI<0xC2, MRMSrcReg,
 937                         (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
 938                         "cmp${cc}sd {$src, $dst|$dst, $src}",
 939                         [(set VR128:$dst, (int_x86_sse2_cmp_sd VR128:$src1,
 940                                            VR128:$src, imm:$cc))]>;
 941   def Int_CMPSDrm : SDI<0xC2, MRMSrcMem,
 942                         (ops VR128:$dst, VR128:$src1, f64mem:$src, SSECC:$cc),
 943                         "cmp${cc}sd {$src, $dst|$dst, $src}",
 944                         [(set VR128:$dst, (int_x86_sse2_cmp_sd VR128:$src1,
 945                                            (load addr:$src), imm:$cc))]>;
 946 }
 947
 948 def Int_UCOMISDrr: PDI<0x2E, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 949                        "ucomisd {$src2, $src1|$src1, $src2}",
 950                        [(X86ucomi (v2f64 VR128:$src1), (v2f64 VR128:$src2))]>;
 951 def Int_UCOMISDrm: PDI<0x2E, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 952                        "ucomisd {$src2, $src1|$src1, $src2}",
 953                        [(X86ucomi (v2f64 VR128:$src1), (load addr:$src2))]>;
 954
 955 def Int_COMISDrr: PDI<0x2F, MRMSrcReg, (ops VR128:$src1, VR128:$src2),
 956                       "comisd {$src2, $src1|$src1, $src2}",
 957                       [(X86comi (v2f64 VR128:$src1), (v2f64 VR128:$src2))]>;
 958 def Int_COMISDrm: PDI<0x2F, MRMSrcMem, (ops VR128:$src1, f128mem:$src2),
 959                       "comisd {$src2, $src1|$src1, $src2}",
 960                       [(X86comi (v2f64 VR128:$src1), (load addr:$src2))]>;
 961
 962 // Aliases of packed SSE2 instructions for scalar use. These all have names that
 963 // start with 'Fs'.
 964
 965 // Alias instructions that map fld0 to pxor for sse.
 966 def FsFLD0SD : I<0xEF, MRMInitReg, (ops FR64:$dst),
 967                  "pxor $dst, $dst", [(set FR64:$dst, fpimm0)]>,
 968                Requires<[HasSSE2]>, TB, OpSize;
 969
 970 // Alias instruction to do FR64 reg-to-reg copy using movapd. Upper bits are
 971 // disregarded.
 972 def FsMOVAPDrr : PDI<0x28, MRMSrcReg, (ops FR64:$dst, FR64:$src),
 973                      "movapd {$src, $dst|$dst, $src}", []>;
 974
 975 // Alias instruction to load FR64 from f128mem using movapd. Upper bits are
 976 // disregarded.
 977 def FsMOVAPDrm : PDI<0x28, MRMSrcMem, (ops FR64:$dst, f128mem:$src),
 978                      "movapd {$src, $dst|$dst, $src}",
 979                      [(set FR64:$dst, (X86loadpf64 addr:$src))]>;
 980
 981 // Alias bitwise logical operations using SSE logical ops on packed FP values.
 982 let isTwoAddress = 1 in {
 983 let isCommutable = 1 in {
 984   def FsANDPDrr : PDI<0x54, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 985                       "andpd {$src2, $dst|$dst, $src2}",
 986                       [(set FR64:$dst, (X86fand FR64:$src1, FR64:$src2))]>;
 987   def FsORPDrr  : PDI<0x56, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 988                       "orpd {$src2, $dst|$dst, $src2}",
 989                       [(set FR64:$dst, (X86for FR64:$src1, FR64:$src2))]>;
 990   def FsXORPDrr : PDI<0x57, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
 991                       "xorpd {$src2, $dst|$dst, $src2}",
 992                       [(set FR64:$dst, (X86fxor FR64:$src1, FR64:$src2))]>;
 993 }
 994
 995 def FsANDPDrm : PDI<0x54, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f128mem:$src2),
 996                     "andpd {$src2, $dst|$dst, $src2}",
 997                     [(set FR64:$dst, (X86fand FR64:$src1,
 998                                       (X86loadpf64 addr:$src2)))]>;
 999 def FsORPDrm  : PDI<0x56, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f128mem:$src2),
1000                     "orpd {$src2, $dst|$dst, $src2}",
1001                     [(set FR64:$dst, (X86for FR64:$src1,
1002                                       (X86loadpf64 addr:$src2)))]>;
1003 def FsXORPDrm : PDI<0x57, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f128mem:$src2),
1004                     "xorpd {$src2, $dst|$dst, $src2}",
1005                     [(set FR64:$dst, (X86fxor FR64:$src1,
1006                                       (X86loadpf64 addr:$src2)))]>;
1007
1008 def FsANDNPDrr : PDI<0x55, MRMSrcReg,
1009                      (ops FR64:$dst, FR64:$src1, FR64:$src2),
1010                      "andnpd {$src2, $dst|$dst, $src2}", []>;
1011 def FsANDNPDrm : PDI<0x55, MRMSrcMem,
1012                      (ops FR64:$dst, FR64:$src1, f128mem:$src2),
1013                      "andnpd {$src2, $dst|$dst, $src2}", []>;
1014 }
1015
1016 /// scalar_sse2_fp_binop_rm - Scalar SSE2 binops come in three basic forms:
1017 ///
1018 ///  1. f64 - This comes in SSE2 form for doubles.
1019 ///  2. rr vs rm - They include a reg+reg form and a reg+mem form.
1020 ///
1021 /// In addition, scalar SSE ops have an intrinsic form.  This form is unlike the
1022 /// normal form, in that they take an entire vector (instead of a scalar) and
1023 /// leave the top elements undefined.  This adds another two variants of the
1024 /// above permutations, giving us 8 forms for 'instruction'.
1025 ///
1026 let isTwoAddress = 1 in {
1027 multiclass scalar_sse2_fp_binop_rm<bits<8> opc, string OpcodeStr,
1028                                    SDNode OpNode, Intrinsic F64Int,
1029                                    bit Commutable = 0> {
1030   // Scalar operation, reg+reg.
1031   def SDrr : SDI<opc, MRMSrcReg, (ops FR64:$dst, FR64:$src1, FR64:$src2),
1032                  !strconcat(OpcodeStr, "sd {$src2, $dst|$dst, $src2}"),
1033                  [(set FR64:$dst, (OpNode FR64:$src1, FR64:$src2))]> {
1034     let isCommutable = Commutable;
1035   }
1036
1037   // Scalar operation, reg+mem.
1038   def SDrm : SDI<opc, MRMSrcMem, (ops FR64:$dst, FR64:$src1, f64mem:$src2),
1039                  !strconcat(OpcodeStr, "sd {$src2, $dst|$dst, $src2}"),
1040                  [(set FR64:$dst, (OpNode FR64:$src1, (load addr:$src2)))]>;
1041
1042   // Vector intrinsic operation, reg+reg.
1043   def SDrr_Int : SDI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1044                      !strconcat(OpcodeStr, "sd {$src2, $dst|$dst, $src2}"),
1045                      [(set VR128:$dst, (F64Int VR128:$src1, VR128:$src2))]> {
1046     let isCommutable = Commutable;
1047   }
1048
1049   // Vector intrinsic operation, reg+mem.
1050   def SDrm_Int : SDI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, sdmem:$src2),
1051                      !strconcat(OpcodeStr, "sd {$src2, $dst|$dst, $src2}"),
1052                      [(set VR128:$dst, (F64Int VR128:$src1,
1053                                                sse_load_f64:$src2))]>;
1054 }
1055 }
1056
1057 // Arithmetic instructions
1058 defm ADD : scalar_sse2_fp_binop_rm<0x58, "add", fadd, int_x86_sse2_add_sd, 1>;
1059 defm MUL : scalar_sse2_fp_binop_rm<0x59, "mul", fmul, int_x86_sse2_mul_sd, 1>;
1060 defm SUB : scalar_sse2_fp_binop_rm<0x5C, "sub", fsub, int_x86_sse2_sub_sd>;
1061 defm DIV : scalar_sse2_fp_binop_rm<0x5E, "div", fdiv, int_x86_sse2_div_sd>;
1062
1063 defm MAX : scalar_sse2_fp_binop_rm<0x5F, "max", X86fmax, int_x86_sse2_max_sd>;
1064 defm MIN : scalar_sse2_fp_binop_rm<0x5D, "min", X86fmin, int_x86_sse2_min_sd>;
1065
1066 //===----------------------------------------------------------------------===//
1067 // SSE packed FP Instructions
1068
1069 // Move Instructions
1070 def MOVAPDrr : PDI<0x28, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1071                    "movapd {$src, $dst|$dst, $src}", []>;
1072 def MOVAPDrm : PDI<0x28, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1073                    "movapd {$src, $dst|$dst, $src}",
1074                    [(set VR128:$dst, (loadv2f64 addr:$src))]>;
1075
1076 def MOVAPDmr : PDI<0x29, MRMDestMem, (ops f128mem:$dst, VR128:$src),
1077                    "movapd {$src, $dst|$dst, $src}",
1078                    [(store (v2f64 VR128:$src), addr:$dst)]>;
1079
1080 def MOVUPDrr : PDI<0x10, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1081                    "movupd {$src, $dst|$dst, $src}", []>;
1082 def MOVUPDrm : PDI<0x10, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1083                    "movupd {$src, $dst|$dst, $src}",
1084                    [(set VR128:$dst, (int_x86_sse2_loadu_pd addr:$src))]>;
1085 def MOVUPDmr : PDI<0x11, MRMDestMem, (ops f128mem:$dst, VR128:$src),
1086                    "movupd {$src, $dst|$dst, $src}",
1087                    [(int_x86_sse2_storeu_pd addr:$dst, VR128:$src)]>;
1088
1089 let isTwoAddress = 1 in {
1090   let AddedComplexity = 20 in {
1091     def MOVLPDrm : PDI<0x12, MRMSrcMem,
1092                        (ops VR128:$dst, VR128:$src1, f64mem:$src2),
1093                        "movlpd {$src2, $dst|$dst, $src2}",
1094                        [(set VR128:$dst,
1095                          (v2f64 (vector_shuffle VR128:$src1,
1096                                  (scalar_to_vector (loadf64 addr:$src2)),
1097                                  MOVLP_shuffle_mask)))]>;
1098     def MOVHPDrm : PDI<0x16, MRMSrcMem,
1099                        (ops VR128:$dst, VR128:$src1, f64mem:$src2),
1100                        "movhpd {$src2, $dst|$dst, $src2}",
1101                        [(set VR128:$dst,
1102                          (v2f64 (vector_shuffle VR128:$src1,
1103                                  (scalar_to_vector (loadf64 addr:$src2)),
1104                                  MOVHP_shuffle_mask)))]>;
1105   } // AddedComplexity
1106 } // isTwoAddress
1107
1108 def MOVLPDmr : PDI<0x13, MRMDestMem, (ops f64mem:$dst, VR128:$src),
1109                    "movlpd {$src, $dst|$dst, $src}",
1110                    [(store (f64 (vector_extract (v2f64 VR128:$src),
1111                                  (iPTR 0))), addr:$dst)]>;
1112
1113 // v2f64 extract element 1 is always custom lowered to unpack high to low
1114 // and extract element 0 so the non-store version isn't too horrible.
1115 def MOVHPDmr : PDI<0x17, MRMDestMem, (ops f64mem:$dst, VR128:$src),
1116                    "movhpd {$src, $dst|$dst, $src}",
1117                    [(store (f64 (vector_extract
1118                                  (v2f64 (vector_shuffle VR128:$src, (undef),
1119                                          UNPCKH_shuffle_mask)), (iPTR 0))),
1120                      addr:$dst)]>;
1121
1122 // SSE2 instructions without OpSize prefix
1123 def Int_CVTDQ2PSrr : I<0x5B, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1124                        "cvtdq2ps {$src, $dst|$dst, $src}",
1125                        [(set VR128:$dst, (int_x86_sse2_cvtdq2ps VR128:$src))]>,
1126                      TB, Requires<[HasSSE2]>;
1127 def Int_CVTDQ2PSrm : I<0x5B, MRMSrcMem, (ops VR128:$dst, i128mem:$src),
1128                        "cvtdq2ps {$src, $dst|$dst, $src}",
1129                        [(set VR128:$dst, (int_x86_sse2_cvtdq2ps
1130                                          (bitconvert (loadv2i64 addr:$src))))]>,
1131                      TB, Requires<[HasSSE2]>;
1132
1133 // SSE2 instructions with XS prefix
1134 def Int_CVTDQ2PDrr : I<0xE6, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1135                        "cvtdq2pd {$src, $dst|$dst, $src}",
1136                        [(set VR128:$dst, (int_x86_sse2_cvtdq2pd VR128:$src))]>,
1137                      XS, Requires<[HasSSE2]>;
1138 def Int_CVTDQ2PDrm : I<0xE6, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
1139                        "cvtdq2pd {$src, $dst|$dst, $src}",
1140                        [(set VR128:$dst, (int_x86_sse2_cvtdq2pd
1141                                           (bitconvert (loadv2i64 addr:$src))))]>,
1142                      XS, Requires<[HasSSE2]>;
1143
1144 def Int_CVTPS2DQrr : PDI<0x5B, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1145                          "cvtps2dq {$src, $dst|$dst, $src}",
1146                          [(set VR128:$dst, (int_x86_sse2_cvtps2dq VR128:$src))]>;
1147 def Int_CVTPS2DQrm : PDI<0x5B, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1148                          "cvtps2dq {$src, $dst|$dst, $src}",
1149                          [(set VR128:$dst, (int_x86_sse2_cvtps2dq
1150                                             (load addr:$src)))]>;
1151 // SSE2 packed instructions with XS prefix
1152 def Int_CVTTPS2DQrr : I<0x5B, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1153                         "cvttps2dq {$src, $dst|$dst, $src}",
1154                         [(set VR128:$dst, (int_x86_sse2_cvttps2dq VR128:$src))]>,
1155                       XS, Requires<[HasSSE2]>;
1156 def Int_CVTTPS2DQrm : I<0x5B, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1157                         "cvttps2dq {$src, $dst|$dst, $src}",
1158                         [(set VR128:$dst, (int_x86_sse2_cvttps2dq
1159                                            (load addr:$src)))]>,
1160                       XS, Requires<[HasSSE2]>;
1161
1162 // SSE2 packed instructions with XD prefix
1163 def Int_CVTPD2DQrr : I<0xE6, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1164                        "cvtpd2dq {$src, $dst|$dst, $src}",
1165                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq VR128:$src))]>,
1166                      XD, Requires<[HasSSE2]>;
1167 def Int_CVTPD2DQrm : I<0xE6, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1168                        "cvtpd2dq {$src, $dst|$dst, $src}",
1169                        [(set VR128:$dst, (int_x86_sse2_cvtpd2dq
1170                                           (load addr:$src)))]>,
1171                      XD, Requires<[HasSSE2]>;
1172
1173 def Int_CVTTPD2DQrr : PDI<0xE6, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1174                           "cvttpd2dq {$src, $dst|$dst, $src}",
1175                        [(set VR128:$dst, (int_x86_sse2_cvttpd2dq VR128:$src))]>;
1176 def Int_CVTTPD2DQrm : PDI<0xE6, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1177                           "cvttpd2dq {$src, $dst|$dst, $src}",
1178                           [(set VR128:$dst, (int_x86_sse2_cvttpd2dq
1179                                              (load addr:$src)))]>;
1180
1181 // SSE2 instructions without OpSize prefix
1182 def Int_CVTPS2PDrr : I<0x5A, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1183                        "cvtps2pd {$src, $dst|$dst, $src}",
1184                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd VR128:$src))]>,
1185                      TB, Requires<[HasSSE2]>;
1186 def Int_CVTPS2PDrm : I<0x5A, MRMSrcReg, (ops VR128:$dst, f64mem:$src),
1187                        "cvtps2pd {$src, $dst|$dst, $src}",
1188                        [(set VR128:$dst, (int_x86_sse2_cvtps2pd
1189                                           (load addr:$src)))]>,
1190                      TB, Requires<[HasSSE2]>;
1191
1192 def Int_CVTPD2PSrr : PDI<0x5A, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1193                          "cvtpd2ps {$src, $dst|$dst, $src}",
1194                         [(set VR128:$dst, (int_x86_sse2_cvtpd2ps VR128:$src))]>;
1195 def Int_CVTPD2PSrm : PDI<0x5A, MRMSrcReg, (ops VR128:$dst, f128mem:$src),
1196                          "cvtpd2ps {$src, $dst|$dst, $src}",
1197                          [(set VR128:$dst, (int_x86_sse2_cvtpd2ps
1198                                             (load addr:$src)))]>;
1199
1200 // Match intrinsics which expect XMM operand(s).
1201 // Aliases for intrinsics
1202 let isTwoAddress = 1 in {
1203 def Int_CVTSI2SDrr: SDI<0x2A, MRMSrcReg,
1204                         (ops VR128:$dst, VR128:$src1, GR32:$src2),
1205                         "cvtsi2sd {$src2, $dst|$dst, $src2}",
1206                         [(set VR128:$dst, (int_x86_sse2_cvtsi2sd VR128:$src1,
1207                                            GR32:$src2))]>;
1208 def Int_CVTSI2SDrm: SDI<0x2A, MRMSrcMem,
1209                         (ops VR128:$dst, VR128:$src1, i32mem:$src2),
1210                         "cvtsi2sd {$src2, $dst|$dst, $src2}",
1211                         [(set VR128:$dst, (int_x86_sse2_cvtsi2sd VR128:$src1,
1212                                            (loadi32 addr:$src2)))]>;
1213 def Int_CVTSD2SSrr: SDI<0x5A, MRMSrcReg,
1214                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
1215                    "cvtsd2ss {$src2, $dst|$dst, $src2}",
1216                    [(set VR128:$dst, (int_x86_sse2_cvtsd2ss VR128:$src1,
1217                                       VR128:$src2))]>;
1218 def Int_CVTSD2SSrm: SDI<0x5A, MRMSrcMem,
1219                         (ops VR128:$dst, VR128:$src1, f64mem:$src2),
1220                    "cvtsd2ss {$src2, $dst|$dst, $src2}",
1221                    [(set VR128:$dst, (int_x86_sse2_cvtsd2ss VR128:$src1,
1222                                       (load addr:$src2)))]>;
1223 def Int_CVTSS2SDrr: I<0x5A, MRMSrcReg,
1224                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1225                     "cvtss2sd {$src2, $dst|$dst, $src2}",
1226                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1227                                        VR128:$src2))]>, XS,
1228                     Requires<[HasSSE2]>;
1229 def Int_CVTSS2SDrm: I<0x5A, MRMSrcMem,
1230                       (ops VR128:$dst, VR128:$src1, f32mem:$src2),
1231                     "cvtss2sd {$src2, $dst|$dst, $src2}",
1232                     [(set VR128:$dst, (int_x86_sse2_cvtss2sd VR128:$src1,
1233                                        (load addr:$src2)))]>, XS,
1234                     Requires<[HasSSE2]>;
1235 }
1236
1237 /// packed_sse2_fp_binop_rm - Packed SSE binops come in three basic forms:
1238 ///  1. v2f64    - This comes in SSE2 form for doubles.
1239 ///  2. rr vs rm - They include a reg+reg form and a ref+mem form.
1240 ///
1241 let isTwoAddress = 1 in {
1242 multiclass packed_sse2_fp_binop_rm<bits<8> opc, string OpcodeStr,
1243                                    SDNode OpNode, bit Commutable = 0> {
1244   // Packed operation, reg+reg.
1245   def PDrr : PDI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1246                !strconcat(OpcodeStr, "pd {$src2, $dst|$dst, $src2}"),
1247                [(set VR128:$dst, (v2f64 (OpNode VR128:$src1, VR128:$src2)))]> {
1248     let isCommutable = Commutable;
1249   }
1250
1251   // Packed operation, reg+mem.
1252   def PDrm : PDI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1253                  !strconcat(OpcodeStr, "pd {$src2, $dst|$dst, $src2}"),
1254                  [(set VR128:$dst, (OpNode VR128:$src1, (loadv2f64 addr:$src2)))]>;
1255 }
1256 }
1257
1258 defm ADD : packed_sse2_fp_binop_rm<0x58, "add", fadd, 1>;
1259 defm MUL : packed_sse2_fp_binop_rm<0x59, "mul", fmul, 1>;
1260 defm DIV : packed_sse2_fp_binop_rm<0x5E, "div", fdiv>;
1261 defm SUB : packed_sse2_fp_binop_rm<0x5C, "sub", fsub>;
1262
1263 // Arithmetic
1264
1265 class PD_Intr<bits<8> o, string OpcodeStr, Intrinsic IntId>
1266   : PDI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1267         !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
1268         [(set VR128:$dst, (IntId VR128:$src))]>;
1269 class PD_Intm<bits<8> o, string OpcodeStr, Intrinsic IntId>
1270   : PDI<o, MRMSrcMem, (ops VR128:$dst, f64mem:$src),
1271         !strconcat(OpcodeStr, " {$src, $dst|$dst, $src}"),
1272         [(set VR128:$dst, (IntId (load addr:$src)))]>;
1273
1274 class PD_Intrr<bits<8> o, string OpcodeStr, Intrinsic IntId>
1275   : PDI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1276         !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1277         [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
1278 class PD_Intrm<bits<8> o, string OpcodeStr, Intrinsic IntId>
1279   : PDI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f64mem:$src2),
1280         !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1281         [(set VR128:$dst, (IntId VR128:$src1, (load addr:$src2)))]>;
1282
1283 def SQRTPDr  : PD_Intr<0x51, "sqrtpd", int_x86_sse2_sqrt_pd>;
1284 def SQRTPDm  : PD_Intm<0x51, "sqrtpd", int_x86_sse2_sqrt_pd>;
1285
1286 let isTwoAddress = 1 in {
1287   let isCommutable = 1 in {
1288     def MAXPDrr  : PD_Intrr<0x5F, "maxpd", int_x86_sse2_max_pd>;
1289     def MINPDrr  : PD_Intrr<0x5D, "minpd", int_x86_sse2_min_pd>;
1290   }
1291
1292   def MAXPDrm  : PD_Intrm<0x5F, "maxpd", int_x86_sse2_max_pd>;
1293   def MINPDrm  : PD_Intrm<0x5D, "minpd", int_x86_sse2_min_pd>;
1294 }
1295
1296 // Logical
1297 let isTwoAddress = 1 in {
1298   let isCommutable = 1 in {
1299     def ANDPDrr : PDI<0x54, MRMSrcReg,
1300                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1301                       "andpd {$src2, $dst|$dst, $src2}",
1302                       [(set VR128:$dst,
1303                         (and (bc_v2i64 (v2f64 VR128:$src1)),
1304                          (bc_v2i64 (v2f64 VR128:$src2))))]>;
1305     def ORPDrr  : PDI<0x56, MRMSrcReg,
1306                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1307                       "orpd {$src2, $dst|$dst, $src2}",
1308                       [(set VR128:$dst,
1309                         (or (bc_v2i64 (v2f64 VR128:$src1)),
1310                          (bc_v2i64 (v2f64 VR128:$src2))))]>;
1311     def XORPDrr : PDI<0x57, MRMSrcReg,
1312                       (ops VR128:$dst, VR128:$src1, VR128:$src2),
1313                       "xorpd {$src2, $dst|$dst, $src2}",
1314                       [(set VR128:$dst,
1315                         (xor (bc_v2i64 (v2f64 VR128:$src1)),
1316                          (bc_v2i64 (v2f64 VR128:$src2))))]>;
1317   }
1318
1319   def ANDPDrm : PDI<0x54, MRMSrcMem,
1320                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1321                     "andpd {$src2, $dst|$dst, $src2}",
1322                     [(set VR128:$dst,
1323                       (and (bc_v2i64 (v2f64 VR128:$src1)),
1324                        (bc_v2i64 (loadv2f64 addr:$src2))))]>;
1325   def ORPDrm  : PDI<0x56, MRMSrcMem,
1326                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1327                     "orpd {$src2, $dst|$dst, $src2}",
1328                     [(set VR128:$dst,
1329                       (or (bc_v2i64 (v2f64 VR128:$src1)),
1330                        (bc_v2i64 (loadv2f64 addr:$src2))))]>;
1331   def XORPDrm : PDI<0x57, MRMSrcMem,
1332                     (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1333                     "xorpd {$src2, $dst|$dst, $src2}",
1334                     [(set VR128:$dst,
1335                       (xor (bc_v2i64 (v2f64 VR128:$src1)),
1336                        (bc_v2i64 (loadv2f64 addr:$src2))))]>;
1337   def ANDNPDrr : PDI<0x55, MRMSrcReg,
1338                      (ops VR128:$dst, VR128:$src1, VR128:$src2),
1339                      "andnpd {$src2, $dst|$dst, $src2}",
1340                      [(set VR128:$dst,
1341                        (and (vnot (bc_v2i64 (v2f64 VR128:$src1))),
1342                         (bc_v2i64 (v2f64 VR128:$src2))))]>;
1343   def ANDNPDrm : PDI<0x55, MRMSrcMem,
1344                      (ops VR128:$dst, VR128:$src1,f128mem:$src2),
1345                      "andnpd {$src2, $dst|$dst, $src2}",
1346                      [(set VR128:$dst,
1347                        (and (vnot (bc_v2i64 (v2f64 VR128:$src1))),
1348                         (bc_v2i64 (loadv2f64 addr:$src2))))]>;
1349 }
1350
1351 let isTwoAddress = 1 in {
1352   def CMPPDrri : PDIi8<0xC2, MRMSrcReg,
1353                       (ops VR128:$dst, VR128:$src1, VR128:$src, SSECC:$cc),
1354                       "cmp${cc}pd {$src, $dst|$dst, $src}",
1355                       [(set VR128:$dst, (int_x86_sse2_cmp_pd VR128:$src1,
1356                                          VR128:$src, imm:$cc))]>;
1357   def CMPPDrmi : PDIi8<0xC2, MRMSrcMem,
1358                       (ops VR128:$dst, VR128:$src1, f128mem:$src, SSECC:$cc),
1359                       "cmp${cc}pd {$src, $dst|$dst, $src}",
1360                       [(set VR128:$dst, (int_x86_sse2_cmp_pd VR128:$src1,
1361                                          (load addr:$src), imm:$cc))]>;
1362 }
1363
1364 // Shuffle and unpack instructions
1365 let isTwoAddress = 1 in {
1366   def SHUFPDrri : PDIi8<0xC6, MRMSrcReg,
1367                         (ops VR128:$dst, VR128:$src1, VR128:$src2, i8imm:$src3),
1368                         "shufpd {$src3, $src2, $dst|$dst, $src2, $src3}",
1369                         [(set VR128:$dst, (v2f64 (vector_shuffle
1370                                                   VR128:$src1, VR128:$src2,
1371                                                   SHUFP_shuffle_mask:$src3)))]>;
1372   def SHUFPDrmi : PDIi8<0xC6, MRMSrcMem,
1373                         (ops VR128:$dst, VR128:$src1,
1374                          f128mem:$src2, i8imm:$src3),
1375                         "shufpd {$src3, $src2, $dst|$dst, $src2, $src3}",
1376                         [(set VR128:$dst,
1377                           (v2f64 (vector_shuffle
1378                                   VR128:$src1, (load addr:$src2),
1379                                   SHUFP_shuffle_mask:$src3)))]>;
1380
1381   let AddedComplexity = 10 in {
1382     def UNPCKHPDrr : PDI<0x15, MRMSrcReg,
1383                          (ops VR128:$dst, VR128:$src1, VR128:$src2),
1384                          "unpckhpd {$src2, $dst|$dst, $src2}",
1385                          [(set VR128:$dst,
1386                            (v2f64 (vector_shuffle
1387                                    VR128:$src1, VR128:$src2,
1388                                    UNPCKH_shuffle_mask)))]>;
1389     def UNPCKHPDrm : PDI<0x15, MRMSrcMem,
1390                          (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1391                          "unpckhpd {$src2, $dst|$dst, $src2}",
1392                          [(set VR128:$dst,
1393                            (v2f64 (vector_shuffle
1394                                    VR128:$src1, (load addr:$src2),
1395                                    UNPCKH_shuffle_mask)))]>;
1396
1397     def UNPCKLPDrr : PDI<0x14, MRMSrcReg,
1398                          (ops VR128:$dst, VR128:$src1, VR128:$src2),
1399                          "unpcklpd {$src2, $dst|$dst, $src2}",
1400                          [(set VR128:$dst,
1401                            (v2f64 (vector_shuffle
1402                                    VR128:$src1, VR128:$src2,
1403                                    UNPCKL_shuffle_mask)))]>;
1404     def UNPCKLPDrm : PDI<0x14, MRMSrcMem,
1405                          (ops VR128:$dst, VR128:$src1, f128mem:$src2),
1406                          "unpcklpd {$src2, $dst|$dst, $src2}",
1407                          [(set VR128:$dst,
1408                            (v2f64 (vector_shuffle
1409                                    VR128:$src1, (load addr:$src2),
1410                                    UNPCKL_shuffle_mask)))]>;
1411   } // AddedComplexity
1412 } // isTwoAddress
1413
1414
1415 //===----------------------------------------------------------------------===//
1416 // SSE integer instructions
1417
1418 // Move Instructions
1419 def MOVDQArr : PDI<0x6F, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1420                    "movdqa {$src, $dst|$dst, $src}", []>;
1421 def MOVDQArm : PDI<0x6F, MRMSrcMem, (ops VR128:$dst, i128mem:$src),
1422                    "movdqa {$src, $dst|$dst, $src}",
1423                    [(set VR128:$dst, (loadv2i64 addr:$src))]>;
1424 def MOVDQAmr : PDI<0x7F, MRMDestMem, (ops i128mem:$dst, VR128:$src),
1425                    "movdqa {$src, $dst|$dst, $src}",
1426                    [(store (v2i64 VR128:$src), addr:$dst)]>;
1427 def MOVDQUrm :   I<0x6F, MRMSrcMem, (ops VR128:$dst, i128mem:$src),
1428                    "movdqu {$src, $dst|$dst, $src}",
1429                    [(set VR128:$dst, (int_x86_sse2_loadu_dq addr:$src))]>,
1430                  XS, Requires<[HasSSE2]>;
1431 def MOVDQUmr :   I<0x7F, MRMDestMem, (ops i128mem:$dst, VR128:$src),
1432                    "movdqu {$src, $dst|$dst, $src}",
1433                    [(int_x86_sse2_storeu_dq addr:$dst, VR128:$src)]>,
1434                  XS, Requires<[HasSSE2]>;
1435
1436
1437 let isTwoAddress = 1 in {
1438
1439 multiclass PDI_binop_rm_int<bits<8> opc, string OpcodeStr, Intrinsic IntId,
1440                             bit Commutable = 0> {
1441   def rr : PDI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1442                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1443                [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]> {
1444     let isCommutable = Commutable;
1445   }
1446   def rm : PDI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1447                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1448                [(set VR128:$dst, (IntId VR128:$src1,
1449                                         (bitconvert (loadv2i64 addr:$src2))))]>;
1450 }
1451
1452 multiclass PDI_binop_rmi_int<bits<8> opc, bits<8> opc2, Format ImmForm,
1453                              string OpcodeStr, Intrinsic IntId> {
1454   def rr : PDI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1455                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1456                [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]>;
1457   def rm : PDI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1458                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1459                [(set VR128:$dst, (IntId VR128:$src1,
1460                                         (bitconvert (loadv2i64 addr:$src2))))]>;
1461   def ri : PDIi8<opc2, ImmForm, (ops VR128:$dst, VR128:$src1, i32i8imm:$src2),
1462                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1463                [(set VR128:$dst, (IntId VR128:$src1,
1464                                         (scalar_to_vector (i32 imm:$src2))))]>;
1465 }
1466
1467
1468 /// PDI_binop_rm - Simple SSE2 binary operator.
1469 multiclass PDI_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
1470                         ValueType OpVT, bit Commutable = 0> {
1471   def rr : PDI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1472                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1473                [(set VR128:$dst, (OpVT (OpNode VR128:$src1, VR128:$src2)))]> {
1474     let isCommutable = Commutable;
1475   }
1476   def rm : PDI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1477                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1478                [(set VR128:$dst, (OpVT (OpNode VR128:$src1,
1479                                        (bitconvert (loadv2i64 addr:$src2)))))]>;
1480 }
1481
1482 /// PDI_binop_rm_v2i64 - Simple SSE2 binary operator whose type is v2i64.
1483 ///
1484 /// FIXME: we could eliminate this and use PDI_binop_rm instead if tblgen knew
1485 /// to collapse (bitconvert VT to VT) into its operand.
1486 ///
1487 multiclass PDI_binop_rm_v2i64<bits<8> opc, string OpcodeStr, SDNode OpNode,
1488                               bit Commutable = 0> {
1489   def rr : PDI<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
1490                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1491                [(set VR128:$dst, (v2i64 (OpNode VR128:$src1, VR128:$src2)))]> {
1492     let isCommutable = Commutable;
1493   }
1494   def rm : PDI<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1495                !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
1496                [(set VR128:$dst, (OpNode VR128:$src1,(loadv2i64 addr:$src2)))]>;
1497 }
1498
1499 } // isTwoAddress
1500
1501 // 128-bit Integer Arithmetic
1502
1503 defm PADDB : PDI_binop_rm<0xFC, "paddb", add, v16i8, 1>;
1504 defm PADDW : PDI_binop_rm<0xFD, "paddw", add, v8i16, 1>;
1505 defm PADDD : PDI_binop_rm<0xFE, "paddd", add, v4i32, 1>;
1506 defm PADDQ : PDI_binop_rm_v2i64<0xD4, "paddq", add, 1>;
1507
1508 defm PADDSB  : PDI_binop_rm_int<0xEC, "paddsb" , int_x86_sse2_padds_b, 1>;
1509 defm PADDSW  : PDI_binop_rm_int<0xED, "paddsw" , int_x86_sse2_padds_w, 1>;
1510 defm PADDUSB : PDI_binop_rm_int<0xDC, "paddusb", int_x86_sse2_paddus_b, 1>;
1511 defm PADDUSW : PDI_binop_rm_int<0xDD, "paddusw", int_x86_sse2_paddus_w, 1>;
1512
1513 defm PSUBB : PDI_binop_rm<0xF8, "psubb", sub, v16i8>;
1514 defm PSUBW : PDI_binop_rm<0xF9, "psubw", sub, v8i16>;
1515 defm PSUBD : PDI_binop_rm<0xFA, "psubd", sub, v4i32>;
1516 defm PSUBQ : PDI_binop_rm_v2i64<0xFB, "psubq", sub>;
1517
1518 defm PSUBSB  : PDI_binop_rm_int<0xE8, "psubsb" , int_x86_sse2_psubs_b>;
1519 defm PSUBSW  : PDI_binop_rm_int<0xE9, "psubsw" , int_x86_sse2_psubs_w>;
1520 defm PSUBUSB : PDI_binop_rm_int<0xD8, "psubusb", int_x86_sse2_psubus_b>;
1521 defm PSUBUSW : PDI_binop_rm_int<0xD9, "psubusw", int_x86_sse2_psubus_w>;
1522
1523 defm PMULLW : PDI_binop_rm<0xD5, "pmullw", mul, v8i16, 1>;
1524
1525 defm PMULHUW : PDI_binop_rm_int<0xE4, "pmulhuw", int_x86_sse2_pmulhu_w, 1>;
1526 defm PMULHW  : PDI_binop_rm_int<0xE5, "pmulhw" , int_x86_sse2_pmulh_w , 1>;
1527 defm PMULUDQ : PDI_binop_rm_int<0xF4, "pmuludq", int_x86_sse2_pmulu_dq, 1>;
1528
1529 defm PMADDWD : PDI_binop_rm_int<0xF5, "pmaddwd", int_x86_sse2_pmadd_wd, 1>;
1530
1531 defm PAVGB  : PDI_binop_rm_int<0xE0, "pavgb", int_x86_sse2_pavg_b, 1>;
1532 defm PAVGW  : PDI_binop_rm_int<0xE3, "pavgw", int_x86_sse2_pavg_w, 1>;
1533
1534
1535 defm PMINUB : PDI_binop_rm_int<0xDA, "pminub", int_x86_sse2_pminu_b, 1>;
1536 defm PMINSW : PDI_binop_rm_int<0xEA, "pminsw", int_x86_sse2_pmins_w, 1>;
1537 defm PMAXUB : PDI_binop_rm_int<0xDE, "pmaxub", int_x86_sse2_pmaxu_b, 1>;
1538 defm PMAXSW : PDI_binop_rm_int<0xEE, "pmaxsw", int_x86_sse2_pmaxs_w, 1>;
1539 defm PSADBW : PDI_binop_rm_int<0xE0, "psadbw", int_x86_sse2_psad_bw, 1>;
1540
1541
1542 defm PSLLW : PDI_binop_rmi_int<0xF1, 0x71, MRM6r, "psllw", int_x86_sse2_psll_w>;
1543 defm PSLLD : PDI_binop_rmi_int<0xF2, 0x72, MRM6r, "pslld", int_x86_sse2_psll_d>;
1544 defm PSLLQ : PDI_binop_rmi_int<0xF3, 0x73, MRM6r, "psllq", int_x86_sse2_psll_q>;
1545
1546 defm PSRLW : PDI_binop_rmi_int<0xD1, 0x71, MRM2r, "psrlw", int_x86_sse2_psrl_w>;
1547 defm PSRLD : PDI_binop_rmi_int<0xD2, 0x72, MRM2r, "psrld", int_x86_sse2_psrl_d>;
1548 defm PSRLQ : PDI_binop_rmi_int<0xD3, 0x73, MRM2r, "psrlq", int_x86_sse2_psrl_q>;
1549
1550 defm PSRAW : PDI_binop_rmi_int<0xE1, 0x71, MRM4r, "psraw", int_x86_sse2_psra_w>;
1551 defm PSRAD : PDI_binop_rmi_int<0xE2, 0x72, MRM4r, "psrad", int_x86_sse2_psra_d>;
1552 // PSRAQ doesn't exist in SSE[1-3].
1553
1554 // 128-bit logical shifts.
1555 let isTwoAddress = 1 in {
1556   def PSLLDQri : PDIi8<0x73, MRM7r,
1557                        (ops VR128:$dst, VR128:$src1, i32i8imm:$src2),
1558                        "pslldq {$src2, $dst|$dst, $src2}", []>;
1559   def PSRLDQri : PDIi8<0x73, MRM3r,
1560                        (ops VR128:$dst, VR128:$src1, i32i8imm:$src2),
1561                        "psrldq {$src2, $dst|$dst, $src2}", []>;
1562   // PSRADQri doesn't exist in SSE[1-3].
1563 }
1564
1565 let Predicates = [HasSSE2] in {
1566   def : Pat<(int_x86_sse2_psll_dq VR128:$src1, imm:$src2),
1567             (v2i64 (PSLLDQri VR128:$src1, (PSxLDQ_imm imm:$src2)))>;
1568   def : Pat<(int_x86_sse2_psrl_dq VR128:$src1, imm:$src2),
1569             (v2i64 (PSRLDQri VR128:$src1, (PSxLDQ_imm imm:$src2)))>;
1570   def : Pat<(v2f64 (X86fsrl VR128:$src1, i32immSExt8:$src2)),
1571             (v2f64 (PSRLDQri VR128:$src1, (PSxLDQ_imm imm:$src2)))>;
1572 }
1573
1574 // Logical
1575 defm PAND : PDI_binop_rm_v2i64<0xDB, "pand", and, 1>;
1576 defm POR  : PDI_binop_rm_v2i64<0xEB, "por" , or , 1>;
1577 defm PXOR : PDI_binop_rm_v2i64<0xEF, "pxor", xor, 1>;
1578
1579 let isTwoAddress = 1 in {
1580   def PANDNrr : PDI<0xDF, MRMSrcReg,
1581                     (ops VR128:$dst, VR128:$src1, VR128:$src2),
1582                     "pandn {$src2, $dst|$dst, $src2}",
1583                     [(set VR128:$dst, (v2i64 (and (vnot VR128:$src1),
1584                                               VR128:$src2)))]>;
1585
1586   def PANDNrm : PDI<0xDF, MRMSrcMem,
1587                     (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1588                     "pandn {$src2, $dst|$dst, $src2}",
1589                     [(set VR128:$dst, (v2i64 (and (vnot VR128:$src1),
1590                                               (load addr:$src2))))]>;
1591 }
1592
1593 // SSE2 Integer comparison
1594 defm PCMPEQB  : PDI_binop_rm_int<0x74, "pcmpeqb", int_x86_sse2_pcmpeq_b>;
1595 defm PCMPEQW  : PDI_binop_rm_int<0x75, "pcmpeqw", int_x86_sse2_pcmpeq_w>;
1596 defm PCMPEQD  : PDI_binop_rm_int<0x76, "pcmpeqd", int_x86_sse2_pcmpeq_d>;
1597 defm PCMPGTB  : PDI_binop_rm_int<0x64, "pcmpgtb", int_x86_sse2_pcmpgt_b>;
1598 defm PCMPGTW  : PDI_binop_rm_int<0x65, "pcmpgtw", int_x86_sse2_pcmpgt_w>;
1599 defm PCMPGTD  : PDI_binop_rm_int<0x66, "pcmpgtd", int_x86_sse2_pcmpgt_d>;
1600
1601 // Pack instructions
1602 defm PACKSSWB : PDI_binop_rm_int<0x63, "packsswb", int_x86_sse2_packsswb_128>;
1603 defm PACKSSDW : PDI_binop_rm_int<0x6B, "packssdw", int_x86_sse2_packssdw_128>;
1604 defm PACKUSWB : PDI_binop_rm_int<0x67, "packuswb", int_x86_sse2_packuswb_128>;
1605
1606 // Shuffle and unpack instructions
1607 def PSHUFDri : PDIi8<0x70, MRMSrcReg,
1608                      (ops VR128:$dst, VR128:$src1, i8imm:$src2),
1609                      "pshufd {$src2, $src1, $dst|$dst, $src1, $src2}",
1610                      [(set VR128:$dst, (v4i32 (vector_shuffle
1611                                                VR128:$src1, (undef),
1612                                                PSHUFD_shuffle_mask:$src2)))]>;
1613 def PSHUFDmi : PDIi8<0x70, MRMSrcMem,
1614                      (ops VR128:$dst, i128mem:$src1, i8imm:$src2),
1615                      "pshufd {$src2, $src1, $dst|$dst, $src1, $src2}",
1616                      [(set VR128:$dst, (v4i32 (vector_shuffle
1617                                                (bc_v4i32(loadv2i64 addr:$src1)),
1618                                                (undef),
1619                                                PSHUFD_shuffle_mask:$src2)))]>;
1620
1621 // SSE2 with ImmT == Imm8 and XS prefix.
1622 def PSHUFHWri : Ii8<0x70, MRMSrcReg,
1623                     (ops VR128:$dst, VR128:$src1, i8imm:$src2),
1624                     "pshufhw {$src2, $src1, $dst|$dst, $src1, $src2}",
1625                     [(set VR128:$dst, (v8i16 (vector_shuffle
1626                                               VR128:$src1, (undef),
1627                                               PSHUFHW_shuffle_mask:$src2)))]>,
1628                 XS, Requires<[HasSSE2]>;
1629 def PSHUFHWmi : Ii8<0x70, MRMSrcMem,
1630                     (ops VR128:$dst, i128mem:$src1, i8imm:$src2),
1631                     "pshufhw {$src2, $src1, $dst|$dst, $src1, $src2}",
1632                     [(set VR128:$dst, (v8i16 (vector_shuffle
1633                                               (bc_v8i16 (loadv2i64 addr:$src1)),
1634                                               (undef),
1635                                               PSHUFHW_shuffle_mask:$src2)))]>,
1636                 XS, Requires<[HasSSE2]>;
1637
1638 // SSE2 with ImmT == Imm8 and XD prefix.
1639 def PSHUFLWri : Ii8<0x70, MRMSrcReg,
1640                     (ops VR128:$dst, VR128:$src1, i32i8imm:$src2),
1641                     "pshuflw {$src2, $src1, $dst|$dst, $src1, $src2}",
1642                     [(set VR128:$dst, (v8i16 (vector_shuffle
1643                                               VR128:$src1, (undef),
1644                                               PSHUFLW_shuffle_mask:$src2)))]>,
1645                 XD, Requires<[HasSSE2]>;
1646 def PSHUFLWmi : Ii8<0x70, MRMSrcMem,
1647                     (ops VR128:$dst, i128mem:$src1, i32i8imm:$src2),
1648                     "pshuflw {$src2, $src1, $dst|$dst, $src1, $src2}",
1649                     [(set VR128:$dst, (v8i16 (vector_shuffle
1650                                               (bc_v8i16 (loadv2i64 addr:$src1)),
1651                                               (undef),
1652                                               PSHUFLW_shuffle_mask:$src2)))]>,
1653                 XD, Requires<[HasSSE2]>;
1654
1655
1656 let isTwoAddress = 1 in {
1657   def PUNPCKLBWrr : PDI<0x60, MRMSrcReg,
1658                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
1659                         "punpcklbw {$src2, $dst|$dst, $src2}",
1660                         [(set VR128:$dst,
1661                           (v16i8 (vector_shuffle VR128:$src1, VR128:$src2,
1662                                   UNPCKL_shuffle_mask)))]>;
1663   def PUNPCKLBWrm : PDI<0x60, MRMSrcMem,
1664                         (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1665                         "punpcklbw {$src2, $dst|$dst, $src2}",
1666                         [(set VR128:$dst,
1667                           (v16i8 (vector_shuffle VR128:$src1,
1668                                   (bc_v16i8 (loadv2i64 addr:$src2)),
1669                                   UNPCKL_shuffle_mask)))]>;
1670   def PUNPCKLWDrr : PDI<0x61, MRMSrcReg,
1671                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
1672                         "punpcklwd {$src2, $dst|$dst, $src2}",
1673                         [(set VR128:$dst,
1674                           (v8i16 (vector_shuffle VR128:$src1, VR128:$src2,
1675                                   UNPCKL_shuffle_mask)))]>;
1676   def PUNPCKLWDrm : PDI<0x61, MRMSrcMem,
1677                         (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1678                         "punpcklwd {$src2, $dst|$dst, $src2}",
1679                         [(set VR128:$dst,
1680                           (v8i16 (vector_shuffle VR128:$src1,
1681                                   (bc_v8i16 (loadv2i64 addr:$src2)),
1682                                   UNPCKL_shuffle_mask)))]>;
1683   def PUNPCKLDQrr : PDI<0x62, MRMSrcReg,
1684                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
1685                         "punpckldq {$src2, $dst|$dst, $src2}",
1686                         [(set VR128:$dst,
1687                           (v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
1688                                   UNPCKL_shuffle_mask)))]>;
1689   def PUNPCKLDQrm : PDI<0x62, MRMSrcMem,
1690                         (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1691                         "punpckldq {$src2, $dst|$dst, $src2}",
1692                         [(set VR128:$dst,
1693                           (v4i32 (vector_shuffle VR128:$src1,
1694                                   (bc_v4i32 (loadv2i64 addr:$src2)),
1695                                   UNPCKL_shuffle_mask)))]>;
1696   def PUNPCKLQDQrr : PDI<0x6C, MRMSrcReg,
1697                          (ops VR128:$dst, VR128:$src1, VR128:$src2),
1698                          "punpcklqdq {$src2, $dst|$dst, $src2}",
1699                         [(set VR128:$dst,
1700                           (v2i64 (vector_shuffle VR128:$src1, VR128:$src2,
1701                                   UNPCKL_shuffle_mask)))]>;
1702   def PUNPCKLQDQrm : PDI<0x6C, MRMSrcMem,
1703                          (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1704                          "punpcklqdq {$src2, $dst|$dst, $src2}",
1705                         [(set VR128:$dst,
1706                           (v2i64 (vector_shuffle VR128:$src1,
1707                                   (loadv2i64 addr:$src2),
1708                                   UNPCKL_shuffle_mask)))]>;
1709
1710   def PUNPCKHBWrr : PDI<0x68, MRMSrcReg,
1711                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
1712                         "punpckhbw {$src2, $dst|$dst, $src2}",
1713                         [(set VR128:$dst,
1714                           (v16i8 (vector_shuffle VR128:$src1, VR128:$src2,
1715                                   UNPCKH_shuffle_mask)))]>;
1716   def PUNPCKHBWrm : PDI<0x68, MRMSrcMem,
1717                         (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1718                         "punpckhbw {$src2, $dst|$dst, $src2}",
1719                         [(set VR128:$dst,
1720                           (v16i8 (vector_shuffle VR128:$src1,
1721                                   (bc_v16i8 (loadv2i64 addr:$src2)),
1722                                   UNPCKH_shuffle_mask)))]>;
1723   def PUNPCKHWDrr : PDI<0x69, MRMSrcReg,
1724                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
1725                         "punpckhwd {$src2, $dst|$dst, $src2}",
1726                         [(set VR128:$dst,
1727                           (v8i16 (vector_shuffle VR128:$src1, VR128:$src2,
1728                                   UNPCKH_shuffle_mask)))]>;
1729   def PUNPCKHWDrm : PDI<0x69, MRMSrcMem,
1730                         (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1731                         "punpckhwd {$src2, $dst|$dst, $src2}",
1732                         [(set VR128:$dst,
1733                           (v8i16 (vector_shuffle VR128:$src1,
1734                                   (bc_v8i16 (loadv2i64 addr:$src2)),
1735                                   UNPCKH_shuffle_mask)))]>;
1736   def PUNPCKHDQrr : PDI<0x6A, MRMSrcReg,
1737                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
1738                         "punpckhdq {$src2, $dst|$dst, $src2}",
1739                         [(set VR128:$dst,
1740                           (v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
1741                                   UNPCKH_shuffle_mask)))]>;
1742   def PUNPCKHDQrm : PDI<0x6A, MRMSrcMem,
1743                         (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1744                         "punpckhdq {$src2, $dst|$dst, $src2}",
1745                         [(set VR128:$dst,
1746                           (v4i32 (vector_shuffle VR128:$src1,
1747                                   (bc_v4i32 (loadv2i64 addr:$src2)),
1748                                   UNPCKH_shuffle_mask)))]>;
1749   def PUNPCKHQDQrr : PDI<0x6D, MRMSrcReg,
1750                          (ops VR128:$dst, VR128:$src1, VR128:$src2),
1751                          "punpckhqdq {$src2, $dst|$dst, $src2}",
1752                         [(set VR128:$dst,
1753                           (v2i64 (vector_shuffle VR128:$src1, VR128:$src2,
1754                                   UNPCKH_shuffle_mask)))]>;
1755   def PUNPCKHQDQrm : PDI<0x6D, MRMSrcMem,
1756                         (ops VR128:$dst, VR128:$src1, i128mem:$src2),
1757                         "punpckhqdq {$src2, $dst|$dst, $src2}",
1758                         [(set VR128:$dst,
1759                           (v2i64 (vector_shuffle VR128:$src1,
1760                                   (loadv2i64 addr:$src2),
1761                                   UNPCKH_shuffle_mask)))]>;
1762 }
1763
1764 // Extract / Insert
1765 def PEXTRWri : PDIi8<0xC5, MRMSrcReg,
1766                     (ops GR32:$dst, VR128:$src1, i32i8imm:$src2),
1767                     "pextrw {$src2, $src1, $dst|$dst, $src1, $src2}",
1768                     [(set GR32:$dst, (X86pextrw (v8i16 VR128:$src1),
1769                                      (iPTR imm:$src2)))]>;
1770 let isTwoAddress = 1 in {
1771   def PINSRWrri : PDIi8<0xC4, MRMSrcReg,
1772                        (ops VR128:$dst, VR128:$src1,
1773                         GR32:$src2, i32i8imm:$src3),
1774                        "pinsrw {$src3, $src2, $dst|$dst, $src2, $src3}",
1775                        [(set VR128:$dst,
1776                          (v8i16 (X86pinsrw (v8i16 VR128:$src1),
1777                                  GR32:$src2, (iPTR imm:$src3))))]>;
1778   def PINSRWrmi : PDIi8<0xC4, MRMSrcMem,
1779                        (ops VR128:$dst, VR128:$src1,
1780                         i16mem:$src2, i32i8imm:$src3),
1781                        "pinsrw {$src3, $src2, $dst|$dst, $src2, $src3}",
1782                        [(set VR128:$dst,
1783                          (v8i16 (X86pinsrw (v8i16 VR128:$src1),
1784                                  (i32 (anyext (loadi16 addr:$src2))),
1785                                  (iPTR imm:$src3))))]>;
1786 }
1787
1788 // Mask creation
1789 def PMOVMSKBrr : PDI<0xD7, MRMSrcReg, (ops GR32:$dst, VR128:$src),
1790                      "pmovmskb {$src, $dst|$dst, $src}",
1791                      [(set GR32:$dst, (int_x86_sse2_pmovmskb_128 VR128:$src))]>;
1792
1793 // Conditional store
1794 def MASKMOVDQU : PDI<0xF7, MRMSrcReg, (ops VR128:$src, VR128:$mask),
1795                      "maskmovdqu {$mask, $src|$src, $mask}",
1796                      [(int_x86_sse2_maskmov_dqu VR128:$src, VR128:$mask, EDI)]>,
1797                  Imp<[EDI],[]>;
1798
1799 // Non-temporal stores
1800 def MOVNTPDmr : PDI<0x2B, MRMDestMem, (ops i128mem:$dst, VR128:$src),
1801                     "movntpd {$src, $dst|$dst, $src}",
1802                     [(int_x86_sse2_movnt_pd addr:$dst, VR128:$src)]>;
1803 def MOVNTDQmr : PDI<0xE7, MRMDestMem, (ops f128mem:$dst, VR128:$src),
1804                     "movntdq {$src, $dst|$dst, $src}",
1805                     [(int_x86_sse2_movnt_dq addr:$dst, VR128:$src)]>;
1806 def MOVNTImr  :   I<0xC3, MRMDestMem, (ops i32mem:$dst, GR32:$src),
1807                     "movnti {$src, $dst|$dst, $src}",
1808                     [(int_x86_sse2_movnt_i addr:$dst, GR32:$src)]>,
1809                   TB, Requires<[HasSSE2]>;
1810
1811 // Flush cache
1812 def CLFLUSH : I<0xAE, MRM7m, (ops i8mem:$src),
1813                "clflush $src", [(int_x86_sse2_clflush addr:$src)]>,
1814               TB, Requires<[HasSSE2]>;
1815
1816 // Load, store, and memory fence
1817 def LFENCE : I<0xAE, MRM5m, (ops),
1818                "lfence", [(int_x86_sse2_lfence)]>, TB, Requires<[HasSSE2]>;
1819 def MFENCE : I<0xAE, MRM6m, (ops),
1820                "mfence", [(int_x86_sse2_mfence)]>, TB, Requires<[HasSSE2]>;
1821
1822
1823 // Alias instructions that map zero vector to pxor / xorp* for sse.
1824 // FIXME: remove when we can teach regalloc that xor reg, reg is ok.
1825 let isReMaterializable = 1 in
1826   def V_SETALLONES : PDI<0x76, MRMInitReg, (ops VR128:$dst),
1827                          "pcmpeqd $dst, $dst",
1828                          [(set VR128:$dst, (v2f64 immAllOnesV))]>;
1829
1830 // FR64 to 128-bit vector conversion.
1831 def MOVSD2PDrr : SDI<0x10, MRMSrcReg, (ops VR128:$dst, FR64:$src),
1832                       "movsd {$src, $dst|$dst, $src}",
1833                       [(set VR128:$dst,
1834                         (v2f64 (scalar_to_vector FR64:$src)))]>;
1835 def MOVSD2PDrm : SDI<0x10, MRMSrcMem, (ops VR128:$dst, f64mem:$src),
1836                      "movsd {$src, $dst|$dst, $src}",
1837                      [(set VR128:$dst,
1838                        (v2f64 (scalar_to_vector (loadf64 addr:$src))))]>;
1839
1840 def MOVDI2PDIrr : PDI<0x6E, MRMSrcReg, (ops VR128:$dst, GR32:$src),
1841                       "movd {$src, $dst|$dst, $src}",
1842                       [(set VR128:$dst,
1843                         (v4i32 (scalar_to_vector GR32:$src)))]>;
1844 def MOVDI2PDIrm : PDI<0x6E, MRMSrcMem, (ops VR128:$dst, i32mem:$src),
1845                       "movd {$src, $dst|$dst, $src}",
1846                       [(set VR128:$dst,
1847                         (v4i32 (scalar_to_vector (loadi32 addr:$src))))]>;
1848
1849 def MOVDI2SSrr  : PDI<0x6E, MRMSrcReg, (ops FR32:$dst, GR32:$src),
1850                       "movd {$src, $dst|$dst, $src}",
1851                       [(set FR32:$dst, (bitconvert GR32:$src))]>;
1852
1853 def MOVDI2SSrm  : PDI<0x6E, MRMSrcMem, (ops FR32:$dst, i32mem:$src),
1854                       "movd {$src, $dst|$dst, $src}",
1855                       [(set FR32:$dst, (bitconvert (loadi32 addr:$src)))]>;
1856
1857 // SSE2 instructions with XS prefix
1858 def MOVQI2PQIrm : I<0x7E, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
1859                     "movq {$src, $dst|$dst, $src}",
1860                     [(set VR128:$dst,
1861                       (v2i64 (scalar_to_vector (loadi64 addr:$src))))]>, XS,
1862                   Requires<[HasSSE2]>;
1863 def MOVPQI2QImr : PDI<0xD6, MRMDestMem, (ops i64mem:$dst, VR128:$src),
1864                       "movq {$src, $dst|$dst, $src}",
1865                       [(store (i64 (vector_extract (v2i64 VR128:$src),
1866                                     (iPTR 0))), addr:$dst)]>;
1867
1868 // FIXME: may not be able to eliminate this movss with coalescing the src and
1869 // dest register classes are different. We really want to write this pattern
1870 // like this:
1871 // def : Pat<(f32 (vector_extract (v4f32 VR128:$src), (iPTR 0))),
1872 //           (f32 FR32:$src)>;
1873 def MOVPD2SDrr : SDI<0x10, MRMSrcReg, (ops FR64:$dst, VR128:$src),
1874                      "movsd {$src, $dst|$dst, $src}",
1875                      [(set FR64:$dst, (vector_extract (v2f64 VR128:$src),
1876                                        (iPTR 0)))]>;
1877 def MOVPD2SDmr : SDI<0x11, MRMDestMem, (ops f64mem:$dst, VR128:$src),
1878                      "movsd {$src, $dst|$dst, $src}",
1879                      [(store (f64 (vector_extract (v2f64 VR128:$src),
1880                                    (iPTR 0))), addr:$dst)]>;
1881 def MOVPDI2DIrr  : PDI<0x7E, MRMDestReg, (ops GR32:$dst, VR128:$src),
1882                        "movd {$src, $dst|$dst, $src}",
1883                        [(set GR32:$dst, (vector_extract (v4i32 VR128:$src),
1884                                         (iPTR 0)))]>;
1885 def MOVPDI2DImr  : PDI<0x7E, MRMDestMem, (ops i32mem:$dst, VR128:$src),
1886                        "movd {$src, $dst|$dst, $src}",
1887                        [(store (i32 (vector_extract (v4i32 VR128:$src),
1888                                      (iPTR 0))), addr:$dst)]>;
1889
1890 def MOVSS2DIrr  : PDI<0x7E, MRMDestReg, (ops GR32:$dst, FR32:$src),
1891                       "movd {$src, $dst|$dst, $src}",
1892                       [(set GR32:$dst, (bitconvert FR32:$src))]>;
1893 def MOVSS2DImr  : PDI<0x7E, MRMDestMem, (ops i32mem:$dst, FR32:$src),
1894                       "movd {$src, $dst|$dst, $src}",
1895                       [(store (i32 (bitconvert FR32:$src)), addr:$dst)]>;
1896
1897
1898 // Move to lower bits of a VR128, leaving upper bits alone.
1899 // Three operand (but two address) aliases.
1900 let isTwoAddress = 1 in {
1901   def MOVLSD2PDrr : SDI<0x10, MRMSrcReg,
1902                         (ops VR128:$dst, VR128:$src1, FR64:$src2),
1903                         "movsd {$src2, $dst|$dst, $src2}", []>;
1904
1905   let AddedComplexity = 15 in
1906     def MOVLPDrr : SDI<0x10, MRMSrcReg,
1907                        (ops VR128:$dst, VR128:$src1, VR128:$src2),
1908                        "movsd {$src2, $dst|$dst, $src2}",
1909                        [(set VR128:$dst,
1910                          (v2f64 (vector_shuffle VR128:$src1, VR128:$src2,
1911                                  MOVL_shuffle_mask)))]>;
1912 }
1913
1914 // Store / copy lower 64-bits of a XMM register.
1915 def MOVLQ128mr : PDI<0xD6, MRMDestMem, (ops i64mem:$dst, VR128:$src),
1916                      "movq {$src, $dst|$dst, $src}",
1917                      [(int_x86_sse2_storel_dq addr:$dst, VR128:$src)]>;
1918
1919 // Move to lower bits of a VR128 and zeroing upper bits.
1920 // Loading from memory automatically zeroing upper bits.
1921 let AddedComplexity = 20 in
1922   def MOVZSD2PDrm : SDI<0x10, MRMSrcMem, (ops VR128:$dst, f64mem:$src),
1923                         "movsd {$src, $dst|$dst, $src}",
1924                         [(set VR128:$dst,
1925                           (v2f64 (vector_shuffle immAllZerosV,
1926                                   (v2f64 (scalar_to_vector
1927                                           (loadf64 addr:$src))),
1928                                   MOVL_shuffle_mask)))]>;
1929
1930 let AddedComplexity = 15 in
1931 // movd / movq to XMM register zero-extends
1932 def MOVZDI2PDIrr : PDI<0x6E, MRMSrcReg, (ops VR128:$dst, GR32:$src),
1933                        "movd {$src, $dst|$dst, $src}",
1934                        [(set VR128:$dst,
1935                          (v4i32 (vector_shuffle immAllZerosV,
1936                                  (v4i32 (scalar_to_vector GR32:$src)),
1937                                  MOVL_shuffle_mask)))]>;
1938 let AddedComplexity = 20 in
1939 def MOVZDI2PDIrm : PDI<0x6E, MRMSrcMem, (ops VR128:$dst, i32mem:$src),
1940                        "movd {$src, $dst|$dst, $src}",
1941                        [(set VR128:$dst,
1942                          (v4i32 (vector_shuffle immAllZerosV,
1943                                  (v4i32 (scalar_to_vector (loadi32 addr:$src))),
1944                                  MOVL_shuffle_mask)))]>;
1945
1946 // Moving from XMM to XMM but still clear upper 64 bits.
1947 let AddedComplexity = 15 in
1948 def MOVZQI2PQIrr : I<0x7E, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1949                      "movq {$src, $dst|$dst, $src}",
1950                      [(set VR128:$dst, (int_x86_sse2_movl_dq VR128:$src))]>,
1951                    XS, Requires<[HasSSE2]>;
1952 let AddedComplexity = 20 in
1953 def MOVZQI2PQIrm : I<0x7E, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
1954                      "movq {$src, $dst|$dst, $src}",
1955                      [(set VR128:$dst, (int_x86_sse2_movl_dq
1956                                         (bitconvert (loadv2i64 addr:$src))))]>,
1957                    XS, Requires<[HasSSE2]>;
1958
1959
1960 //===----------------------------------------------------------------------===//
1961 // SSE3 Instructions
1962 //===----------------------------------------------------------------------===//
1963
1964 // SSE3 Instruction Templates:
1965 //
1966 //   S3I   - SSE3 instructions with TB and OpSize prefixes.
1967 //   S3SI  - SSE3 instructions with XS prefix.
1968 //   S3DI  - SSE3 instructions with XD prefix.
1969
1970 class S3SI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
1971       : I<o, F, ops, asm, pattern>, XS, Requires<[HasSSE3]>;
1972 class S3DI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
1973       : I<o, F, ops, asm, pattern>, XD, Requires<[HasSSE3]>;
1974 class S3I<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
1975       : I<o, F, ops, asm, pattern>, TB, OpSize, Requires<[HasSSE3]>;
1976
1977 // Move Instructions
1978 def MOVSHDUPrr : S3SI<0x16, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1979                       "movshdup {$src, $dst|$dst, $src}",
1980                       [(set VR128:$dst, (v4f32 (vector_shuffle
1981                                                 VR128:$src, (undef),
1982                                                 MOVSHDUP_shuffle_mask)))]>;
1983 def MOVSHDUPrm : S3SI<0x16, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1984                       "movshdup {$src, $dst|$dst, $src}",
1985                       [(set VR128:$dst, (v4f32 (vector_shuffle
1986                                                 (loadv4f32 addr:$src), (undef),
1987                                                 MOVSHDUP_shuffle_mask)))]>;
1988
1989 def MOVSLDUPrr : S3SI<0x12, MRMSrcReg, (ops VR128:$dst, VR128:$src),
1990                       "movsldup {$src, $dst|$dst, $src}",
1991                       [(set VR128:$dst, (v4f32 (vector_shuffle
1992                                                 VR128:$src, (undef),
1993                                                 MOVSLDUP_shuffle_mask)))]>;
1994 def MOVSLDUPrm : S3SI<0x12, MRMSrcMem, (ops VR128:$dst, f128mem:$src),
1995                       "movsldup {$src, $dst|$dst, $src}",
1996                       [(set VR128:$dst, (v4f32 (vector_shuffle
1997                                                 (loadv4f32 addr:$src), (undef),
1998                                                 MOVSLDUP_shuffle_mask)))]>;
1999
2000 def MOVDDUPrr  : S3DI<0x12, MRMSrcReg, (ops VR128:$dst, VR128:$src),
2001                       "movddup {$src, $dst|$dst, $src}",
2002                       [(set VR128:$dst, (v2f64 (vector_shuffle
2003                                                 VR128:$src, (undef),
2004                                                 SSE_splat_lo_mask)))]>;
2005 def MOVDDUPrm  : S3DI<0x12, MRMSrcMem, (ops VR128:$dst, f64mem:$src),
2006                       "movddup {$src, $dst|$dst, $src}",
2007                       [(set VR128:$dst,
2008                         (v2f64 (vector_shuffle
2009                                 (scalar_to_vector (loadf64 addr:$src)),
2010                                 (undef),
2011                                 SSE_splat_lo_mask)))]>;
2012
2013 // Arithmetic
2014 let isTwoAddress = 1 in {
2015   def ADDSUBPSrr : S3DI<0xD0, MRMSrcReg,
2016                         (ops VR128:$dst, VR128:$src1, VR128:$src2),
2017                         "addsubps {$src2, $dst|$dst, $src2}",
2018                         [(set VR128:$dst, (int_x86_sse3_addsub_ps VR128:$src1,
2019                                            VR128:$src2))]>;
2020   def ADDSUBPSrm : S3DI<0xD0, MRMSrcMem,
2021                         (ops VR128:$dst, VR128:$src1, f128mem:$src2),
2022                         "addsubps {$src2, $dst|$dst, $src2}",
2023                         [(set VR128:$dst, (int_x86_sse3_addsub_ps VR128:$src1,
2024                                            (load addr:$src2)))]>;
2025   def ADDSUBPDrr : S3I<0xD0, MRMSrcReg,
2026                        (ops VR128:$dst, VR128:$src1, VR128:$src2),
2027                        "addsubpd {$src2, $dst|$dst, $src2}",
2028                        [(set VR128:$dst, (int_x86_sse3_addsub_pd VR128:$src1,
2029                                           VR128:$src2))]>;
2030   def ADDSUBPDrm : S3I<0xD0, MRMSrcMem,
2031                        (ops VR128:$dst, VR128:$src1, f128mem:$src2),
2032                        "addsubpd {$src2, $dst|$dst, $src2}",
2033                        [(set VR128:$dst, (int_x86_sse3_addsub_pd VR128:$src1,
2034                                           (load addr:$src2)))]>;
2035 }
2036
2037 def LDDQUrm : S3DI<0xF0, MRMSrcMem, (ops VR128:$dst, i128mem:$src),
2038                    "lddqu {$src, $dst|$dst, $src}",
2039                    [(set VR128:$dst, (int_x86_sse3_ldu_dq addr:$src))]>;
2040
2041 // Horizontal ops
2042 class S3D_Intrr<bits<8> o, string OpcodeStr, Intrinsic IntId>
2043   : S3DI<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
2044          !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
2045          [(set VR128:$dst, (v4f32 (IntId VR128:$src1, VR128:$src2)))]>;
2046 class S3D_Intrm<bits<8> o, string OpcodeStr, Intrinsic IntId>
2047   : S3DI<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
2048          !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
2049          [(set VR128:$dst, (v4f32 (IntId VR128:$src1, (load addr:$src2))))]>;
2050 class S3_Intrr<bits<8> o, string OpcodeStr, Intrinsic IntId>
2051   : S3I<o, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
2052         !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
2053         [(set VR128:$dst, (v2f64 (IntId VR128:$src1, VR128:$src2)))]>;
2054 class S3_Intrm<bits<8> o, string OpcodeStr, Intrinsic IntId>
2055   : S3I<o, MRMSrcMem, (ops VR128:$dst, VR128:$src1, f128mem:$src2),
2056         !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
2057         [(set VR128:$dst, (v2f64 (IntId VR128:$src1, (load addr:$src2))))]>;
2058
2059 let isTwoAddress = 1 in {
2060   def HADDPSrr : S3D_Intrr<0x7C, "haddps", int_x86_sse3_hadd_ps>;
2061   def HADDPSrm : S3D_Intrm<0x7C, "haddps", int_x86_sse3_hadd_ps>;
2062   def HADDPDrr : S3_Intrr <0x7C, "haddpd", int_x86_sse3_hadd_pd>;
2063   def HADDPDrm : S3_Intrm <0x7C, "haddpd", int_x86_sse3_hadd_pd>;
2064   def HSUBPSrr : S3D_Intrr<0x7D, "hsubps", int_x86_sse3_hsub_ps>;
2065   def HSUBPSrm : S3D_Intrm<0x7D, "hsubps", int_x86_sse3_hsub_ps>;
2066   def HSUBPDrr : S3_Intrr <0x7D, "hsubpd", int_x86_sse3_hsub_pd>;
2067   def HSUBPDrm : S3_Intrm <0x7D, "hsubpd", int_x86_sse3_hsub_pd>;
2068 }
2069
2070 // Thread synchronization
2071 def MONITOR : I<0xC8, RawFrm, (ops), "monitor",
2072                 [(int_x86_sse3_monitor EAX, ECX, EDX)]>,TB, Requires<[HasSSE3]>;
2073 def MWAIT   : I<0xC9, RawFrm, (ops), "mwait",
2074                 [(int_x86_sse3_mwait ECX, EAX)]>, TB, Requires<[HasSSE3]>;
2075
2076 // vector_shuffle v1, <undef> <1, 1, 3, 3>
2077 let AddedComplexity = 15 in
2078 def : Pat<(v4i32 (vector_shuffle VR128:$src, (undef),
2079                   MOVSHDUP_shuffle_mask)),
2080           (MOVSHDUPrr VR128:$src)>, Requires<[HasSSE3]>;
2081 let AddedComplexity = 20 in
2082 def : Pat<(v4i32 (vector_shuffle (bc_v4i32 (loadv2i64 addr:$src)), (undef),
2083                   MOVSHDUP_shuffle_mask)),
2084           (MOVSHDUPrm addr:$src)>, Requires<[HasSSE3]>;
2085
2086 // vector_shuffle v1, <undef> <0, 0, 2, 2>
2087 let AddedComplexity = 15 in
2088   def : Pat<(v4i32 (vector_shuffle VR128:$src, (undef),
2089                     MOVSLDUP_shuffle_mask)),
2090             (MOVSLDUPrr VR128:$src)>, Requires<[HasSSE3]>;
2091 let AddedComplexity = 20 in
2092   def : Pat<(v4i32 (vector_shuffle (bc_v4i32 (loadv2i64 addr:$src)), (undef),
2093                     MOVSLDUP_shuffle_mask)),
2094             (MOVSLDUPrm addr:$src)>, Requires<[HasSSE3]>;
2095
2096 //===----------------------------------------------------------------------===//
2097 // SSSE3 Instructions
2098 //===----------------------------------------------------------------------===//
2099
2100 // SSE3 Instruction Templates:
2101 //
2102 //   SS38I - SSSE3 instructions with T8 and OpSize prefixes.
2103 //   SS3AI - SSSE3 instructions with TA and OpSize prefixes.
2104
2105 class SS38I<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
2106       : I<o, F, ops, asm, pattern>, T8, OpSize, Requires<[HasSSSE3]>;
2107 class SS3AI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
2108       : I<o, F, ops, asm, pattern>, TA, OpSize, Requires<[HasSSSE3]>;
2109
2110 /// SS3I_binop_rm_int - Simple SSSE3 binary operatr whose type is v2i64.
2111 let isTwoAddress = 1 in {
2112   multiclass SS3I_binop_rm_int<bits<8> opc, string OpcodeStr, Intrinsic IntId,
2113                                bit Commutable = 0> {
2114     def rr : SS38I<opc, MRMSrcReg, (ops VR128:$dst, VR128:$src1, VR128:$src2),
2115                    !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
2116                    [(set VR128:$dst, (IntId VR128:$src1, VR128:$src2))]> {
2117       let isCommutable = Commutable;
2118     }
2119     def rm : SS38I<opc, MRMSrcMem, (ops VR128:$dst, VR128:$src1, i128mem:$src2),
2120                    !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
2121                    [(set VR128:$dst,
2122                      (IntId VR128:$src1,
2123                       (bitconvert (loadv2i64 addr:$src2))))]>;
2124   }
2125 }
2126
2127 defm PMULHRSW128 : SS3I_binop_rm_int<0x0B, "pmulhrsw",
2128                                      int_x86_ssse3_pmulhrsw_128, 1>;
2129
2130 //===----------------------------------------------------------------------===//
2131 // Non-Instruction Patterns
2132 //===----------------------------------------------------------------------===//
2133
2134 // 128-bit vector undef's.
2135 def : Pat<(v2f64 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
2136 def : Pat<(v16i8 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
2137 def : Pat<(v8i16 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
2138 def : Pat<(v4i32 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
2139 def : Pat<(v2i64 (undef)), (IMPLICIT_DEF_VR128)>, Requires<[HasSSE2]>;
2140
2141 // 128-bit vector all zero's.
2142 def : Pat<(v16i8 immAllZerosV), (V_SET0)>, Requires<[HasSSE2]>;
2143 def : Pat<(v8i16 immAllZerosV), (V_SET0)>, Requires<[HasSSE2]>;
2144 def : Pat<(v4i32 immAllZerosV), (V_SET0)>, Requires<[HasSSE2]>;
2145 def : Pat<(v2i64 immAllZerosV), (V_SET0)>, Requires<[HasSSE2]>;
2146 def : Pat<(v2f64 immAllZerosV), (V_SET0)>, Requires<[HasSSE2]>;
2147
2148 // 128-bit vector all one's.
2149 def : Pat<(v16i8 immAllOnesV), (V_SETALLONES)>, Requires<[HasSSE2]>;
2150 def : Pat<(v8i16 immAllOnesV), (V_SETALLONES)>, Requires<[HasSSE2]>;
2151 def : Pat<(v4i32 immAllOnesV), (V_SETALLONES)>, Requires<[HasSSE2]>;
2152 def : Pat<(v2i64 immAllOnesV), (V_SETALLONES)>, Requires<[HasSSE2]>;
2153 def : Pat<(v4f32 immAllOnesV), (V_SETALLONES)>, Requires<[HasSSE1]>;
2154
2155 // Store 128-bit integer vector values.
2156 def : Pat<(store (v16i8 VR128:$src), addr:$dst),
2157           (MOVDQAmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
2158 def : Pat<(store (v8i16 VR128:$src), addr:$dst),
2159           (MOVDQAmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
2160 def : Pat<(store (v4i32 VR128:$src), addr:$dst),
2161           (MOVDQAmr addr:$dst, VR128:$src)>, Requires<[HasSSE2]>;
2162
2163 // Scalar to v8i16 / v16i8. The source may be a GR32, but only the lower 8 or
2164 // 16-bits matter.
2165 def : Pat<(v8i16 (X86s2vec GR32:$src)), (MOVDI2PDIrr GR32:$src)>,
2166       Requires<[HasSSE2]>;
2167 def : Pat<(v16i8 (X86s2vec GR32:$src)), (MOVDI2PDIrr GR32:$src)>,
2168       Requires<[HasSSE2]>;
2169
2170 // bit_convert
2171 let Predicates = [HasSSE2] in {
2172   def : Pat<(v2i64 (bitconvert (v4i32 VR128:$src))), (v2i64 VR128:$src)>;
2173   def : Pat<(v2i64 (bitconvert (v8i16 VR128:$src))), (v2i64 VR128:$src)>;
2174   def : Pat<(v2i64 (bitconvert (v16i8 VR128:$src))), (v2i64 VR128:$src)>;
2175   def : Pat<(v2i64 (bitconvert (v2f64 VR128:$src))), (v2i64 VR128:$src)>;
2176   def : Pat<(v2i64 (bitconvert (v4f32 VR128:$src))), (v2i64 VR128:$src)>;
2177   def : Pat<(v4i32 (bitconvert (v2i64 VR128:$src))), (v4i32 VR128:$src)>;
2178   def : Pat<(v4i32 (bitconvert (v8i16 VR128:$src))), (v4i32 VR128:$src)>;
2179   def : Pat<(v4i32 (bitconvert (v16i8 VR128:$src))), (v4i32 VR128:$src)>;
2180   def : Pat<(v4i32 (bitconvert (v2f64 VR128:$src))), (v4i32 VR128:$src)>;
2181   def : Pat<(v4i32 (bitconvert (v4f32 VR128:$src))), (v4i32 VR128:$src)>;
2182   def : Pat<(v8i16 (bitconvert (v2i64 VR128:$src))), (v8i16 VR128:$src)>;
2183   def : Pat<(v8i16 (bitconvert (v4i32 VR128:$src))), (v8i16 VR128:$src)>;
2184   def : Pat<(v8i16 (bitconvert (v16i8 VR128:$src))), (v8i16 VR128:$src)>;
2185   def : Pat<(v8i16 (bitconvert (v2f64 VR128:$src))), (v8i16 VR128:$src)>;
2186   def : Pat<(v8i16 (bitconvert (v4f32 VR128:$src))), (v8i16 VR128:$src)>;
2187   def : Pat<(v16i8 (bitconvert (v2i64 VR128:$src))), (v16i8 VR128:$src)>;
2188   def : Pat<(v16i8 (bitconvert (v4i32 VR128:$src))), (v16i8 VR128:$src)>;
2189   def : Pat<(v16i8 (bitconvert (v8i16 VR128:$src))), (v16i8 VR128:$src)>;
2190   def : Pat<(v16i8 (bitconvert (v2f64 VR128:$src))), (v16i8 VR128:$src)>;
2191   def : Pat<(v16i8 (bitconvert (v4f32 VR128:$src))), (v16i8 VR128:$src)>;
2192   def : Pat<(v4f32 (bitconvert (v2i64 VR128:$src))), (v4f32 VR128:$src)>;
2193   def : Pat<(v4f32 (bitconvert (v4i32 VR128:$src))), (v4f32 VR128:$src)>;
2194   def : Pat<(v4f32 (bitconvert (v8i16 VR128:$src))), (v4f32 VR128:$src)>;
2195   def : Pat<(v4f32 (bitconvert (v16i8 VR128:$src))), (v4f32 VR128:$src)>;
2196   def : Pat<(v4f32 (bitconvert (v2f64 VR128:$src))), (v4f32 VR128:$src)>;
2197   def : Pat<(v2f64 (bitconvert (v2i64 VR128:$src))), (v2f64 VR128:$src)>;
2198   def : Pat<(v2f64 (bitconvert (v4i32 VR128:$src))), (v2f64 VR128:$src)>;
2199   def : Pat<(v2f64 (bitconvert (v8i16 VR128:$src))), (v2f64 VR128:$src)>;
2200   def : Pat<(v2f64 (bitconvert (v16i8 VR128:$src))), (v2f64 VR128:$src)>;
2201   def : Pat<(v2f64 (bitconvert (v4f32 VR128:$src))), (v2f64 VR128:$src)>;
2202 }
2203
2204 // Move scalar to XMM zero-extended
2205 // movd to XMM register zero-extends
2206 let AddedComplexity = 15 in {
2207 def : Pat<(v8i16 (vector_shuffle immAllZerosV,
2208                   (v8i16 (X86s2vec GR32:$src)), MOVL_shuffle_mask)),
2209           (MOVZDI2PDIrr GR32:$src)>, Requires<[HasSSE2]>;
2210 def : Pat<(v16i8 (vector_shuffle immAllZerosV,
2211                   (v16i8 (X86s2vec GR32:$src)), MOVL_shuffle_mask)),
2212           (MOVZDI2PDIrr GR32:$src)>, Requires<[HasSSE2]>;
2213 // Zeroing a VR128 then do a MOVS{S|D} to the lower bits.
2214 def : Pat<(v2f64 (vector_shuffle immAllZerosV,
2215                   (v2f64 (scalar_to_vector FR64:$src)), MOVL_shuffle_mask)),
2216           (MOVLSD2PDrr (V_SET0), FR64:$src)>, Requires<[HasSSE2]>;
2217 def : Pat<(v4f32 (vector_shuffle immAllZerosV,
2218                   (v4f32 (scalar_to_vector FR32:$src)), MOVL_shuffle_mask)),
2219           (MOVLSS2PSrr (V_SET0), FR32:$src)>, Requires<[HasSSE2]>;
2220 }
2221
2222 // Splat v2f64 / v2i64
2223 let AddedComplexity = 10 in {
2224 def : Pat<(vector_shuffle (v2f64 VR128:$src), (undef), SSE_splat_lo_mask:$sm),
2225           (UNPCKLPDrr VR128:$src, VR128:$src)>,   Requires<[HasSSE2]>;
2226 def : Pat<(vector_shuffle (v2f64 VR128:$src), (undef), UNPCKH_shuffle_mask:$sm),
2227           (UNPCKHPDrr VR128:$src, VR128:$src)>,   Requires<[HasSSE2]>;
2228 def : Pat<(vector_shuffle (v2i64 VR128:$src), (undef), SSE_splat_lo_mask:$sm),
2229           (PUNPCKLQDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2230 def : Pat<(vector_shuffle (v2i64 VR128:$src), (undef), UNPCKH_shuffle_mask:$sm),
2231           (PUNPCKHQDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2232 }
2233
2234 // Splat v4f32
2235 def : Pat<(vector_shuffle (v4f32 VR128:$src), (undef), SSE_splat_mask:$sm),
2236           (SHUFPSrri VR128:$src, VR128:$src, SSE_splat_mask:$sm)>,
2237       Requires<[HasSSE1]>;
2238
2239 // Special unary SHUFPSrri case.
2240 // FIXME: when we want non two-address code, then we should use PSHUFD?
2241 def : Pat<(vector_shuffle (v4f32 VR128:$src1), (undef),
2242            SHUFP_unary_shuffle_mask:$sm),
2243           (SHUFPSrri VR128:$src1, VR128:$src1, SHUFP_unary_shuffle_mask:$sm)>,
2244       Requires<[HasSSE1]>;
2245 // Unary v4f32 shuffle with PSHUF* in order to fold a load.
2246 def : Pat<(vector_shuffle (loadv4f32 addr:$src1), (undef),
2247            SHUFP_unary_shuffle_mask:$sm),
2248           (PSHUFDmi addr:$src1, SHUFP_unary_shuffle_mask:$sm)>,
2249       Requires<[HasSSE2]>;
2250 // Special binary v4i32 shuffle cases with SHUFPS.
2251 def : Pat<(vector_shuffle (v4i32 VR128:$src1), (v4i32 VR128:$src2),
2252            PSHUFD_binary_shuffle_mask:$sm),
2253           (SHUFPSrri VR128:$src1, VR128:$src2, PSHUFD_binary_shuffle_mask:$sm)>,
2254            Requires<[HasSSE2]>;
2255 def : Pat<(vector_shuffle (v4i32 VR128:$src1),
2256            (bc_v4i32 (loadv2i64 addr:$src2)), PSHUFD_binary_shuffle_mask:$sm),
2257           (SHUFPSrmi VR128:$src1, addr:$src2, PSHUFD_binary_shuffle_mask:$sm)>,
2258            Requires<[HasSSE2]>;
2259
2260 // vector_shuffle v1, <undef>, <0, 0, 1, 1, ...>
2261 let AddedComplexity = 10 in {
2262 def : Pat<(v4f32 (vector_shuffle VR128:$src, (undef),
2263                   UNPCKL_v_undef_shuffle_mask)),
2264           (UNPCKLPSrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2265 def : Pat<(v16i8 (vector_shuffle VR128:$src, (undef),
2266                   UNPCKL_v_undef_shuffle_mask)),
2267           (PUNPCKLBWrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2268 def : Pat<(v8i16 (vector_shuffle VR128:$src, (undef),
2269                   UNPCKL_v_undef_shuffle_mask)),
2270           (PUNPCKLWDrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2271 def : Pat<(v4i32 (vector_shuffle VR128:$src, (undef),
2272                   UNPCKL_v_undef_shuffle_mask)),
2273           (PUNPCKLDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE1]>;
2274 }
2275
2276 // vector_shuffle v1, <undef>, <2, 2, 3, 3, ...>
2277 let AddedComplexity = 10 in {
2278 def : Pat<(v4f32 (vector_shuffle VR128:$src, (undef),
2279                   UNPCKH_v_undef_shuffle_mask)),
2280           (UNPCKHPSrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2281 def : Pat<(v16i8 (vector_shuffle VR128:$src, (undef),
2282                   UNPCKH_v_undef_shuffle_mask)),
2283           (PUNPCKHBWrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2284 def : Pat<(v8i16 (vector_shuffle VR128:$src, (undef),
2285                   UNPCKH_v_undef_shuffle_mask)),
2286           (PUNPCKHWDrr VR128:$src, VR128:$src)>, Requires<[HasSSE2]>;
2287 def : Pat<(v4i32 (vector_shuffle VR128:$src, (undef),
2288                   UNPCKH_v_undef_shuffle_mask)),
2289           (PUNPCKHDQrr VR128:$src, VR128:$src)>, Requires<[HasSSE1]>;
2290 }
2291
2292 let AddedComplexity = 15 in {
2293 // vector_shuffle v1, v2 <0, 1, 4, 5> using MOVLHPS
2294 def : Pat<(v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
2295                   MOVHP_shuffle_mask)),
2296           (MOVLHPSrr VR128:$src1, VR128:$src2)>;
2297
2298 // vector_shuffle v1, v2 <6, 7, 2, 3> using MOVHLPS
2299 def : Pat<(v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
2300                   MOVHLPS_shuffle_mask)),
2301           (MOVHLPSrr VR128:$src1, VR128:$src2)>;
2302
2303 // vector_shuffle v1, undef <2, ?, ?, ?> using MOVHLPS
2304 def : Pat<(v4f32 (vector_shuffle VR128:$src1, (undef),
2305                   MOVHLPS_v_undef_shuffle_mask)),
2306           (MOVHLPSrr VR128:$src1, VR128:$src1)>;
2307 def : Pat<(v4i32 (vector_shuffle VR128:$src1, (undef),
2308                   MOVHLPS_v_undef_shuffle_mask)),
2309           (MOVHLPSrr VR128:$src1, VR128:$src1)>;
2310 }
2311
2312 let AddedComplexity = 20 in {
2313 // vector_shuffle v1, (load v2) <4, 5, 2, 3> using MOVLPS
2314 // vector_shuffle v1, (load v2) <0, 1, 4, 5> using MOVHPS
2315 def : Pat<(v4f32 (vector_shuffle VR128:$src1, (loadv4f32 addr:$src2),
2316                   MOVLP_shuffle_mask)),
2317           (MOVLPSrm VR128:$src1, addr:$src2)>, Requires<[HasSSE1]>;
2318 def : Pat<(v2f64 (vector_shuffle VR128:$src1, (loadv2f64 addr:$src2),
2319                   MOVLP_shuffle_mask)),
2320           (MOVLPDrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2321 def : Pat<(v4f32 (vector_shuffle VR128:$src1, (loadv4f32 addr:$src2),
2322                   MOVHP_shuffle_mask)),
2323           (MOVHPSrm VR128:$src1, addr:$src2)>, Requires<[HasSSE1]>;
2324 def : Pat<(v2f64 (vector_shuffle VR128:$src1, (loadv2f64 addr:$src2),
2325                   MOVHP_shuffle_mask)),
2326           (MOVHPDrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2327
2328 def : Pat<(v4i32 (vector_shuffle VR128:$src1, (bc_v4i32 (loadv2i64 addr:$src2)),
2329                   MOVLP_shuffle_mask)),
2330           (MOVLPSrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2331 def : Pat<(v2i64 (vector_shuffle VR128:$src1, (loadv2i64 addr:$src2),
2332                   MOVLP_shuffle_mask)),
2333           (MOVLPDrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2334 def : Pat<(v4i32 (vector_shuffle VR128:$src1, (bc_v4i32 (loadv2i64 addr:$src2)),
2335                   MOVHP_shuffle_mask)),
2336           (MOVHPSrm VR128:$src1, addr:$src2)>, Requires<[HasSSE1]>;
2337 def : Pat<(v2i64 (vector_shuffle VR128:$src1, (loadv2i64 addr:$src2),
2338                   MOVLP_shuffle_mask)),
2339           (MOVLPDrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2340 }
2341
2342 let AddedComplexity = 15 in {
2343 // Setting the lowest element in the vector.
2344 def : Pat<(v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
2345                   MOVL_shuffle_mask)),
2346           (MOVLPSrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
2347 def : Pat<(v2i64 (vector_shuffle VR128:$src1, VR128:$src2,
2348                   MOVL_shuffle_mask)),
2349           (MOVLPDrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
2350
2351 // vector_shuffle v1, v2 <4, 5, 2, 3> using MOVLPDrr (movsd)
2352 def : Pat<(v4f32 (vector_shuffle VR128:$src1, VR128:$src2,
2353                   MOVLP_shuffle_mask)),
2354           (MOVLPDrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
2355 def : Pat<(v4i32 (vector_shuffle VR128:$src1, VR128:$src2,
2356                   MOVLP_shuffle_mask)),
2357           (MOVLPDrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
2358 }
2359
2360 // Set lowest element and zero upper elements.
2361 let AddedComplexity = 20 in
2362 def : Pat<(bc_v2i64 (vector_shuffle immAllZerosV,
2363                      (v2f64 (scalar_to_vector (loadf64 addr:$src))),
2364                      MOVL_shuffle_mask)),
2365           (MOVZQI2PQIrm addr:$src)>, Requires<[HasSSE2]>;
2366
2367 // FIXME: Temporary workaround since 2-wide shuffle is broken.
2368 def : Pat<(int_x86_sse2_movs_d  VR128:$src1, VR128:$src2),
2369           (v2f64 (MOVLPDrr VR128:$src1, VR128:$src2))>, Requires<[HasSSE2]>;
2370 def : Pat<(int_x86_sse2_loadh_pd VR128:$src1, addr:$src2),
2371           (v2f64 (MOVHPDrm VR128:$src1, addr:$src2))>, Requires<[HasSSE2]>;
2372 def : Pat<(int_x86_sse2_loadl_pd VR128:$src1, addr:$src2),
2373           (v2f64 (MOVLPDrm VR128:$src1, addr:$src2))>, Requires<[HasSSE2]>;
2374 def : Pat<(int_x86_sse2_shuf_pd VR128:$src1, VR128:$src2, imm:$src3),
2375           (v2f64 (SHUFPDrri VR128:$src1, VR128:$src2, imm:$src3))>,
2376       Requires<[HasSSE2]>;
2377 def : Pat<(int_x86_sse2_shuf_pd VR128:$src1, (load addr:$src2), imm:$src3),
2378           (v2f64 (SHUFPDrmi VR128:$src1, addr:$src2, imm:$src3))>,
2379       Requires<[HasSSE2]>;
2380 def : Pat<(int_x86_sse2_unpckh_pd VR128:$src1, VR128:$src2),
2381           (v2f64 (UNPCKHPDrr VR128:$src1, VR128:$src2))>, Requires<[HasSSE2]>;
2382 def : Pat<(int_x86_sse2_unpckh_pd VR128:$src1, (load addr:$src2)),
2383           (v2f64 (UNPCKHPDrm VR128:$src1, addr:$src2))>, Requires<[HasSSE2]>;
2384 def : Pat<(int_x86_sse2_unpckl_pd VR128:$src1, VR128:$src2),
2385           (v2f64 (UNPCKLPDrr VR128:$src1, VR128:$src2))>, Requires<[HasSSE2]>;
2386 def : Pat<(int_x86_sse2_unpckl_pd VR128:$src1, (load addr:$src2)),
2387           (v2f64 (UNPCKLPDrm VR128:$src1, addr:$src2))>, Requires<[HasSSE2]>;
2388 def : Pat<(int_x86_sse2_punpckh_qdq VR128:$src1, VR128:$src2),
2389           (v2i64 (PUNPCKHQDQrr VR128:$src1, VR128:$src2))>, Requires<[HasSSE2]>;
2390 def : Pat<(int_x86_sse2_punpckh_qdq VR128:$src1, (load addr:$src2)),
2391           (v2i64 (PUNPCKHQDQrm VR128:$src1, addr:$src2))>, Requires<[HasSSE2]>;
2392 def : Pat<(int_x86_sse2_punpckl_qdq VR128:$src1, VR128:$src2),
2393           (v2i64 (PUNPCKLQDQrr VR128:$src1, VR128:$src2))>, Requires<[HasSSE2]>;
2394 def : Pat<(int_x86_sse2_punpckl_qdq VR128:$src1, (load addr:$src2)),
2395           (PUNPCKLQDQrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2396
2397 // Some special case pandn patterns.
2398 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v4i32 immAllOnesV))),
2399                   VR128:$src2)),
2400           (PANDNrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
2401 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v8i16 immAllOnesV))),
2402                   VR128:$src2)),
2403           (PANDNrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
2404 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v16i8 immAllOnesV))),
2405                   VR128:$src2)),
2406           (PANDNrr VR128:$src1, VR128:$src2)>, Requires<[HasSSE2]>;
2407
2408 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v4i32 immAllOnesV))),
2409                   (load addr:$src2))),
2410           (PANDNrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2411 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v8i16 immAllOnesV))),
2412                   (load addr:$src2))),
2413           (PANDNrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2414 def : Pat<(v2i64 (and (xor VR128:$src1, (bc_v2i64 (v16i8 immAllOnesV))),
2415                   (load addr:$src2))),
2416           (PANDNrm VR128:$src1, addr:$src2)>, Requires<[HasSSE2]>;
2417
2418 // Unaligned load
2419 def : Pat<(v4f32 (X86loadu addr:$src)), (MOVUPSrm addr:$src)>,
2420       Requires<[HasSSE1]>;