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 //===----------------------------------------------------------------------===//
  48 // MMX Multiclasses
  49 //===----------------------------------------------------------------------===//
  50
  51 let isTwoAddress = 1 in {
  52   // MMXI_binop_rm - Simple MMX binary operator.
  53   multiclass MMXI_binop_rm<bits<8> opc, string OpcodeStr, SDNode OpNode,
  54                            ValueType OpVT, bit Commutable = 0> {
  55     def rr : MMXI<opc, MRMSrcReg, (ops VR64:$dst, VR64:$src1, VR64:$src2),
  56                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  57                   [(set VR64:$dst, (OpVT (OpNode VR64:$src1, VR64:$src2)))]> {
  58       let isCommutable = Commutable;
  59     }
  60     def rm : MMXI<opc, MRMSrcMem, (ops VR64:$dst, VR64:$src1, i64mem:$src2),
  61                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  62                   [(set VR64:$dst, (OpVT (OpNode VR64:$src1,
  63                                          (bitconvert
  64                                           (loadv2i32 addr:$src2)))))]>;
  65   }
  66
  67   multiclass MMXI_binop_rm_int<bits<8> opc, string OpcodeStr, Intrinsic IntId,
  68                                bit Commutable = 0> {
  69     def rr : MMXI<opc, MRMSrcReg, (ops VR64:$dst, VR64:$src1, VR64:$src2),
  70                  !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  71                  [(set VR64:$dst, (IntId VR64:$src1, VR64:$src2))]> {
  72       let isCommutable = Commutable;
  73     }
  74     def rm : MMXI<opc, MRMSrcMem, (ops VR64:$dst, VR64:$src1, i64mem:$src2),
  75                  !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  76                  [(set VR64:$dst, (IntId VR64:$src1,
  77                                    (bitconvert (loadv2i32 addr:$src2))))]>;
  78   }
  79
  80   // MMXI_binop_rm_v2i32 - Simple MMX binary operator whose type is v2i32.
  81   //
  82   // FIXME: we could eliminate this and use MMXI_binop_rm instead if tblgen knew
  83   // to collapse (bitconvert VT to VT) into its operand.
  84   //
  85   multiclass MMXI_binop_rm_v2i32<bits<8> opc, string OpcodeStr, SDNode OpNode,
  86                                  bit Commutable = 0> {
  87     def rr : MMXI<opc, MRMSrcReg, (ops VR64:$dst, VR64:$src1, VR64:$src2),
  88                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  89                   [(set VR64:$dst, (v2i32 (OpNode VR64:$src1, VR64:$src2)))]> {
  90       let isCommutable = Commutable;
  91     }
  92     def rm : MMXI<opc, MRMSrcMem, (ops VR64:$dst, VR64:$src1, i64mem:$src2),
  93                   !strconcat(OpcodeStr, " {$src2, $dst|$dst, $src2}"),
  94                   [(set VR64:$dst,
  95                     (OpNode VR64:$src1,(loadv2i32 addr:$src2)))]>;
  96   }
  97 }
  98
  99 //===----------------------------------------------------------------------===//
 100 // MMX EMMS Instruction
 101 //===----------------------------------------------------------------------===//
 102
 103 def EMMS : MMXI<0x77, RawFrm, (ops), "emms", [(int_x86_mmx_emms)]>;
 104
 105 //===----------------------------------------------------------------------===//
 106 // MMX Scalar Instructions
 107 //===----------------------------------------------------------------------===//
 108
 109 // Arithmetic Instructions
 110 defm MMX_PADDB : MMXI_binop_rm<0xFC, "paddb", add, v8i8, 1>;
 111 defm MMX_PADDW : MMXI_binop_rm<0xFD, "paddw", add, v4i16, 1>;
 112 defm MMX_PADDD : MMXI_binop_rm<0xFE, "paddd", add, v2i32, 1>;
 113
 114 defm MMX_PADDSB  : MMXI_binop_rm_int<0xEC, "paddsb" , int_x86_mmx_padds_b, 1>;
 115 defm MMX_PADDSW  : MMXI_binop_rm_int<0xED, "paddsw" , int_x86_mmx_padds_w, 1>;
 116
 117 defm MMX_PADDUSB : MMXI_binop_rm_int<0xDC, "paddusb", int_x86_mmx_paddus_b, 1>;
 118 defm MMX_PADDUSW : MMXI_binop_rm_int<0xDD, "paddusw", int_x86_mmx_paddus_w, 1>;
 119
 120 defm MMX_PSUBB : MMXI_binop_rm<0xF8, "psubb", sub, v8i8>;
 121 defm MMX_PSUBW : MMXI_binop_rm<0xF9, "psubw", sub, v4i16>;
 122 defm MMX_PSUBD : MMXI_binop_rm<0xFA, "psubd", sub, v2i32>;
 123
 124 defm MMX_PSUBSB  : MMXI_binop_rm_int<0xE8, "psubsb" , int_x86_mmx_psubs_b>;
 125 defm MMX_PSUBSW  : MMXI_binop_rm_int<0xE9, "psubsw" , int_x86_mmx_psubs_w>;
 126
 127 defm MMX_PSUBUSB : MMXI_binop_rm_int<0xD8, "psubusb", int_x86_mmx_psubus_b>;
 128 defm MMX_PSUBUSW : MMXI_binop_rm_int<0xD9, "psubusw", int_x86_mmx_psubus_w>;
 129
 130 defm MMX_PMULLW  : MMXI_binop_rm<0xD5, "pmullw", mul, v4i16, 1>;
 131
 132 defm MMX_PMULHW  : MMXI_binop_rm_int<0xE5, "pmulhw" , int_x86_mmx_pmulh_w , 1>;
 133 defm MMX_PMADDWD : MMXI_binop_rm_int<0xF5, "pmaddwd", int_x86_mmx_pmadd_wd, 1>;
 134
 135 // Logical Instructions
 136 defm MMX_PAND : MMXI_binop_rm_v2i32<0xDB, "pand", and, 1>;
 137 defm MMX_POR  : MMXI_binop_rm_v2i32<0xEB, "por" , or,  1>;
 138 defm MMX_PXOR : MMXI_binop_rm_v2i32<0xEF, "pxor", xor, 1>;
 139
 140 let isTwoAddress = 1 in {
 141   def MMX_PANDNrr : MMXI<0xDF, MRMSrcReg,
 142                          (ops VR64:$dst, VR64:$src1, VR64:$src2),
 143                          "pandn {$src2, $dst|$dst, $src2}",
 144                          [(set VR64:$dst, (v2i32 (and (vnot VR64:$src1),
 145                                                   VR64:$src2)))]>;
 146   def MMX_PANDNrm : MMXI<0xDF, MRMSrcMem,
 147                          (ops VR64:$dst, VR64:$src1, i64mem:$src2),
 148                          "pandn {$src2, $dst|$dst, $src2}",
 149                          [(set VR64:$dst, (v2i32 (and (vnot VR64:$src1),
 150                                                   (load addr:$src2))))]>;
 151 }
 152
 153 // Move Instructions
 154 def MOVD64rr : MMXI<0x6E, MRMSrcReg, (ops VR64:$dst, GR32:$src),
 155                     "movd {$src, $dst|$dst, $src}", []>;
 156 def MOVD64rm : MMXI<0x6E, MRMSrcMem, (ops VR64:$dst, i32mem:$src),
 157                     "movd {$src, $dst|$dst, $src}", []>;
 158 def MOVD64mr : MMXI<0x7E, MRMDestMem, (ops i32mem:$dst, VR64:$src),
 159                     "movd {$src, $dst|$dst, $src}", []>;
 160
 161 def MOVQ64rr : MMXI<0x6F, MRMSrcReg, (ops VR64:$dst, VR64:$src),
 162                     "movq {$src, $dst|$dst, $src}", []>;
 163 def MOVQ64rm : MMXI<0x6F, MRMSrcMem, (ops VR64:$dst, i64mem:$src),
 164                     "movq {$src, $dst|$dst, $src}",
 165                     [(set VR64:$dst, (loadv2i32 addr:$src))]>;
 166 def MOVQ64mr : MMXI<0x7F, MRMDestMem, (ops i64mem:$dst, VR64:$src),
 167                     "movq {$src, $dst|$dst, $src}",
 168                     [(store (v2i32 VR64:$src), addr:$dst)]>;
 169
 170 // Conversion instructions
 171 def CVTPI2PSrr : MMXI<0x2A, MRMSrcReg, (ops VR128:$dst, VR64:$src),
 172                       "cvtpi2ps {$src, $dst|$dst, $src}", []>;
 173 def CVTPI2PSrm : MMXI<0x2A, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
 174                       "cvtpi2ps {$src, $dst|$dst, $src}", []>;
 175 def CVTPI2PDrr : MMX2I<0x2A, MRMSrcReg, (ops VR128:$dst, VR64:$src),
 176                        "cvtpi2pd {$src, $dst|$dst, $src}", []>;
 177 def CVTPI2PDrm : MMX2I<0x2A, MRMSrcMem, (ops VR128:$dst, i64mem:$src),
 178                        "cvtpi2pd {$src, $dst|$dst, $src}", []>;
 179 def CVTTPS2PIrr: I<0x2C, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 180                    "cvttps2pi {$src, $dst|$dst, $src}", []>, TB,
 181                    Requires<[HasMMX]>;
 182 def CVTTPS2PIrm: I<0x2C, MRMSrcMem, (ops VR64:$dst, f64mem:$src),
 183                    "cvttps2pi {$src, $dst|$dst, $src}", []>, TB,
 184                  Requires<[HasMMX]>;
 185 def CVTPS2PIrr : MMXI<0x2D, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 186                       "cvtps2pi {$src, $dst|$dst, $src}", []>;
 187 def CVTPS2PIrm : MMXI<0x2D, MRMSrcMem, (ops VR64:$dst, f64mem:$src),
 188                       "cvtps2pi {$src, $dst|$dst, $src}", []>;
 189 def CVTPD2PIrr : MMX2I<0x2D, MRMSrcReg, (ops VR64:$dst, VR128:$src),
 190                        "cvtpd2pi {$src, $dst|$dst, $src}", []>;
 191 def CVTPD2PIrm : MMX2I<0x2D, MRMSrcMem, (ops VR64:$dst, f128mem:$src),
 192                        "cvtpd2pi {$src, $dst|$dst, $src}", []>;
 193
 194 // Shuffle and unpack instructions
 195 def PSHUFWri : MMXIi8<0x70, MRMSrcReg,
 196                       (ops VR64:$dst, VR64:$src1, i8imm:$src2),
 197                       "pshufw {$src2, $src1, $dst|$dst, $src1, $src2}", []>;
 198 def PSHUFWmi : MMXIi8<0x70, MRMSrcMem,
 199                       (ops VR64:$dst, i64mem:$src1, i8imm:$src2),
 200                       "pshufw {$src2, $src1, $dst|$dst, $src1, $src2}", []>;
 201
 202 // Misc.
 203 def MOVNTQ   : I<0xE7, MRMDestMem, (ops i64mem:$dst, VR64:$src),
 204                  "movntq {$src, $dst|$dst, $src}", []>, TB,
 205                Requires<[HasMMX]>;
 206
 207 def MASKMOVQ : I<0xF7, MRMDestMem, (ops VR64:$src, VR64:$mask),
 208                  "maskmovq {$mask, $src|$src, $mask}", []>, TB,
 209                Requires<[HasMMX]>;
 210
 211 //===----------------------------------------------------------------------===//
 212 // Non-Instruction Patterns
 213 //===----------------------------------------------------------------------===//
 214
 215 // Store 64-bit integer vector values.
 216 def : Pat<(store (v8i8  VR64:$src), addr:$dst),
 217           (MOVQ64mr addr:$dst, VR64:$src)>;
 218 def : Pat<(store (v4i16 VR64:$src), addr:$dst),
 219           (MOVQ64mr addr:$dst, VR64:$src)>;
 220
 221 // Bit convert.
 222 def : Pat<(v8i8  (bitconvert (v2i32 VR64:$src))), (v8i8  VR64:$src)>;
 223 def : Pat<(v8i8  (bitconvert (v4i16 VR64:$src))), (v8i8  VR64:$src)>;
 224 def : Pat<(v4i16 (bitconvert (v2i32 VR64:$src))), (v4i16 VR64:$src)>;
 225 def : Pat<(v4i16 (bitconvert (v8i8  VR64:$src))), (v4i16 VR64:$src)>;
 226 def : Pat<(v2i32 (bitconvert (v4i16 VR64:$src))), (v2i32 VR64:$src)>;
 227 def : Pat<(v2i32 (bitconvert (v8i8  VR64:$src))), (v2i32 VR64:$src)>;