lib/Target/X86/InstPrinter/X86InstComments.cpp

   1 //===-- X86InstComments.cpp - Generate verbose-asm comments for instrs ----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This defines functionality used to emit comments about X86 instructions to
  11 // an output stream for -fverbose-asm.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "X86InstComments.h"
  16 #include "MCTargetDesc/X86MCTargetDesc.h"
  17 #include "Utils/X86ShuffleDecode.h"
  18 #include "llvm/MC/MCInst.h"
  19 #include "llvm/CodeGen/MachineValueType.h"
  20 #include "llvm/Support/raw_ostream.h"
  21
  22 using namespace llvm;
  23
  24 static unsigned getVectorRegSize(unsigned RegNo) {
  25   if (X86::ZMM0 <= RegNo && RegNo <= X86::ZMM31)
  26     return 512;
  27   if (X86::YMM0 <= RegNo && RegNo <= X86::YMM31)
  28     return 256;
  29   if (X86::XMM0 <= RegNo && RegNo <= X86::XMM31)
  30     return 128;
  31   if (X86::MM0 <= RegNo && RegNo <= X86::MM7)
  32     return 64;
  33
  34   llvm_unreachable("Unknown vector reg!");
  35   return 0;
  36 }
  37
  38 static MVT getRegOperandVectorVT(const MCInst *MI, const MVT &ScalarVT,
  39                                  unsigned OperandIndex) {
  40   unsigned OpReg = MI->getOperand(OperandIndex).getReg();
  41   return MVT::getVectorVT(ScalarVT,
  42                           getVectorRegSize(OpReg)/ScalarVT.getSizeInBits());
  43 }
  44
  45 /// \brief Extracts the src/dst types for a given zero extension instruction.
  46 /// \note While the number of elements in DstVT type correct, the
  47 /// number in the SrcVT type is expanded to fill the src xmm register and the
  48 /// upper elements may not be included in the dst xmm/ymm register.
  49 static void getZeroExtensionTypes(const MCInst *MI, MVT &SrcVT, MVT &DstVT) {
  50   switch (MI->getOpcode()) {
  51   default:
  52     llvm_unreachable("Unknown zero extension instruction");
  53   // i8 zero extension
  54   case X86::PMOVZXBWrm:
  55   case X86::PMOVZXBWrr:
  56   case X86::VPMOVZXBWrm:
  57   case X86::VPMOVZXBWrr:
  58     SrcVT = MVT::v16i8;
  59     DstVT = MVT::v8i16;
  60     break;
  61   case X86::VPMOVZXBWYrm:
  62   case X86::VPMOVZXBWYrr:
  63     SrcVT = MVT::v16i8;
  64     DstVT = MVT::v16i16;
  65     break;
  66   case X86::PMOVZXBDrm:
  67   case X86::PMOVZXBDrr:
  68   case X86::VPMOVZXBDrm:
  69   case X86::VPMOVZXBDrr:
  70     SrcVT = MVT::v16i8;
  71     DstVT = MVT::v4i32;
  72     break;
  73   case X86::VPMOVZXBDYrm:
  74   case X86::VPMOVZXBDYrr:
  75     SrcVT = MVT::v16i8;
  76     DstVT = MVT::v8i32;
  77     break;
  78   case X86::PMOVZXBQrm:
  79   case X86::PMOVZXBQrr:
  80   case X86::VPMOVZXBQrm:
  81   case X86::VPMOVZXBQrr:
  82     SrcVT = MVT::v16i8;
  83     DstVT = MVT::v2i64;
  84     break;
  85   case X86::VPMOVZXBQYrm:
  86   case X86::VPMOVZXBQYrr:
  87     SrcVT = MVT::v16i8;
  88     DstVT = MVT::v4i64;
  89     break;
  90   // i16 zero extension
  91   case X86::PMOVZXWDrm:
  92   case X86::PMOVZXWDrr:
  93   case X86::VPMOVZXWDrm:
  94   case X86::VPMOVZXWDrr:
  95     SrcVT = MVT::v8i16;
  96     DstVT = MVT::v4i32;
  97     break;
  98   case X86::VPMOVZXWDYrm:
  99   case X86::VPMOVZXWDYrr:
 100     SrcVT = MVT::v8i16;
 101     DstVT = MVT::v8i32;
 102     break;
 103   case X86::PMOVZXWQrm:
 104   case X86::PMOVZXWQrr:
 105   case X86::VPMOVZXWQrm:
 106   case X86::VPMOVZXWQrr:
 107     SrcVT = MVT::v8i16;
 108     DstVT = MVT::v2i64;
 109     break;
 110   case X86::VPMOVZXWQYrm:
 111   case X86::VPMOVZXWQYrr:
 112     SrcVT = MVT::v8i16;
 113     DstVT = MVT::v4i64;
 114     break;
 115   // i32 zero extension
 116   case X86::PMOVZXDQrm:
 117   case X86::PMOVZXDQrr:
 118   case X86::VPMOVZXDQrm:
 119   case X86::VPMOVZXDQrr:
 120     SrcVT = MVT::v4i32;
 121     DstVT = MVT::v2i64;
 122     break;
 123   case X86::VPMOVZXDQYrm:
 124   case X86::VPMOVZXDQYrr:
 125     SrcVT = MVT::v4i32;
 126     DstVT = MVT::v4i64;
 127     break;
 128   }
 129 }
 130
 131 #define CASE_MASK_INS_COMMON(Inst, Suffix, src)  \
 132   case X86::V##Inst##Suffix##src:                \
 133   case X86::V##Inst##Suffix##src##k:             \
 134   case X86::V##Inst##Suffix##src##kz:
 135
 136 #define CASE_SSE_INS_COMMON(Inst, src)           \
 137   case X86::Inst##src:
 138
 139 #define CASE_AVX_INS_COMMON(Inst, Suffix, src)  \
 140   case X86::V##Inst##Suffix##src:
 141
 142 #define CASE_MOVDUP(Inst, src)                  \
 143   CASE_MASK_INS_COMMON(Inst, Z, r##src)         \
 144   CASE_MASK_INS_COMMON(Inst, Z256, r##src)      \
 145   CASE_MASK_INS_COMMON(Inst, Z128, r##src)      \
 146   CASE_AVX_INS_COMMON(Inst, , r##src)           \
 147   CASE_AVX_INS_COMMON(Inst, Y, r##src)          \
 148   CASE_SSE_INS_COMMON(Inst, r##src)             \
 149
 150 #define CASE_UNPCK(Inst, src)                   \
 151   CASE_MASK_INS_COMMON(Inst, Z, r##src)         \
 152   CASE_MASK_INS_COMMON(Inst, Z256, r##src)      \
 153   CASE_MASK_INS_COMMON(Inst, Z128, r##src)      \
 154   CASE_AVX_INS_COMMON(Inst, , r##src)           \
 155   CASE_AVX_INS_COMMON(Inst, Y, r##src)          \
 156   CASE_SSE_INS_COMMON(Inst, r##src)             \
 157
 158 #define CASE_SHUF(Inst, src)                    \
 159   CASE_MASK_INS_COMMON(Inst, Z, r##src##i)      \
 160   CASE_MASK_INS_COMMON(Inst, Z256, r##src##i)   \
 161   CASE_MASK_INS_COMMON(Inst, Z128, r##src##i)   \
 162   CASE_AVX_INS_COMMON(Inst, , r##src##i)        \
 163   CASE_AVX_INS_COMMON(Inst, Y, r##src##i)       \
 164   CASE_SSE_INS_COMMON(Inst, r##src##i)          \
 165
 166 #define CASE_VPERM(Inst, src)                   \
 167   CASE_MASK_INS_COMMON(Inst, Z, src##i)         \
 168   CASE_MASK_INS_COMMON(Inst, Z256, src##i)      \
 169   CASE_MASK_INS_COMMON(Inst, Z128, src##i)      \
 170   CASE_AVX_INS_COMMON(Inst, , src##i)           \
 171   CASE_AVX_INS_COMMON(Inst, Y, src##i)          \
 172
 173 #define CASE_VSHUF(Inst, src)                          \
 174   CASE_MASK_INS_COMMON(SHUFF##Inst, Z, r##src##i)      \
 175   CASE_MASK_INS_COMMON(SHUFI##Inst, Z, r##src##i)      \
 176   CASE_MASK_INS_COMMON(SHUFF##Inst, Z256, r##src##i)   \
 177   CASE_MASK_INS_COMMON(SHUFI##Inst, Z256, r##src##i)   \
 178
 179 /// \brief Extracts the types and if it has memory operand for a given
 180 /// (SHUFF32x4/SHUFF64x2/SHUFI32x4/SHUFI64x2) instruction.
 181 static void getVSHUF64x2FamilyInfo(const MCInst *MI, MVT &VT, bool &HasMemOp) {
 182   HasMemOp = false;
 183   switch (MI->getOpcode()) {
 184   default:
 185     llvm_unreachable("Unknown VSHUF64x2 family instructions.");
 186     break;
 187   CASE_VSHUF(64X2, m)
 188     HasMemOp = true;        // FALL THROUGH.
 189   CASE_VSHUF(64X2, r)
 190     VT = getRegOperandVectorVT(MI, MVT::i64, 0);
 191     break;
 192   CASE_VSHUF(32X4, m)
 193     HasMemOp = true;        // FALL THROUGH.
 194   CASE_VSHUF(32X4, r)
 195     VT = getRegOperandVectorVT(MI, MVT::i32, 0);
 196     break;
 197   }
 198 }
 199
 200 //===----------------------------------------------------------------------===//
 201 // Top Level Entrypoint
 202 //===----------------------------------------------------------------------===//
 203
 204 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints
 205 /// newline terminated strings to the specified string if desired.  This
 206 /// information is shown in disassembly dumps when verbose assembly is enabled.
 207 bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
 208                                   const char *(*getRegName)(unsigned)) {
 209   // If this is a shuffle operation, the switch should fill in this state.
 210   SmallVector<int, 8> ShuffleMask;
 211   const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
 212
 213   switch (MI->getOpcode()) {
 214   default:
 215     // Not an instruction for which we can decode comments.
 216     return false;
 217
 218   case X86::BLENDPDrri:
 219   case X86::VBLENDPDrri:
 220   case X86::VBLENDPDYrri:
 221     Src2Name = getRegName(MI->getOperand(2).getReg());
 222     // FALL THROUGH.
 223   case X86::BLENDPDrmi:
 224   case X86::VBLENDPDrmi:
 225   case X86::VBLENDPDYrmi:
 226     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 227       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::f64, 0),
 228                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 229                       ShuffleMask);
 230     Src1Name = getRegName(MI->getOperand(1).getReg());
 231     DestName = getRegName(MI->getOperand(0).getReg());
 232     break;
 233
 234   case X86::BLENDPSrri:
 235   case X86::VBLENDPSrri:
 236   case X86::VBLENDPSYrri:
 237     Src2Name = getRegName(MI->getOperand(2).getReg());
 238     // FALL THROUGH.
 239   case X86::BLENDPSrmi:
 240   case X86::VBLENDPSrmi:
 241   case X86::VBLENDPSYrmi:
 242     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 243       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::f32, 0),
 244                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 245                       ShuffleMask);
 246     Src1Name = getRegName(MI->getOperand(1).getReg());
 247     DestName = getRegName(MI->getOperand(0).getReg());
 248     break;
 249
 250   case X86::PBLENDWrri:
 251   case X86::VPBLENDWrri:
 252   case X86::VPBLENDWYrri:
 253     Src2Name = getRegName(MI->getOperand(2).getReg());
 254     // FALL THROUGH.
 255   case X86::PBLENDWrmi:
 256   case X86::VPBLENDWrmi:
 257   case X86::VPBLENDWYrmi:
 258     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 259       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::i16, 0),
 260                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 261                       ShuffleMask);
 262     Src1Name = getRegName(MI->getOperand(1).getReg());
 263     DestName = getRegName(MI->getOperand(0).getReg());
 264     break;
 265
 266   case X86::VPBLENDDrri:
 267   case X86::VPBLENDDYrri:
 268     Src2Name = getRegName(MI->getOperand(2).getReg());
 269     // FALL THROUGH.
 270   case X86::VPBLENDDrmi:
 271   case X86::VPBLENDDYrmi:
 272     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 273       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::i32, 0),
 274                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 275                       ShuffleMask);
 276     Src1Name = getRegName(MI->getOperand(1).getReg());
 277     DestName = getRegName(MI->getOperand(0).getReg());
 278     break;
 279
 280   case X86::INSERTPSrr:
 281   case X86::VINSERTPSrr:
 282     Src2Name = getRegName(MI->getOperand(2).getReg());
 283     // FALL THROUGH.
 284   case X86::INSERTPSrm:
 285   case X86::VINSERTPSrm:
 286     DestName = getRegName(MI->getOperand(0).getReg());
 287     Src1Name = getRegName(MI->getOperand(1).getReg());
 288     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 289       DecodeINSERTPSMask(MI->getOperand(MI->getNumOperands() - 1).getImm(),
 290                          ShuffleMask);
 291     break;
 292
 293   case X86::MOVLHPSrr:
 294   case X86::VMOVLHPSrr:
 295     Src2Name = getRegName(MI->getOperand(2).getReg());
 296     Src1Name = getRegName(MI->getOperand(1).getReg());
 297     DestName = getRegName(MI->getOperand(0).getReg());
 298     DecodeMOVLHPSMask(2, ShuffleMask);
 299     break;
 300
 301   case X86::MOVHLPSrr:
 302   case X86::VMOVHLPSrr:
 303     Src2Name = getRegName(MI->getOperand(2).getReg());
 304     Src1Name = getRegName(MI->getOperand(1).getReg());
 305     DestName = getRegName(MI->getOperand(0).getReg());
 306     DecodeMOVHLPSMask(2, ShuffleMask);
 307     break;
 308
 309   CASE_MOVDUP(MOVSLDUP, r)
 310     Src1Name = getRegName(MI->getOperand(MI->getNumOperands() - 1).getReg());
 311     // FALL THROUGH.
 312   CASE_MOVDUP(MOVSLDUP, m) {
 313     MVT VT = getRegOperandVectorVT(MI, MVT::f32, 0);
 314     DestName = getRegName(MI->getOperand(0).getReg());
 315     DecodeMOVSLDUPMask(VT, ShuffleMask);
 316     break;
 317   }
 318
 319   CASE_MOVDUP(MOVSHDUP, r)
 320     Src1Name = getRegName(MI->getOperand(MI->getNumOperands() - 1).getReg());
 321     // FALL THROUGH.
 322   CASE_MOVDUP(MOVSHDUP, m) {
 323     MVT VT = getRegOperandVectorVT(MI, MVT::f32, 0);
 324     DestName = getRegName(MI->getOperand(0).getReg());
 325     DecodeMOVSHDUPMask(VT, ShuffleMask);
 326     break;
 327   }
 328
 329   case X86::VMOVDDUPYrr:
 330     Src1Name = getRegName(MI->getOperand(1).getReg());
 331     // FALL THROUGH.
 332   case X86::VMOVDDUPYrm:
 333     DestName = getRegName(MI->getOperand(0).getReg());
 334     DecodeMOVDDUPMask(MVT::v4f64, ShuffleMask);
 335     break;
 336
 337   case X86::MOVDDUPrr:
 338   case X86::VMOVDDUPrr:
 339     Src1Name = getRegName(MI->getOperand(1).getReg());
 340     // FALL THROUGH.
 341   case X86::MOVDDUPrm:
 342   case X86::VMOVDDUPrm:
 343     DestName = getRegName(MI->getOperand(0).getReg());
 344     DecodeMOVDDUPMask(MVT::v2f64, ShuffleMask);
 345     break;
 346
 347   case X86::PSLLDQri:
 348   case X86::VPSLLDQri:
 349   case X86::VPSLLDQYri:
 350     Src1Name = getRegName(MI->getOperand(1).getReg());
 351     DestName = getRegName(MI->getOperand(0).getReg());
 352     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 353       DecodePSLLDQMask(getRegOperandVectorVT(MI, MVT::i8, 0),
 354                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 355                        ShuffleMask);
 356     break;
 357
 358   case X86::PSRLDQri:
 359   case X86::VPSRLDQri:
 360   case X86::VPSRLDQYri:
 361     Src1Name = getRegName(MI->getOperand(1).getReg());
 362     DestName = getRegName(MI->getOperand(0).getReg());
 363     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 364       DecodePSRLDQMask(getRegOperandVectorVT(MI, MVT::i8, 0),
 365                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 366                        ShuffleMask);
 367     break;
 368
 369   case X86::PALIGNR128rr:
 370   case X86::VPALIGNR128rr:
 371   case X86::VPALIGNR256rr:
 372     Src1Name = getRegName(MI->getOperand(2).getReg());
 373     // FALL THROUGH.
 374   case X86::PALIGNR128rm:
 375   case X86::VPALIGNR128rm:
 376   case X86::VPALIGNR256rm:
 377     Src2Name = getRegName(MI->getOperand(1).getReg());
 378     DestName = getRegName(MI->getOperand(0).getReg());
 379     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 380       DecodePALIGNRMask(getRegOperandVectorVT(MI, MVT::i8, 0),
 381                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 382                         ShuffleMask);
 383     break;
 384
 385   case X86::PSHUFDri:
 386   case X86::VPSHUFDri:
 387   case X86::VPSHUFDYri:
 388     Src1Name = getRegName(MI->getOperand(1).getReg());
 389     // FALL THROUGH.
 390   case X86::PSHUFDmi:
 391   case X86::VPSHUFDmi:
 392   case X86::VPSHUFDYmi:
 393     DestName = getRegName(MI->getOperand(0).getReg());
 394     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 395       DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::i32, 0),
 396                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 397                       ShuffleMask);
 398     break;
 399
 400   case X86::PSHUFHWri:
 401   case X86::VPSHUFHWri:
 402   case X86::VPSHUFHWYri:
 403     Src1Name = getRegName(MI->getOperand(1).getReg());
 404     // FALL THROUGH.
 405   case X86::PSHUFHWmi:
 406   case X86::VPSHUFHWmi:
 407   case X86::VPSHUFHWYmi:
 408     DestName = getRegName(MI->getOperand(0).getReg());
 409     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 410       DecodePSHUFHWMask(getRegOperandVectorVT(MI, MVT::i16, 0),
 411                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 412                         ShuffleMask);
 413     break;
 414
 415   case X86::PSHUFLWri:
 416   case X86::VPSHUFLWri:
 417   case X86::VPSHUFLWYri:
 418     Src1Name = getRegName(MI->getOperand(1).getReg());
 419     // FALL THROUGH.
 420   case X86::PSHUFLWmi:
 421   case X86::VPSHUFLWmi:
 422   case X86::VPSHUFLWYmi:
 423     DestName = getRegName(MI->getOperand(0).getReg());
 424     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 425       DecodePSHUFLWMask(getRegOperandVectorVT(MI, MVT::i16, 0),
 426                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 427                         ShuffleMask);
 428     break;
 429
 430   case X86::MMX_PSHUFWri:
 431     Src1Name = getRegName(MI->getOperand(1).getReg());
 432     // FALL THROUGH.
 433   case X86::MMX_PSHUFWmi:
 434     DestName = getRegName(MI->getOperand(0).getReg());
 435     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 436       DecodePSHUFMask(MVT::v4i16,
 437                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 438                       ShuffleMask);
 439     break;
 440
 441   case X86::PSWAPDrr:
 442     Src1Name = getRegName(MI->getOperand(1).getReg());
 443     // FALL THROUGH.
 444   case X86::PSWAPDrm:
 445     DestName = getRegName(MI->getOperand(0).getReg());
 446     DecodePSWAPMask(MVT::v2i32, ShuffleMask);
 447     break;
 448
 449   CASE_UNPCK(PUNPCKHBW, r)
 450   case X86::MMX_PUNPCKHBWirr:
 451     Src2Name = getRegName(MI->getOperand(2).getReg());
 452     // FALL THROUGH.
 453   CASE_UNPCK(PUNPCKHBW, m)
 454   case X86::MMX_PUNPCKHBWirm:
 455     Src1Name = getRegName(MI->getOperand(1).getReg());
 456     DestName = getRegName(MI->getOperand(0).getReg());
 457     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i8, 0), ShuffleMask);
 458     break;
 459
 460   CASE_UNPCK(PUNPCKHWD, r)
 461   case X86::MMX_PUNPCKHWDirr:
 462     Src2Name = getRegName(MI->getOperand(2).getReg());
 463     // FALL THROUGH.
 464   CASE_UNPCK(PUNPCKHWD, m)
 465   case X86::MMX_PUNPCKHWDirm:
 466     Src1Name = getRegName(MI->getOperand(1).getReg());
 467     DestName = getRegName(MI->getOperand(0).getReg());
 468     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i16, 0), ShuffleMask);
 469     break;
 470
 471   CASE_UNPCK(PUNPCKHDQ, r)
 472   case X86::MMX_PUNPCKHDQirr:
 473     Src2Name = getRegName(MI->getOperand(2).getReg());
 474     // FALL THROUGH.
 475   CASE_UNPCK(PUNPCKHDQ, m)
 476   case X86::MMX_PUNPCKHDQirm:
 477     Src1Name = getRegName(MI->getOperand(1).getReg());
 478     DestName = getRegName(MI->getOperand(0).getReg());
 479     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i32, 0), ShuffleMask);
 480     break;
 481
 482   CASE_UNPCK(PUNPCKHQDQ, r)
 483     Src2Name = getRegName(MI->getOperand(2).getReg());
 484     // FALL THROUGH.
 485   CASE_UNPCK(PUNPCKHQDQ, m)
 486     Src1Name = getRegName(MI->getOperand(1).getReg());
 487     DestName = getRegName(MI->getOperand(0).getReg());
 488     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i64, 0), ShuffleMask);
 489     break;
 490
 491   CASE_UNPCK(PUNPCKLBW, r)
 492   case X86::MMX_PUNPCKLBWirr:
 493     Src2Name = getRegName(MI->getOperand(2).getReg());
 494     // FALL THROUGH.
 495   CASE_UNPCK(PUNPCKLBW, m)
 496   case X86::MMX_PUNPCKLBWirm:
 497     Src1Name = getRegName(MI->getOperand(1).getReg());
 498     DestName = getRegName(MI->getOperand(0).getReg());
 499     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i8, 0), ShuffleMask);
 500     break;
 501
 502   CASE_UNPCK(PUNPCKLWD, r)
 503   case X86::MMX_PUNPCKLWDirr:
 504     Src2Name = getRegName(MI->getOperand(2).getReg());
 505     // FALL THROUGH.
 506   CASE_UNPCK(PUNPCKLWD, m)
 507   case X86::MMX_PUNPCKLWDirm:
 508     Src1Name = getRegName(MI->getOperand(1).getReg());
 509     DestName = getRegName(MI->getOperand(0).getReg());
 510     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i16, 0), ShuffleMask);
 511     break;
 512
 513   CASE_UNPCK(PUNPCKLDQ, r)
 514   case X86::MMX_PUNPCKLDQirr:
 515     Src2Name = getRegName(MI->getOperand(2).getReg());
 516     // FALL THROUGH.
 517   CASE_UNPCK(PUNPCKLDQ, m)
 518   case X86::MMX_PUNPCKLDQirm:
 519     Src1Name = getRegName(MI->getOperand(1).getReg());
 520     DestName = getRegName(MI->getOperand(0).getReg());
 521     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i32, 0), ShuffleMask);
 522     break;
 523
 524   CASE_UNPCK(PUNPCKLQDQ, r)
 525     Src2Name = getRegName(MI->getOperand(2).getReg());
 526     // FALL THROUGH.
 527   CASE_UNPCK(PUNPCKLQDQ, m)
 528     Src1Name = getRegName(MI->getOperand(1).getReg());
 529     DestName = getRegName(MI->getOperand(0).getReg());
 530     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i64, 0), ShuffleMask);
 531     break;
 532
 533   CASE_SHUF(SHUFPD, r)
 534     Src2Name = getRegName(MI->getOperand(2).getReg());
 535     // FALL THROUGH.
 536   CASE_SHUF(SHUFPD, m)
 537     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 538       DecodeSHUFPMask(getRegOperandVectorVT(MI, MVT::f64, 0),
 539                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 540                       ShuffleMask);
 541     Src1Name = getRegName(MI->getOperand(1).getReg());
 542     DestName = getRegName(MI->getOperand(0).getReg());
 543     break;
 544
 545   CASE_SHUF(SHUFPS, r)
 546     Src2Name = getRegName(MI->getOperand(2).getReg());
 547     // FALL THROUGH.
 548   CASE_SHUF(SHUFPS, m)
 549     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 550       DecodeSHUFPMask(getRegOperandVectorVT(MI, MVT::f32, 0),
 551                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 552                       ShuffleMask);
 553     Src1Name = getRegName(MI->getOperand(1).getReg());
 554     DestName = getRegName(MI->getOperand(0).getReg());
 555     break;
 556
 557   CASE_VSHUF(64X2, r)
 558   CASE_VSHUF(64X2, m)
 559   CASE_VSHUF(32X4, r)
 560   CASE_VSHUF(32X4, m) {
 561     MVT VT;
 562     bool HasMemOp;
 563     unsigned NumOp = MI->getNumOperands();
 564     getVSHUF64x2FamilyInfo(MI, VT, HasMemOp);
 565     decodeVSHUF64x2FamilyMask(VT, MI->getOperand(NumOp - 1).getImm(),
 566                               ShuffleMask);
 567     DestName = getRegName(MI->getOperand(0).getReg());
 568     if (HasMemOp) {
 569       assert((NumOp >= 8) && "Expected at least 8 operands!");
 570       Src1Name = getRegName(MI->getOperand(NumOp - 7).getReg());
 571     } else {
 572       assert((NumOp >= 4) && "Expected at least 4 operands!");
 573       Src2Name = getRegName(MI->getOperand(NumOp - 2).getReg());
 574       Src1Name = getRegName(MI->getOperand(NumOp - 3).getReg());
 575     }
 576     break;
 577   }
 578
 579   CASE_UNPCK(UNPCKLPD, r)
 580     Src2Name = getRegName(MI->getOperand(2).getReg());
 581     // FALL THROUGH.
 582   CASE_UNPCK(UNPCKLPD, m)
 583     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::f64, 0), ShuffleMask);
 584     Src1Name = getRegName(MI->getOperand(1).getReg());
 585     DestName = getRegName(MI->getOperand(0).getReg());
 586     break;
 587
 588   CASE_UNPCK(UNPCKLPS, r)
 589     Src2Name = getRegName(MI->getOperand(2).getReg());
 590     // FALL THROUGH.
 591   CASE_UNPCK(UNPCKLPS, m)
 592     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
 593     Src1Name = getRegName(MI->getOperand(1).getReg());
 594     DestName = getRegName(MI->getOperand(0).getReg());
 595     break;
 596
 597   CASE_UNPCK(UNPCKHPD, r)
 598     Src2Name = getRegName(MI->getOperand(2).getReg());
 599     // FALL THROUGH.
 600   CASE_UNPCK(UNPCKHPD, m)
 601     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::f64, 0), ShuffleMask);
 602     Src1Name = getRegName(MI->getOperand(1).getReg());
 603     DestName = getRegName(MI->getOperand(0).getReg());
 604     break;
 605
 606   CASE_UNPCK(UNPCKHPS, r)
 607     Src2Name = getRegName(MI->getOperand(2).getReg());
 608     // FALL THROUGH.
 609   CASE_UNPCK(UNPCKHPS, m)
 610     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
 611     Src1Name = getRegName(MI->getOperand(1).getReg());
 612     DestName = getRegName(MI->getOperand(0).getReg());
 613     break;
 614
 615   CASE_VPERM(PERMILPS, r)
 616     Src1Name = getRegName(MI->getOperand(1).getReg());
 617     // FALL THROUGH.
 618   CASE_VPERM(PERMILPS, m)
 619     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 620       DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::f32, 0),
 621                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 622                       ShuffleMask);
 623     DestName = getRegName(MI->getOperand(0).getReg());
 624     break;
 625
 626   CASE_VPERM(PERMILPD, r)
 627     Src1Name = getRegName(MI->getOperand(1).getReg());
 628     // FALL THROUGH.
 629   CASE_VPERM(PERMILPD, m)
 630     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 631       DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::f64, 0),
 632                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 633                       ShuffleMask);
 634     DestName = getRegName(MI->getOperand(0).getReg());
 635     break;
 636
 637   case X86::VPERM2F128rr:
 638   case X86::VPERM2I128rr:
 639     Src2Name = getRegName(MI->getOperand(2).getReg());
 640     // FALL THROUGH.
 641   case X86::VPERM2F128rm:
 642   case X86::VPERM2I128rm:
 643     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 644     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 645       DecodeVPERM2X128Mask(MVT::v4i64,
 646                            MI->getOperand(MI->getNumOperands() - 1).getImm(),
 647                            ShuffleMask);
 648     Src1Name = getRegName(MI->getOperand(1).getReg());
 649     DestName = getRegName(MI->getOperand(0).getReg());
 650     break;
 651
 652   case X86::VPERMQYri:
 653   case X86::VPERMPDYri:
 654     Src1Name = getRegName(MI->getOperand(1).getReg());
 655     // FALL THROUGH.
 656   case X86::VPERMQYmi:
 657   case X86::VPERMPDYmi:
 658     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 659       DecodeVPERMMask(MI->getOperand(MI->getNumOperands() - 1).getImm(),
 660                       ShuffleMask);
 661     DestName = getRegName(MI->getOperand(0).getReg());
 662     break;
 663
 664   case X86::MOVSDrr:
 665   case X86::VMOVSDrr:
 666     Src2Name = getRegName(MI->getOperand(2).getReg());
 667     Src1Name = getRegName(MI->getOperand(1).getReg());
 668     // FALL THROUGH.
 669   case X86::MOVSDrm:
 670   case X86::VMOVSDrm:
 671     DecodeScalarMoveMask(MVT::v2f64, nullptr == Src2Name, ShuffleMask);
 672     DestName = getRegName(MI->getOperand(0).getReg());
 673     break;
 674   case X86::MOVSSrr:
 675   case X86::VMOVSSrr:
 676     Src2Name = getRegName(MI->getOperand(2).getReg());
 677     Src1Name = getRegName(MI->getOperand(1).getReg());
 678     // FALL THROUGH.
 679   case X86::MOVSSrm:
 680   case X86::VMOVSSrm:
 681     DecodeScalarMoveMask(MVT::v4f32, nullptr == Src2Name, ShuffleMask);
 682     DestName = getRegName(MI->getOperand(0).getReg());
 683     break;
 684
 685   case X86::MOVPQI2QIrr:
 686   case X86::MOVZPQILo2PQIrr:
 687   case X86::VMOVPQI2QIrr:
 688   case X86::VMOVZPQILo2PQIrr:
 689     Src1Name = getRegName(MI->getOperand(1).getReg());
 690   // FALL THROUGH.
 691   case X86::MOVQI2PQIrm:
 692   case X86::MOVZQI2PQIrm:
 693   case X86::MOVZPQILo2PQIrm:
 694   case X86::VMOVQI2PQIrm:
 695   case X86::VMOVZQI2PQIrm:
 696   case X86::VMOVZPQILo2PQIrm:
 697     DecodeZeroMoveLowMask(MVT::v2i64, ShuffleMask);
 698     DestName = getRegName(MI->getOperand(0).getReg());
 699     break;
 700
 701   case X86::MOVDI2PDIrm:
 702   case X86::VMOVDI2PDIrm:
 703     DecodeZeroMoveLowMask(MVT::v4i32, ShuffleMask);
 704     DestName = getRegName(MI->getOperand(0).getReg());
 705     break;
 706
 707   case X86::EXTRQI:
 708     if (MI->getOperand(2).isImm() &&
 709         MI->getOperand(3).isImm())
 710       DecodeEXTRQIMask(MI->getOperand(2).getImm(),
 711                        MI->getOperand(3).getImm(),
 712                        ShuffleMask);
 713
 714     DestName = getRegName(MI->getOperand(0).getReg());
 715     Src1Name = getRegName(MI->getOperand(1).getReg());
 716     break;
 717
 718   case X86::INSERTQI:
 719     if (MI->getOperand(3).isImm() &&
 720         MI->getOperand(4).isImm())
 721       DecodeINSERTQIMask(MI->getOperand(3).getImm(),
 722                          MI->getOperand(4).getImm(),
 723                          ShuffleMask);
 724
 725     DestName = getRegName(MI->getOperand(0).getReg());
 726     Src1Name = getRegName(MI->getOperand(1).getReg());
 727     Src2Name = getRegName(MI->getOperand(2).getReg());
 728     break;
 729
 730   case X86::PMOVZXBWrr:
 731   case X86::PMOVZXBDrr:
 732   case X86::PMOVZXBQrr:
 733   case X86::PMOVZXWDrr:
 734   case X86::PMOVZXWQrr:
 735   case X86::PMOVZXDQrr:
 736   case X86::VPMOVZXBWrr:
 737   case X86::VPMOVZXBDrr:
 738   case X86::VPMOVZXBQrr:
 739   case X86::VPMOVZXWDrr:
 740   case X86::VPMOVZXWQrr:
 741   case X86::VPMOVZXDQrr:
 742   case X86::VPMOVZXBWYrr:
 743   case X86::VPMOVZXBDYrr:
 744   case X86::VPMOVZXBQYrr:
 745   case X86::VPMOVZXWDYrr:
 746   case X86::VPMOVZXWQYrr:
 747   case X86::VPMOVZXDQYrr:
 748     Src1Name = getRegName(MI->getOperand(1).getReg());
 749   // FALL THROUGH.
 750   case X86::PMOVZXBWrm:
 751   case X86::PMOVZXBDrm:
 752   case X86::PMOVZXBQrm:
 753   case X86::PMOVZXWDrm:
 754   case X86::PMOVZXWQrm:
 755   case X86::PMOVZXDQrm:
 756   case X86::VPMOVZXBWrm:
 757   case X86::VPMOVZXBDrm:
 758   case X86::VPMOVZXBQrm:
 759   case X86::VPMOVZXWDrm:
 760   case X86::VPMOVZXWQrm:
 761   case X86::VPMOVZXDQrm:
 762   case X86::VPMOVZXBWYrm:
 763   case X86::VPMOVZXBDYrm:
 764   case X86::VPMOVZXBQYrm:
 765   case X86::VPMOVZXWDYrm:
 766   case X86::VPMOVZXWQYrm:
 767   case X86::VPMOVZXDQYrm: {
 768     MVT SrcVT, DstVT;
 769     getZeroExtensionTypes(MI, SrcVT, DstVT);
 770     DecodeZeroExtendMask(SrcVT, DstVT, ShuffleMask);
 771     DestName = getRegName(MI->getOperand(0).getReg());
 772   } break;
 773   }
 774
 775   // The only comments we decode are shuffles, so give up if we were unable to
 776   // decode a shuffle mask.
 777   if (ShuffleMask.empty())
 778     return false;
 779
 780   if (!DestName) DestName = Src1Name;
 781   OS << (DestName ? DestName : "mem") << " = ";
 782
 783   // If the two sources are the same, canonicalize the input elements to be
 784   // from the first src so that we get larger element spans.
 785   if (Src1Name == Src2Name) {
 786     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 787       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 788           ShuffleMask[i] >= (int)e)   // From second mask.
 789         ShuffleMask[i] -= e;
 790     }
 791   }
 792
 793   // The shuffle mask specifies which elements of the src1/src2 fill in the
 794   // destination, with a few sentinel values.  Loop through and print them
 795   // out.
 796   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 797     if (i != 0)
 798       OS << ',';
 799     if (ShuffleMask[i] == SM_SentinelZero) {
 800       OS << "zero";
 801       continue;
 802     }
 803
 804     // Otherwise, it must come from src1 or src2.  Print the span of elements
 805     // that comes from this src.
 806     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
 807     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 808     OS << (SrcName ? SrcName : "mem") << '[';
 809     bool IsFirst = true;
 810     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
 811            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
 812       if (!IsFirst)
 813         OS << ',';
 814       else
 815         IsFirst = false;
 816       if (ShuffleMask[i] == SM_SentinelUndef)
 817         OS << "u";
 818       else
 819         OS << ShuffleMask[i] % ShuffleMask.size();
 820       ++i;
 821     }
 822     OS << ']';
 823     --i; // For loop increments element #.
 824   }
 825   //MI->print(OS, 0);
 826   OS << "\n";
 827
 828   // We successfully added a comment to this instruction.
 829   return true;
 830 }