lib/Target/X86/X86InstrMMX.td

   1 //====- X86InstrMMX.td - Describe the X86 Instruction Set --*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the Evan Cheng and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the X86 MMX 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 // Instruction templates
  18 //===----------------------------------------------------------------------===//
  19
  20 // MMXI   - MMX instructions with TB prefix.
  21 // MMX2I  - MMX / SSE2 instructions with TB and OpSize prefixes.
  22 // MMXIi8 - MMX instructions with ImmT == Imm8 and TB prefix.
  23 class MMXI<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
  24       : I<o, F, ops, asm, pattern>, TB, Requires<[HasMMX]>;
  25 class MMX2I<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
  26       : I<o, F, ops, asm, pattern>, TB, OpSize, Requires<[HasSSE2]>;
  27 class MMXIi8<bits<8> o, Format F, dag ops, string asm, list<dag> pattern>
  28       : Ii8<o, F, ops, asm, pattern>, TB, Requires<[HasMMX]>;
  29
  30 // Some 'special' instructions
  31 def IMPLICIT_DEF_VR64 : I<0, Pseudo, (ops VR64:$dst),
  32                           "#IMPLICIT_DEF $dst",
  33                           [(set VR64:$dst, (v8i8 (undef)))]>,
  34                         Requires<[HasMMX]>;
  35
  36 // 64-bit vector undef's.
  37 def : Pat<(v8i8  (undef)), (IMPLICIT_DEF_VR64)>;
  38 def : Pat<(v4i16 (undef)), (IMPLICIT_DEF_VR64)>;
  39 def : Pat<(v2i32 (undef)), (IMPLICIT_DEF_VR64)>;
  40
  41 //===----------------------------------------------------------------------===//
  42 // MMX Pattern Fragments
  43 //===----------------------------------------------------------------------===//
  44
  45 def loadv2i32 : PatFrag<(ops node:$ptr), (v2i32 (load node:$ptr))>;
  46
  47 def bc_v8i8  : PatFrag<(ops node:$in), (v8i8  (bitconvert node:$in))>;
  48 def bc_v4i16 : PatFrag<(ops node:$in), (v4i16 (bitconvert node:$in))>;
  49 def bc_v2i32 : PatFrag<(ops node:$in), (v2i32 (bitconvert node:$in))>;
  50
  51 //===----------------------------------------------------------------------===//
  52 // MMX Multiclasses
  53 //===----------------------------------------------------------------------===//
  54
  55 let isTwoAddress = 1 in {
  56   // MMXI_binop_rm - Simple MMX binary operator.
  57   multiclass MMXI_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
  58                            ValueType OpVT, bit Commutable = 0> {
  59     def rr : MMXI<opc, MRMSrcReg, (ops VR64:$dst, VR64:$src1, VR64:$src2),
  60                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  61                   [(set VR64:$dst, (OpVT (OpNode VR64:$src1, VR64:$src2)))]> {
  62       let isCommutable = Commutable;
  63     }
  64     def rm : MMXI<opc, MRMSrcMem, (ops VR64:$dst, VR64:$src1, i64mem:$src2),
  65                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  66                   [(set VR64:$dst, (OpVT (OpNode VR64:$src1,
  67                                          (bitconvert
  68                                           (loadv2i32 addr:$src2)))))]>;
  69   }
  70
  71   multiclass MMXI_binop_rm_int<bits<8> opc, string OpcodeStr, Intrinsic IntId,
  72                                bit Commutable = 0> {
  73     def rr : MMXI<opc, MRMSrcReg, (ops VR64:$dst, VR64:$src1, VR64:$src2),
  74                  !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  75                  [(set VR64:$dst, (IntId VR64:$src1, VR64:$src2))]> {
  76       let isCommutable = Commutable;
  77     }
  78     def rm : MMXI<opc, MRMSrcMem, (ops VR64:$dst, VR64:$src1, i64mem:$src2),
  79                  !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  80                  [(set VR64:$dst, (IntId VR64:$src1,
  81                                    (bitconvert (loadv2i32 addr:$src2))))]>;
  82   }
  83
  84   // MMXI_binop_rm_v2i32 - Simple MMX binary operator whose type is v2i32.
  85   //
  86   // FIXME: we could eliminate this and use MMXI_binop_rm instead if tblgen knew
  87   // to collapse (bitconvert VT to VT) into its operand.
  88   //
  89   multiclass MMXI_binop_rm_v2i32<bits<8> opc, string OpcodeStr, SDNode OpNode,
  90                                  bit Commutable = 0> {
  91     def rr : MMXI<opc, MRMSrcReg, (ops VR64:$dst, VR64:$src1, VR64:$src2),
  92                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  93                   [(set VR64:$dst, (v2i32 (OpNode VR64:$src1, VR64:$src2)))]> {
  94       let isCommutable = Commutable;
  95     }
  96     def rm : MMXI<opc, MRMSrcMem, (ops VR64:$dst, VR64:$src1, i64mem:$src2),
  97                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  98                   [(set VR64:$dst,
  99                     (OpNode VR64:$src1,(loadv2i32 addr:$src2)))]>;
 100   }
 101
 102   multiclass MMXI_binop_rmi_int<bits<8> opc, bits<8> opc2, Format ImmForm,
 103                                 string OpcodeStr, Intrinsic IntId> {
 104     def rr : MMXI<opc, MRMSrcReg, (ops VR64:$dst, VR64:$src1, VR64:$src2),
 105                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
 106                   [(set VR64:$dst, (IntId VR64:$src1, VR64:$src2))]>;
 107     def rm : MMXI<opc, MRMSrcMem, (ops VR64:$dst, VR64:$src1, i64mem:$src2),
 108                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
 109                   [(set VR64:$dst, (IntId VR64:$src1,
 110                                     (bitconvert (loadv2i32 addr:$src2))))]>;
 111     def ri : MMXIi8<opc2, ImmForm, (ops VR64:$dst, VR64:$src1, i32i8imm:$src2),
 112                     !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
 113                     [(set VR64:$dst, (IntId VR64:$src1,
 114                                       (scalar_to_vector (i32 imm:$src2))))]>;
 115   }
 116 }
 117
 118 //===----------------------------------------------------------------------===//
 119 // MMX EMMS Instruction
 120 //===----------------------------------------------------------------------===//
 121
 122 def MMX_EMMS : MMXI<0x77, RawFrm, (ops), "emms", [(int_x86_mmx_emms)]>;
 123
 124 //===----------------------------------------------------------------------===//
 125 // MMX Scalar Instructions
 126 //===----------------------------------------------------------------------===//
 127
 128 // Arithmetic Instructions
 129 defm MMX_PADDB : MMXI_binop_rm<0xFC, "paddb", add, v8i8, 1>;
 130 defm MMX_PADDW : MMXI_binop_rm<0xFD, "paddw", add, v4i16, 1>;
 131 defm MMX_PADDD : MMXI_binop_rm<0xFE, "paddd", add, v2i32, 1>;
 132
 133 defm MMX_PADDSB  : MMXI_binop_rm_int<0xEC, "paddsb" , int_x86_mmx_padds_b, 1>;
 134 defm MMX_PADDSW  : MMXI_binop_rm_int<0xED, "paddsw" , int_x86_mmx_padds_w, 1>;
 135
 136 defm MMX_PADDUSB : MMXI_binop_rm_int<0xDC, "paddusb", int_x86_mmx_paddus_b, 1>;
 137 defm MMX_PADDUSW : MMXI_binop_rm_int<0xDD, "paddusw", int_x86_mmx_paddus_w, 1>;
 138
 139 defm MMX_PSUBB : MMXI_binop_rm<0xF8, "psubb", sub, v8i8>;
 140 defm MMX_PSUBW : MMXI_binop_rm<0xF9, "psubw", sub, v4i16>;
 141 defm MMX_PSUBD : MMXI_binop_rm<0xFA, "psubd", sub, v2i32>;
 142
 143 defm MMX_PSUBSB  : MMXI_binop_rm_int<0xE8, "psubsb" , int_x86_mmx_psubs_b>;
 144 defm MMX_PSUBSW  : MMXI_binop_rm_int<0xE9, "psubsw" , int_x86_mmx_psubs_w>;
 145
 146 defm MMX_PSUBUSB : MMXI_binop_rm_int<0xD8, "psubusb", int_x86_mmx_psubus_b>;
 147 defm MMX_PSUBUSW : MMXI_binop_rm_int<0xD9, "psubusw", int_x86_mmx_psubus_w>;
 148
 149 defm MMX_PMULLW  : MMXI_binop_rm<0xD5, "pmullw", mul, v4i16, 1>;
 150
 151 defm MMX_PMULHW  : MMXI_binop_rm_int<0xE5, "pmulhw" , int_x86_mmx_pmulh_w , 1>;
 152 defm MMX_PMADDWD : MMXI_binop_rm_int<0xF5, "pmaddwd", int_x86_mmx_pmadd_wd, 1>;
 153
 154
 155 // MMX_SHUFFLE_get_shuf_imm xform function: convert vector_shuffle mask to
 156 // MMX_PSHUF*, MMX_SHUFP* etc. imm.
 157 def MMX_SHUFFLE_get_shuf_imm : SDNodeXForm<build_vector, [{
 158   return getI8Imm(X86::getShuffleSHUFImmediate(N));
 159 }]>;
 160
 161 def MMX_splat_mask : PatLeaf<(build_vector), [{
 162   return X86::isSplatMask(N);
 163 }], MMX_SHUFFLE_get_shuf_imm>;
 164
 165 def MMX_UNPCKH_shuffle_mask : PatLeaf<(build_vector), [{
 166   return X86::isUNPCKHMask(N);
 167 }]>;
 168
 169 let isTwoAddress = 1 in {
 170 def MMX_PUNPCKHBWrr : MMXI<0x68, MRMSrcReg,
 171                            (ops VR64:$dst, VR64:$src1, VR64:$src2),
 172                            "punpckhbw {$src2, $dst|$dst, $src2}",
 173                            [(set VR64:$dst,
 174                              (v8i8 (vector_shuffle VR64:$src1, VR64:$src2,
 175                                     MMX_UNPCKH_shuffle_mask)))]>;
 176 def MMX_PUNPCKHBWrm : MMXI<0x68, MRMSrcMem,
 177                            (ops VR64:$dst, VR64:$src1, i64mem:$src2),
 178                            "punpckhbw {$src2, $dst|$dst, $src2}",
 179                            [(set VR64:$dst,
 180                              (v8i8 (vector_shuffle VR64:$src1,
 181                                     (bc_v8i8 (loadv2i32 addr:$src2)),
 182                                     MMX_UNPCKH_shuffle_mask)))]>;
 183 def MMX_PUNPCKHWDrr : MMXI<0x69, MRMSrcReg,
 184                            (ops VR64:$dst, VR64:$src1, VR64:$src2),
 185                            "punpckhwd {$src2, $dst|$dst, $src2}",
 186                            [(set VR64:$dst,
 187                              (v4i16 (vector_shuffle VR64:$src1, VR64:$src2,
 188                                      MMX_UNPCKH_shuffle_mask)))]>;
 189 def MMX_PUNPCKHWDrm : MMXI<0x69, MRMSrcMem,
 190                            (ops VR64:$dst, VR64:$src1, i64mem:$src2),
 191                            "punpckhwd {$src2, $dst|$dst, $src2}",
 192                            [(set VR64:$dst,
 193                              (v4i16 (vector_shuffle VR64:$src1,
 194                                      (bc_v4i16 (loadv2i32 addr:$src2)),
 195                                      MMX_UNPCKH_shuffle_mask)))]>;
 196 def MMX_PUNPCKHDQrr : MMXI<0x6A, MRMSrcReg,
 197                            (ops VR64:$dst, VR64:$src1, VR64:$src2),
 198                            "punpckhdq {$src2, $dst|$dst, $src2}",
 199                            [(set VR64:$dst,
 200                              (v2i32 (vector_shuffle VR64:$src1, VR64:$src2,
 201                                      MMX_UNPCKH_shuffle_mask)))]>;
 202 def MMX_PUNPCKHDQrm : MMXI<0x6A, MRMSrcMem,
 203                            (ops VR64:$dst, VR64:$src1, i64mem:$src2),
 204                            "punpckhdq {$src2, $dst|$dst, $src2}",
 205                            [(set VR64:$dst,
 206                              (v2i32 (vector_shuffle VR64:$src1,
 207                                      (loadv2i32 addr:$src2),
 208                                      MMX_UNPCKH_shuffle_mask)))]>;
 209 }
 210
 211 // Logical Instructions
 212 defm MMX_PAND : MMXI_binop_rm_v2i32<0xDB, "pand", and, 1>;
 213 defm MMX_POR  : MMXI_binop_rm_v2i32<0xEB, "por" , or,  1>;
 214 defm MMX_PXOR : MMXI_binop_rm_v2i32<0xEF, "pxor", xor, 1>;
 215
 216 let isTwoAddress = 1 in {
 217   def MMX_PANDNrr : MMXI<0xDF, MRMSrcReg,
 218                          (ops VR64:$dst, VR64:$src1, VR64:$src2),
 219                          "pandn {$src2, $dst|$dst, $src2}",
 220                          [(set VR64:$dst, (v2i32 (and (vnot VR64:$src1),
 221                                                   VR64:$src2)))]>;
 222   def MMX_PANDNrm : MMXI<0xDF, MRMSrcMem,
 223                          (ops VR64:$dst, VR64:$src1, i64mem:$src2),
 224                          "pandn {$src2, $dst|$dst, $src2}",
 225                          [(set VR64:$dst, (v2i32 (and (vnot VR64:$src1),
 226                                                   (load addr:$src2))))]>;
 227 }
 228
 229 // Shift Instructions
 230 defm MMX_PSRLW : MMXI_binop_rmi_int<0xD1, 0x71, MRM2r, "psrlw",
 231                                     int_x86_mmx_psrl_w>;
 232 defm MMX_PSRLD : MMXI_binop_rmi_int<0xD2, 0x72, MRM2r, "psrld",
 233                                     int_x86_mmx_psrl_d>;
 234 defm MMX_PSRLQ : MMXI_binop_rmi_int<0xD3, 0x73, MRM2r, "psrlq",
 235                                     int_x86_mmx_psrl_q>;
 236
 237 defm MMX_PSLLW : MMXI_binop_rmi_int<0xF1, 0x71, MRM6r, "psllw",
 238                                     int_x86_mmx_psll_w>;
 239 defm MMX_PSLLD : MMXI_binop_rmi_int<0xF2, 0x72, MRM6r, "pslld",
 240                                     int_x86_mmx_psll_d>;
 241 defm MMX_PSLLQ : MMXI_binop_rmi_int<0xF3, 0x73, MRM6r, "psllq",
 242                                     int_x86_mmx_psll_q>;
 243
 244 defm MMX_PSRAW : MMXI_binop_rmi_int<0xE1, 0x71, MRM4r, "psraw",
 245                                     int_x86_mmx_psra_w>;
 246 defm MMX_PSRAD : MMXI_binop_rmi_int<0xE2, 0x72, MRM4r, "psrad",
 247                                     int_x86_mmx_psra_d>;
 248
 249 // Move Instructions
 250 def MOVD64rr : MMXI<0x6E, MRMSrcReg, (ops VR64:$dst, GR32:$src),
 251                     "movd {$src, $dst|$dst, $src}", []>;
 252 def MOVD64rm : MMXI<0x6E, MRMSrcMem, (ops VR64:$dst, i32mem:$src),
 253                     "movd {$src, $dst|$dst, $src}", []>;
 254 def MOVD64mr : MMXI<0x7E, MRMDestMem, (ops i32mem:$dst, VR64:$src),
 255                     "movd {$src, $dst|$dst, $src}", []>;
 256
 257 def MOVQ64rr : MMXI<0x6F, MRMSrcReg, (ops VR64:$dst, VR64:$src),
 258                     "movq {$src, $dst|$dst, $src}", []>;
 259 def MOVQ64rm : MMXI<0x6F, MRMSrcMem, (ops VR64:$dst, i64mem:$src),
 260                     "movq {$src, $dst|$dst, $src}",
 261                     [(set VR64:$dst, (loadv2i32 addr:$src))]>;
 262 def MOVQ64mr : MMXI<0x7F, MRMDestMem, (ops i64mem:$dst, VR64:$src),
 263                     "movq {$src, $dst|$dst, $src}",
 264                     [(store (v2i32 VR64:$src), addr:$dst)]>;
 265
 266 // Conversion instructions
 267 def CVTPI2PSrr : MMXI<0x2A, MRMSrcReg, (ops VR128:$dst, VR64:$src),
 268                       "cvtpi2ps {$src, $dst|$dst, $src}", []>;
 269 def CVTPI2PSrm : MMXI<0x2A, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
 270                       "cvtpi2ps {$src, $dst|$dst, $src}", []>;
 271 def CVTPI2PDrr : MMX2I<0x2A, MRMSrcReg, (ops VR128:$dst, VR64:$src),
 272                        "cvtpi2pd {$src, $dst|$dst, $src}", []>;
 273 def CVTPI2PDrm : MMX2I<0x2A, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
 274                        "cvtpi2pd {$src, $dst|$dst, $src}", []>;
 275 def CVTTPS2PIrr: I<0x2C, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 276                    "cvttps2pi {$src, $dst|$dst, $src}", []>, TB,
 277                    Requires<[HasMMX]>;
 278 def CVTTPS2PIrm: I<0x2C, MRMSrcMem, (ops VR64:$dst, f64mem:$src),
 279                    "cvttps2pi {$src, $dst|$dst, $src}", []>, TB,
 280                  Requires<[HasMMX]>;
 281 def CVTPS2PIrr : MMXI<0x2D, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 282                       "cvtps2pi {$src, $dst|$dst, $src}", []>;
 283 def CVTPS2PIrm : MMXI<0x2D, MRMSrcMem, (ops VR64:$dst, f64mem:$src),
 284                       "cvtps2pi {$src, $dst|$dst, $src}", []>;
 285 def CVTPD2PIrr : MMX2I<0x2D, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 286                        "cvtpd2pi {$src, $dst|$dst, $src}", []>;
 287 def CVTPD2PIrm : MMX2I<0x2D, MRMSrcMem, (ops VR64:$dst, f128mem:$src),
 288                        "cvtpd2pi {$src, $dst|$dst, $src}", []>;
 289
 290 // Shuffle and unpack instructions
 291 def PSHUFWri : MMXIi8<0x70, MRMSrcReg,
 292                       (ops VR64:$dst, VR64:$src1, i8imm:$src2),
 293                       "pshufw {$src2, $src1, $dst|$dst, $src1, $src2}", []>;
 294 def PSHUFWmi : MMXIi8<0x70, MRMSrcMem,
 295                       (ops VR64:$dst, i64mem:$src1, i8imm:$src2),
 296                       "pshufw {$src2, $src1, $dst|$dst, $src1, $src2}", []>;
 297
 298 // Misc.
 299 def MOVNTQ   : I<0xE7, MRMDestMem, (ops i64mem:$dst, VR64:$src),
 300                  "movntq {$src, $dst|$dst, $src}", []>, TB,
 301                Requires<[HasMMX]>;
 302
 303 def MASKMOVQ : I<0xF7, MRMDestMem, (ops VR64:$src, VR64:$mask),
 304                  "maskmovq {$mask, $src|$src, $mask}", []>, TB,
 305                Requires<[HasMMX]>;
 306
 307 //===----------------------------------------------------------------------===//
 308 // Non-Instruction Patterns
 309 //===----------------------------------------------------------------------===//
 310
 311 // Store 64-bit integer vector values.
 312 def : Pat<(store (v8i8  VR64:$src), addr:$dst),
 313           (MOVQ64mr addr:$dst, VR64:$src)>;
 314 def : Pat<(store (v4i16 VR64:$src), addr:$dst),
 315           (MOVQ64mr addr:$dst, VR64:$src)>;
 316
 317 // Bit convert.
 318 def : Pat<(v8i8  (bitconvert (v2i32 VR64:$src))), (v8i8  VR64:$src)>;
 319 def : Pat<(v8i8  (bitconvert (v4i16 VR64:$src))), (v8i8  VR64:$src)>;
 320 def : Pat<(v4i16 (bitconvert (v2i32 VR64:$src))), (v4i16 VR64:$src)>;
 321 def : Pat<(v4i16 (bitconvert (v8i8  VR64:$src))), (v4i16 VR64:$src)>;
 322 def : Pat<(v2i32 (bitconvert (v4i16 VR64:$src))), (v2i32 VR64:$src)>;
 323 def : Pat<(v2i32 (bitconvert (v8i8  VR64:$src))), (v2i32 VR64:$src)>;
 324
 325 // Splat v2i32
 326 let AddedComplexity = 10 in {
 327   def : Pat<(vector_shuffle (v2i32 VR64:$src), (undef),
 328              MMX_splat_mask:$sm),
 329             (MMX_PUNPCKHDQrr VR64:$src, VR64:$src)>;
 330   def : Pat<(vector_shuffle (v2i32 VR64:$src), (undef),
 331              MMX_UNPCKH_shuffle_mask:$sm),
 332             (MMX_PUNPCKHDQrr VR64:$src, VR64:$src)>;
 333 }
 334
 335 def MMX_X86s2vec : SDNode<"X86ISD::S2VEC",  SDTypeProfile<1, 1, []>, []>;
 336
 337 // Scalar to v4i16 / v8i8. The source may be a GR32, but only the lower 8 or
 338 // 16-bits matter.
 339 def : Pat<(v4i16 (MMX_X86s2vec GR32:$src)), (MOVD64rr GR32:$src)>;
 340 def : Pat<(v8i8 (MMX_X86s2vec GR32:$src)), (MOVD64rr GR32:$src)>;