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
  26   if (X86::ZMM0 <= RegNo && RegNo <= X86::ZMM31)
  27     return 512;
  28   if (X86::YMM0 <= RegNo && RegNo <= X86::YMM31)
  29     return 256;
  30   if (X86::XMM0 <= RegNo && RegNo <= X86::XMM31)
  31     return 128;
  32
  33   llvm_unreachable("Unknown vector reg!");
  34   return 0;
  35 }
  36
  37 static MVT getRegOperandVectorVT(const MCInst *MI, const MVT &ScalarVT,
  38                                  unsigned OperandIndex) {
  39   unsigned OpReg = MI->getOperand(OperandIndex).getReg();
  40   return MVT::getVectorVT(ScalarVT,
  41                           getVectorRegSize(OpReg)/ScalarVT.getSizeInBits());
  42 }
  43
  44 /// \brief Extracts the src/dst types for a given zero extension instruction.
  45 /// \note While the number of elements in DstVT type correct, the
  46 /// number in the SrcVT type is expanded to fill the src xmm register and the
  47 /// upper elements may not be included in the dst xmm/ymm register.
  48 static void getZeroExtensionTypes(const MCInst *MI, MVT &SrcVT, MVT &DstVT) {
  49   switch (MI->getOpcode()) {
  50   default:
  51     llvm_unreachable("Unknown zero extension instruction");
  52   // i8 zero extension
  53   case X86::PMOVZXBWrm:
  54   case X86::PMOVZXBWrr:
  55   case X86::VPMOVZXBWrm:
  56   case X86::VPMOVZXBWrr:
  57     SrcVT = MVT::v16i8;
  58     DstVT = MVT::v8i16;
  59     break;
  60   case X86::VPMOVZXBWYrm:
  61   case X86::VPMOVZXBWYrr:
  62     SrcVT = MVT::v16i8;
  63     DstVT = MVT::v16i16;
  64     break;
  65   case X86::PMOVZXBDrm:
  66   case X86::PMOVZXBDrr:
  67   case X86::VPMOVZXBDrm:
  68   case X86::VPMOVZXBDrr:
  69     SrcVT = MVT::v16i8;
  70     DstVT = MVT::v4i32;
  71     break;
  72   case X86::VPMOVZXBDYrm:
  73   case X86::VPMOVZXBDYrr:
  74     SrcVT = MVT::v16i8;
  75     DstVT = MVT::v8i32;
  76     break;
  77   case X86::PMOVZXBQrm:
  78   case X86::PMOVZXBQrr:
  79   case X86::VPMOVZXBQrm:
  80   case X86::VPMOVZXBQrr:
  81     SrcVT = MVT::v16i8;
  82     DstVT = MVT::v2i64;
  83     break;
  84   case X86::VPMOVZXBQYrm:
  85   case X86::VPMOVZXBQYrr:
  86     SrcVT = MVT::v16i8;
  87     DstVT = MVT::v4i64;
  88     break;
  89   // i16 zero extension
  90   case X86::PMOVZXWDrm:
  91   case X86::PMOVZXWDrr:
  92   case X86::VPMOVZXWDrm:
  93   case X86::VPMOVZXWDrr:
  94     SrcVT = MVT::v8i16;
  95     DstVT = MVT::v4i32;
  96     break;
  97   case X86::VPMOVZXWDYrm:
  98   case X86::VPMOVZXWDYrr:
  99     SrcVT = MVT::v8i16;
 100     DstVT = MVT::v8i32;
 101     break;
 102   case X86::PMOVZXWQrm:
 103   case X86::PMOVZXWQrr:
 104   case X86::VPMOVZXWQrm:
 105   case X86::VPMOVZXWQrr:
 106     SrcVT = MVT::v8i16;
 107     DstVT = MVT::v2i64;
 108     break;
 109   case X86::VPMOVZXWQYrm:
 110   case X86::VPMOVZXWQYrr:
 111     SrcVT = MVT::v8i16;
 112     DstVT = MVT::v4i64;
 113     break;
 114   // i32 zero extension
 115   case X86::PMOVZXDQrm:
 116   case X86::PMOVZXDQrr:
 117   case X86::VPMOVZXDQrm:
 118   case X86::VPMOVZXDQrr:
 119     SrcVT = MVT::v4i32;
 120     DstVT = MVT::v2i64;
 121     break;
 122   case X86::VPMOVZXDQYrm:
 123   case X86::VPMOVZXDQYrr:
 124     SrcVT = MVT::v4i32;
 125     DstVT = MVT::v4i64;
 126     break;
 127   }
 128 }
 129
 130 #define CASE_MASK_INS_COMMON(Inst, Suffix, src)  \
 131   case X86::V##Inst##Suffix##src:                \
 132   case X86::V##Inst##Suffix##src##k:             \
 133   case X86::V##Inst##Suffix##src##kz:
 134
 135 #define CASE_SSE_INS_COMMON(Inst, src)           \
 136   case X86::Inst##src:
 137
 138 #define CASE_AVX_INS_COMMON(Inst, Suffix, src)  \
 139   case X86::V##Inst##Suffix##src:
 140
 141 #define CASE_MOVDUP(Inst, src)                  \
 142   CASE_MASK_INS_COMMON(Inst, Z, r##src)         \
 143   CASE_MASK_INS_COMMON(Inst, Z256, r##src)      \
 144   CASE_MASK_INS_COMMON(Inst, Z128, r##src)      \
 145   CASE_AVX_INS_COMMON(Inst, , r##src)           \
 146   CASE_AVX_INS_COMMON(Inst, Y, r##src)          \
 147   CASE_SSE_INS_COMMON(Inst, r##src)             \
 148
 149 #define CASE_VSHUF(Inst, src)                          \
 150   CASE_MASK_INS_COMMON(SHUFF##Inst, Z, r##src##i)      \
 151   CASE_MASK_INS_COMMON(SHUFI##Inst, Z, r##src##i)      \
 152   CASE_MASK_INS_COMMON(SHUFF##Inst, Z256, r##src##i)   \
 153   CASE_MASK_INS_COMMON(SHUFI##Inst, Z256, r##src##i)   \
 154
 155 /// \brief Extracts the types and if it has memory operand for a given
 156 /// (SHUFF32x4/SHUFF64x2/SHUFI32x4/SHUFI64x2) instruction.
 157 static void getVSHUF64x2FamilyInfo(const MCInst *MI, MVT &VT, bool &HasMemOp) {
 158   HasMemOp = false;
 159   switch (MI->getOpcode()) {
 160   default:
 161     llvm_unreachable("Unknown VSHUF64x2 family instructions.");
 162     break;
 163   CASE_VSHUF(64X2, m)
 164     HasMemOp = true;        // FALL THROUGH.
 165   CASE_VSHUF(64X2, r)
 166     VT = getRegOperandVectorVT(MI, MVT::i64, 0);
 167     break;
 168   CASE_VSHUF(32X4, m)
 169     HasMemOp = true;        // FALL THROUGH.
 170   CASE_VSHUF(32X4, r)
 171     VT = getRegOperandVectorVT(MI, MVT::i32, 0);
 172     break;
 173   }
 174 }
 175
 176 //===----------------------------------------------------------------------===//
 177 // Top Level Entrypoint
 178 //===----------------------------------------------------------------------===//
 179
 180 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints
 181 /// newline terminated strings to the specified string if desired.  This
 182 /// information is shown in disassembly dumps when verbose assembly is enabled.
 183 bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
 184                                   const char *(*getRegName)(unsigned)) {
 185   // If this is a shuffle operation, the switch should fill in this state.
 186   SmallVector<int, 8> ShuffleMask;
 187   const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
 188
 189   switch (MI->getOpcode()) {
 190   default:
 191     // Not an instruction for which we can decode comments.
 192     return false;
 193
 194   case X86::BLENDPDrri:
 195   case X86::VBLENDPDrri:
 196     Src2Name = getRegName(MI->getOperand(2).getReg());
 197     // FALL THROUGH.
 198   case X86::BLENDPDrmi:
 199   case X86::VBLENDPDrmi:
 200     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 201       DecodeBLENDMask(MVT::v2f64,
 202                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 203                       ShuffleMask);
 204     Src1Name = getRegName(MI->getOperand(1).getReg());
 205     DestName = getRegName(MI->getOperand(0).getReg());
 206     break;
 207   case X86::VBLENDPDYrri:
 208     Src2Name = getRegName(MI->getOperand(2).getReg());
 209     // FALL THROUGH.
 210   case X86::VBLENDPDYrmi:
 211     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 212       DecodeBLENDMask(MVT::v4f64,
 213                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 214                       ShuffleMask);
 215     Src1Name = getRegName(MI->getOperand(1).getReg());
 216     DestName = getRegName(MI->getOperand(0).getReg());
 217     break;
 218
 219   case X86::BLENDPSrri:
 220   case X86::VBLENDPSrri:
 221     Src2Name = getRegName(MI->getOperand(2).getReg());
 222     // FALL THROUGH.
 223   case X86::BLENDPSrmi:
 224   case X86::VBLENDPSrmi:
 225     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 226       DecodeBLENDMask(MVT::v4f32,
 227                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 228                       ShuffleMask);
 229     Src1Name = getRegName(MI->getOperand(1).getReg());
 230     DestName = getRegName(MI->getOperand(0).getReg());
 231     break;
 232   case X86::VBLENDPSYrri:
 233     Src2Name = getRegName(MI->getOperand(2).getReg());
 234     // FALL THROUGH.
 235   case X86::VBLENDPSYrmi:
 236     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 237       DecodeBLENDMask(MVT::v8f32,
 238                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 239                       ShuffleMask);
 240     Src1Name = getRegName(MI->getOperand(1).getReg());
 241     DestName = getRegName(MI->getOperand(0).getReg());
 242     break;
 243
 244   case X86::PBLENDWrri:
 245   case X86::VPBLENDWrri:
 246     Src2Name = getRegName(MI->getOperand(2).getReg());
 247     // FALL THROUGH.
 248   case X86::PBLENDWrmi:
 249   case X86::VPBLENDWrmi:
 250     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 251       DecodeBLENDMask(MVT::v8i16,
 252                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 253                       ShuffleMask);
 254     Src1Name = getRegName(MI->getOperand(1).getReg());
 255     DestName = getRegName(MI->getOperand(0).getReg());
 256     break;
 257   case X86::VPBLENDWYrri:
 258     Src2Name = getRegName(MI->getOperand(2).getReg());
 259     // FALL THROUGH.
 260   case X86::VPBLENDWYrmi:
 261     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 262       DecodeBLENDMask(MVT::v16i16,
 263                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 264                       ShuffleMask);
 265     Src1Name = getRegName(MI->getOperand(1).getReg());
 266     DestName = getRegName(MI->getOperand(0).getReg());
 267     break;
 268
 269   case X86::VPBLENDDrri:
 270     Src2Name = getRegName(MI->getOperand(2).getReg());
 271     // FALL THROUGH.
 272   case X86::VPBLENDDrmi:
 273     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 274       DecodeBLENDMask(MVT::v4i32,
 275                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 276                       ShuffleMask);
 277     Src1Name = getRegName(MI->getOperand(1).getReg());
 278     DestName = getRegName(MI->getOperand(0).getReg());
 279     break;
 280
 281   case X86::VPBLENDDYrri:
 282     Src2Name = getRegName(MI->getOperand(2).getReg());
 283     // FALL THROUGH.
 284   case X86::VPBLENDDYrmi:
 285     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 286       DecodeBLENDMask(MVT::v8i32,
 287                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 288                       ShuffleMask);
 289     Src1Name = getRegName(MI->getOperand(1).getReg());
 290     DestName = getRegName(MI->getOperand(0).getReg());
 291     break;
 292
 293   case X86::INSERTPSrr:
 294   case X86::VINSERTPSrr:
 295     Src2Name = getRegName(MI->getOperand(2).getReg());
 296     // FALL THROUGH.
 297   case X86::INSERTPSrm:
 298   case X86::VINSERTPSrm:
 299     DestName = getRegName(MI->getOperand(0).getReg());
 300     Src1Name = getRegName(MI->getOperand(1).getReg());
 301     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 302       DecodeINSERTPSMask(MI->getOperand(MI->getNumOperands() - 1).getImm(),
 303                          ShuffleMask);
 304     break;
 305
 306   case X86::MOVLHPSrr:
 307   case X86::VMOVLHPSrr:
 308     Src2Name = getRegName(MI->getOperand(2).getReg());
 309     Src1Name = getRegName(MI->getOperand(1).getReg());
 310     DestName = getRegName(MI->getOperand(0).getReg());
 311     DecodeMOVLHPSMask(2, ShuffleMask);
 312     break;
 313
 314   case X86::MOVHLPSrr:
 315   case X86::VMOVHLPSrr:
 316     Src2Name = getRegName(MI->getOperand(2).getReg());
 317     Src1Name = getRegName(MI->getOperand(1).getReg());
 318     DestName = getRegName(MI->getOperand(0).getReg());
 319     DecodeMOVHLPSMask(2, ShuffleMask);
 320     break;
 321   CASE_MOVDUP(MOVSLDUP, r)
 322     Src1Name = getRegName(MI->getOperand(MI->getNumOperands() - 1).getReg());
 323     // FALL THROUGH.
 324   CASE_MOVDUP(MOVSLDUP, m) {
 325     MVT VT = getRegOperandVectorVT(MI, MVT::f32, 0);
 326     DestName = getRegName(MI->getOperand(0).getReg());
 327     DecodeMOVSLDUPMask(VT, ShuffleMask);
 328     break;
 329   }
 330   CASE_MOVDUP(MOVSHDUP, r)
 331     Src1Name = getRegName(MI->getOperand(MI->getNumOperands() - 1).getReg());
 332     // FALL THROUGH.
 333   CASE_MOVDUP(MOVSHDUP, m) {
 334     MVT VT = getRegOperandVectorVT(MI, MVT::f32, 0);
 335     DestName = getRegName(MI->getOperand(0).getReg());
 336     DecodeMOVSHDUPMask(VT, ShuffleMask);
 337     break;
 338   }
 339   case X86::VMOVDDUPYrr:
 340     Src1Name = getRegName(MI->getOperand(1).getReg());
 341     // FALL THROUGH.
 342   case X86::VMOVDDUPYrm:
 343     DestName = getRegName(MI->getOperand(0).getReg());
 344     DecodeMOVDDUPMask(MVT::v4f64, ShuffleMask);
 345     break;
 346
 347   case X86::MOVDDUPrr:
 348   case X86::VMOVDDUPrr:
 349     Src1Name = getRegName(MI->getOperand(1).getReg());
 350     // FALL THROUGH.
 351   case X86::MOVDDUPrm:
 352   case X86::VMOVDDUPrm:
 353     DestName = getRegName(MI->getOperand(0).getReg());
 354     DecodeMOVDDUPMask(MVT::v2f64, ShuffleMask);
 355     break;
 356
 357   case X86::PSLLDQri:
 358   case X86::VPSLLDQri:
 359     Src1Name = getRegName(MI->getOperand(1).getReg());
 360     DestName = getRegName(MI->getOperand(0).getReg());
 361     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 362       DecodePSLLDQMask(MVT::v16i8,
 363                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 364                        ShuffleMask);
 365     break;
 366
 367   case X86::VPSLLDQYri:
 368     Src1Name = getRegName(MI->getOperand(1).getReg());
 369     DestName = getRegName(MI->getOperand(0).getReg());
 370     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 371       DecodePSLLDQMask(MVT::v32i8,
 372                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 373                        ShuffleMask);
 374     break;
 375
 376   case X86::PSRLDQri:
 377   case X86::VPSRLDQri:
 378     Src1Name = getRegName(MI->getOperand(1).getReg());
 379     DestName = getRegName(MI->getOperand(0).getReg());
 380     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 381       DecodePSRLDQMask(MVT::v16i8,
 382                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 383                        ShuffleMask);
 384     break;
 385
 386   case X86::VPSRLDQYri:
 387     Src1Name = getRegName(MI->getOperand(1).getReg());
 388     DestName = getRegName(MI->getOperand(0).getReg());
 389     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 390       DecodePSRLDQMask(MVT::v32i8,
 391                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 392                        ShuffleMask);
 393     break;
 394
 395   case X86::PALIGNR128rr:
 396   case X86::VPALIGNR128rr:
 397     Src1Name = getRegName(MI->getOperand(2).getReg());
 398     // FALL THROUGH.
 399   case X86::PALIGNR128rm:
 400   case X86::VPALIGNR128rm:
 401     Src2Name = getRegName(MI->getOperand(1).getReg());
 402     DestName = getRegName(MI->getOperand(0).getReg());
 403     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 404       DecodePALIGNRMask(MVT::v16i8,
 405                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 406                         ShuffleMask);
 407     break;
 408   case X86::VPALIGNR256rr:
 409     Src1Name = getRegName(MI->getOperand(2).getReg());
 410     // FALL THROUGH.
 411   case X86::VPALIGNR256rm:
 412     Src2Name = getRegName(MI->getOperand(1).getReg());
 413     DestName = getRegName(MI->getOperand(0).getReg());
 414     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 415       DecodePALIGNRMask(MVT::v32i8,
 416                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 417                         ShuffleMask);
 418     break;
 419
 420   case X86::PSHUFDri:
 421   case X86::VPSHUFDri:
 422     Src1Name = getRegName(MI->getOperand(1).getReg());
 423     // FALL THROUGH.
 424   case X86::PSHUFDmi:
 425   case X86::VPSHUFDmi:
 426     DestName = getRegName(MI->getOperand(0).getReg());
 427     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 428       DecodePSHUFMask(MVT::v4i32,
 429                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 430                       ShuffleMask);
 431     break;
 432   case X86::VPSHUFDYri:
 433     Src1Name = getRegName(MI->getOperand(1).getReg());
 434     // FALL THROUGH.
 435   case X86::VPSHUFDYmi:
 436     DestName = getRegName(MI->getOperand(0).getReg());
 437     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 438       DecodePSHUFMask(MVT::v8i32,
 439                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 440                       ShuffleMask);
 441     break;
 442
 443   case X86::PSHUFHWri:
 444   case X86::VPSHUFHWri:
 445     Src1Name = getRegName(MI->getOperand(1).getReg());
 446     // FALL THROUGH.
 447   case X86::PSHUFHWmi:
 448   case X86::VPSHUFHWmi:
 449     DestName = getRegName(MI->getOperand(0).getReg());
 450     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 451       DecodePSHUFHWMask(MVT::v8i16,
 452                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 453                         ShuffleMask);
 454     break;
 455   case X86::VPSHUFHWYri:
 456     Src1Name = getRegName(MI->getOperand(1).getReg());
 457     // FALL THROUGH.
 458   case X86::VPSHUFHWYmi:
 459     DestName = getRegName(MI->getOperand(0).getReg());
 460     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 461       DecodePSHUFHWMask(MVT::v16i16,
 462                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 463                         ShuffleMask);
 464     break;
 465   case X86::PSHUFLWri:
 466   case X86::VPSHUFLWri:
 467     Src1Name = getRegName(MI->getOperand(1).getReg());
 468     // FALL THROUGH.
 469   case X86::PSHUFLWmi:
 470   case X86::VPSHUFLWmi:
 471     DestName = getRegName(MI->getOperand(0).getReg());
 472     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 473       DecodePSHUFLWMask(MVT::v8i16,
 474                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 475                         ShuffleMask);
 476     break;
 477   case X86::VPSHUFLWYri:
 478     Src1Name = getRegName(MI->getOperand(1).getReg());
 479     // FALL THROUGH.
 480   case X86::VPSHUFLWYmi:
 481     DestName = getRegName(MI->getOperand(0).getReg());
 482     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 483       DecodePSHUFLWMask(MVT::v16i16,
 484                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 485                         ShuffleMask);
 486     break;
 487
 488   case X86::MMX_PSHUFWri:
 489     Src1Name = getRegName(MI->getOperand(1).getReg());
 490     // FALL THROUGH.
 491   case X86::MMX_PSHUFWmi:
 492     DestName = getRegName(MI->getOperand(0).getReg());
 493     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 494       DecodePSHUFMask(MVT::v4i16,
 495                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 496                       ShuffleMask);
 497     break;
 498
 499   case X86::PSWAPDrr:
 500     Src1Name = getRegName(MI->getOperand(1).getReg());
 501     // FALL THROUGH.
 502   case X86::PSWAPDrm:
 503     DestName = getRegName(MI->getOperand(0).getReg());
 504     DecodePSWAPMask(MVT::v2i32, ShuffleMask);
 505     break;
 506
 507   case X86::MMX_PUNPCKHBWirr:
 508     Src2Name = getRegName(MI->getOperand(2).getReg());
 509   case X86::MMX_PUNPCKHBWirm:
 510     Src1Name = getRegName(MI->getOperand(1).getReg());
 511     DestName = getRegName(MI->getOperand(0).getReg());
 512     DecodeUNPCKHMask(MVT::v8i8, ShuffleMask);
 513     break;
 514   case X86::MMX_PUNPCKHWDirr:
 515     Src2Name = getRegName(MI->getOperand(2).getReg());
 516   case X86::MMX_PUNPCKHWDirm:
 517     Src1Name = getRegName(MI->getOperand(1).getReg());
 518     DestName = getRegName(MI->getOperand(0).getReg());
 519     DecodeUNPCKHMask(MVT::v4i16, ShuffleMask);
 520     break;
 521   case X86::MMX_PUNPCKHDQirr:
 522     Src2Name = getRegName(MI->getOperand(2).getReg());
 523   case X86::MMX_PUNPCKHDQirm:
 524     Src1Name = getRegName(MI->getOperand(1).getReg());
 525     DestName = getRegName(MI->getOperand(0).getReg());
 526     DecodeUNPCKHMask(MVT::v2i32, ShuffleMask);
 527     break;
 528   case X86::PUNPCKHBWrr:
 529   case X86::VPUNPCKHBWrr:
 530     Src2Name = getRegName(MI->getOperand(2).getReg());
 531     // FALL THROUGH.
 532   case X86::PUNPCKHBWrm:
 533   case X86::VPUNPCKHBWrm:
 534     Src1Name = getRegName(MI->getOperand(1).getReg());
 535     DestName = getRegName(MI->getOperand(0).getReg());
 536     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
 537     break;
 538   case X86::VPUNPCKHBWYrr:
 539     Src2Name = getRegName(MI->getOperand(2).getReg());
 540     // FALL THROUGH.
 541   case X86::VPUNPCKHBWYrm:
 542     Src1Name = getRegName(MI->getOperand(1).getReg());
 543     DestName = getRegName(MI->getOperand(0).getReg());
 544     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
 545     break;
 546   case X86::PUNPCKHWDrr:
 547   case X86::VPUNPCKHWDrr:
 548     Src2Name = getRegName(MI->getOperand(2).getReg());
 549     // FALL THROUGH.
 550   case X86::PUNPCKHWDrm:
 551   case X86::VPUNPCKHWDrm:
 552     Src1Name = getRegName(MI->getOperand(1).getReg());
 553     DestName = getRegName(MI->getOperand(0).getReg());
 554     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
 555     break;
 556   case X86::VPUNPCKHWDYrr:
 557     Src2Name = getRegName(MI->getOperand(2).getReg());
 558     // FALL THROUGH.
 559   case X86::VPUNPCKHWDYrm:
 560     Src1Name = getRegName(MI->getOperand(1).getReg());
 561     DestName = getRegName(MI->getOperand(0).getReg());
 562     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
 563     break;
 564   case X86::PUNPCKHDQrr:
 565   case X86::VPUNPCKHDQrr:
 566     Src2Name = getRegName(MI->getOperand(2).getReg());
 567     // FALL THROUGH.
 568   case X86::PUNPCKHDQrm:
 569   case X86::VPUNPCKHDQrm:
 570     Src1Name = getRegName(MI->getOperand(1).getReg());
 571     DestName = getRegName(MI->getOperand(0).getReg());
 572     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
 573     break;
 574   case X86::VPUNPCKHDQYrr:
 575     Src2Name = getRegName(MI->getOperand(2).getReg());
 576     // FALL THROUGH.
 577   case X86::VPUNPCKHDQYrm:
 578     Src1Name = getRegName(MI->getOperand(1).getReg());
 579     DestName = getRegName(MI->getOperand(0).getReg());
 580     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
 581     break;
 582   case X86::VPUNPCKHDQZrr:
 583     Src2Name = getRegName(MI->getOperand(2).getReg());
 584     // FALL THROUGH.
 585   case X86::VPUNPCKHDQZrm:
 586     Src1Name = getRegName(MI->getOperand(1).getReg());
 587     DestName = getRegName(MI->getOperand(0).getReg());
 588     DecodeUNPCKHMask(MVT::v16i32, ShuffleMask);
 589     break;
 590   case X86::PUNPCKHQDQrr:
 591   case X86::VPUNPCKHQDQrr:
 592     Src2Name = getRegName(MI->getOperand(2).getReg());
 593     // FALL THROUGH.
 594   case X86::PUNPCKHQDQrm:
 595   case X86::VPUNPCKHQDQrm:
 596     Src1Name = getRegName(MI->getOperand(1).getReg());
 597     DestName = getRegName(MI->getOperand(0).getReg());
 598     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
 599     break;
 600   case X86::VPUNPCKHQDQYrr:
 601     Src2Name = getRegName(MI->getOperand(2).getReg());
 602     // FALL THROUGH.
 603   case X86::VPUNPCKHQDQYrm:
 604     Src1Name = getRegName(MI->getOperand(1).getReg());
 605     DestName = getRegName(MI->getOperand(0).getReg());
 606     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
 607     break;
 608   case X86::VPUNPCKHQDQZrr:
 609     Src2Name = getRegName(MI->getOperand(2).getReg());
 610     // FALL THROUGH.
 611   case X86::VPUNPCKHQDQZrm:
 612     Src1Name = getRegName(MI->getOperand(1).getReg());
 613     DestName = getRegName(MI->getOperand(0).getReg());
 614     DecodeUNPCKHMask(MVT::v8i64, ShuffleMask);
 615     break;
 616
 617   case X86::MMX_PUNPCKLBWirr:
 618     Src2Name = getRegName(MI->getOperand(2).getReg());
 619   case X86::MMX_PUNPCKLBWirm:
 620     Src1Name = getRegName(MI->getOperand(1).getReg());
 621     DestName = getRegName(MI->getOperand(0).getReg());
 622     DecodeUNPCKLMask(MVT::v8i8, ShuffleMask);
 623     break;
 624   case X86::MMX_PUNPCKLWDirr:
 625     Src2Name = getRegName(MI->getOperand(2).getReg());
 626   case X86::MMX_PUNPCKLWDirm:
 627     Src1Name = getRegName(MI->getOperand(1).getReg());
 628     DestName = getRegName(MI->getOperand(0).getReg());
 629     DecodeUNPCKLMask(MVT::v4i16, ShuffleMask);
 630     break;
 631   case X86::MMX_PUNPCKLDQirr:
 632     Src2Name = getRegName(MI->getOperand(2).getReg());
 633   case X86::MMX_PUNPCKLDQirm:
 634     Src1Name = getRegName(MI->getOperand(1).getReg());
 635     DestName = getRegName(MI->getOperand(0).getReg());
 636     DecodeUNPCKLMask(MVT::v2i32, ShuffleMask);
 637     break;
 638   case X86::PUNPCKLBWrr:
 639   case X86::VPUNPCKLBWrr:
 640     Src2Name = getRegName(MI->getOperand(2).getReg());
 641     // FALL THROUGH.
 642   case X86::PUNPCKLBWrm:
 643   case X86::VPUNPCKLBWrm:
 644     Src1Name = getRegName(MI->getOperand(1).getReg());
 645     DestName = getRegName(MI->getOperand(0).getReg());
 646     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
 647     break;
 648   case X86::VPUNPCKLBWYrr:
 649     Src2Name = getRegName(MI->getOperand(2).getReg());
 650     // FALL THROUGH.
 651   case X86::VPUNPCKLBWYrm:
 652     Src1Name = getRegName(MI->getOperand(1).getReg());
 653     DestName = getRegName(MI->getOperand(0).getReg());
 654     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
 655     break;
 656   case X86::PUNPCKLWDrr:
 657   case X86::VPUNPCKLWDrr:
 658     Src2Name = getRegName(MI->getOperand(2).getReg());
 659     // FALL THROUGH.
 660   case X86::PUNPCKLWDrm:
 661   case X86::VPUNPCKLWDrm:
 662     Src1Name = getRegName(MI->getOperand(1).getReg());
 663     DestName = getRegName(MI->getOperand(0).getReg());
 664     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
 665     break;
 666   case X86::VPUNPCKLWDYrr:
 667     Src2Name = getRegName(MI->getOperand(2).getReg());
 668     // FALL THROUGH.
 669   case X86::VPUNPCKLWDYrm:
 670     Src1Name = getRegName(MI->getOperand(1).getReg());
 671     DestName = getRegName(MI->getOperand(0).getReg());
 672     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
 673     break;
 674   case X86::PUNPCKLDQrr:
 675   case X86::VPUNPCKLDQrr:
 676     Src2Name = getRegName(MI->getOperand(2).getReg());
 677     // FALL THROUGH.
 678   case X86::PUNPCKLDQrm:
 679   case X86::VPUNPCKLDQrm:
 680     Src1Name = getRegName(MI->getOperand(1).getReg());
 681     DestName = getRegName(MI->getOperand(0).getReg());
 682     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
 683     break;
 684   case X86::VPUNPCKLDQYrr:
 685     Src2Name = getRegName(MI->getOperand(2).getReg());
 686     // FALL THROUGH.
 687   case X86::VPUNPCKLDQYrm:
 688     Src1Name = getRegName(MI->getOperand(1).getReg());
 689     DestName = getRegName(MI->getOperand(0).getReg());
 690     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
 691     break;
 692   case X86::VPUNPCKLDQZrr:
 693     Src2Name = getRegName(MI->getOperand(2).getReg());
 694     // FALL THROUGH.
 695   case X86::VPUNPCKLDQZrm:
 696     Src1Name = getRegName(MI->getOperand(1).getReg());
 697     DestName = getRegName(MI->getOperand(0).getReg());
 698     DecodeUNPCKLMask(MVT::v16i32, ShuffleMask);
 699     break;
 700   case X86::PUNPCKLQDQrr:
 701   case X86::VPUNPCKLQDQrr:
 702     Src2Name = getRegName(MI->getOperand(2).getReg());
 703     // FALL THROUGH.
 704   case X86::PUNPCKLQDQrm:
 705   case X86::VPUNPCKLQDQrm:
 706     Src1Name = getRegName(MI->getOperand(1).getReg());
 707     DestName = getRegName(MI->getOperand(0).getReg());
 708     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
 709     break;
 710   case X86::VPUNPCKLQDQYrr:
 711     Src2Name = getRegName(MI->getOperand(2).getReg());
 712     // FALL THROUGH.
 713   case X86::VPUNPCKLQDQYrm:
 714     Src1Name = getRegName(MI->getOperand(1).getReg());
 715     DestName = getRegName(MI->getOperand(0).getReg());
 716     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
 717     break;
 718   case X86::VPUNPCKLQDQZrr:
 719     Src2Name = getRegName(MI->getOperand(2).getReg());
 720     // FALL THROUGH.
 721   case X86::VPUNPCKLQDQZrm:
 722     Src1Name = getRegName(MI->getOperand(1).getReg());
 723     DestName = getRegName(MI->getOperand(0).getReg());
 724     DecodeUNPCKLMask(MVT::v8i64, ShuffleMask);
 725     break;
 726
 727   case X86::SHUFPDrri:
 728   case X86::VSHUFPDrri:
 729     Src2Name = getRegName(MI->getOperand(2).getReg());
 730     // FALL THROUGH.
 731   case X86::SHUFPDrmi:
 732   case X86::VSHUFPDrmi:
 733     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 734       DecodeSHUFPMask(MVT::v2f64,
 735                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 736                       ShuffleMask);
 737     Src1Name = getRegName(MI->getOperand(1).getReg());
 738     DestName = getRegName(MI->getOperand(0).getReg());
 739     break;
 740   case X86::VSHUFPDYrri:
 741     Src2Name = getRegName(MI->getOperand(2).getReg());
 742     // FALL THROUGH.
 743   case X86::VSHUFPDYrmi:
 744     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 745       DecodeSHUFPMask(MVT::v4f64,
 746                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 747                       ShuffleMask);
 748     Src1Name = getRegName(MI->getOperand(1).getReg());
 749     DestName = getRegName(MI->getOperand(0).getReg());
 750     break;
 751
 752   case X86::SHUFPSrri:
 753   case X86::VSHUFPSrri:
 754     Src2Name = getRegName(MI->getOperand(2).getReg());
 755     // FALL THROUGH.
 756   case X86::SHUFPSrmi:
 757   case X86::VSHUFPSrmi:
 758     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 759       DecodeSHUFPMask(MVT::v4f32,
 760                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 761                       ShuffleMask);
 762     Src1Name = getRegName(MI->getOperand(1).getReg());
 763     DestName = getRegName(MI->getOperand(0).getReg());
 764     break;
 765   case X86::VSHUFPSYrri:
 766     Src2Name = getRegName(MI->getOperand(2).getReg());
 767     // FALL THROUGH.
 768   case X86::VSHUFPSYrmi:
 769     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 770       DecodeSHUFPMask(MVT::v8f32,
 771                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 772                       ShuffleMask);
 773     Src1Name = getRegName(MI->getOperand(1).getReg());
 774     DestName = getRegName(MI->getOperand(0).getReg());
 775     break;
 776   CASE_VSHUF(64X2, r)
 777   CASE_VSHUF(64X2, m)
 778   CASE_VSHUF(32X4, r)
 779   CASE_VSHUF(32X4, m) {
 780     MVT VT;
 781     bool HasMemOp;
 782     unsigned NumOp = MI->getNumOperands();
 783     getVSHUF64x2FamilyInfo(MI, VT, HasMemOp);
 784     decodeVSHUF64x2FamilyMask(VT, MI->getOperand(NumOp - 1).getImm(),
 785                               ShuffleMask);
 786     DestName = getRegName(MI->getOperand(0).getReg());
 787     if (HasMemOp) {
 788       assert((NumOp >= 8) && "Expected at least 8 operands!");
 789       Src1Name = getRegName(MI->getOperand(NumOp - 7).getReg());
 790     } else {
 791       assert((NumOp >= 4) && "Expected at least 4 operands!");
 792       Src2Name = getRegName(MI->getOperand(NumOp - 2).getReg());
 793       Src1Name = getRegName(MI->getOperand(NumOp - 3).getReg());
 794     }
 795     break;
 796   }
 797   case X86::UNPCKLPDrr:
 798   case X86::VUNPCKLPDrr:
 799     Src2Name = getRegName(MI->getOperand(2).getReg());
 800     // FALL THROUGH.
 801   case X86::UNPCKLPDrm:
 802   case X86::VUNPCKLPDrm:
 803     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
 804     Src1Name = getRegName(MI->getOperand(1).getReg());
 805     DestName = getRegName(MI->getOperand(0).getReg());
 806     break;
 807   case X86::VUNPCKLPDYrr:
 808     Src2Name = getRegName(MI->getOperand(2).getReg());
 809     // FALL THROUGH.
 810   case X86::VUNPCKLPDYrm:
 811     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
 812     Src1Name = getRegName(MI->getOperand(1).getReg());
 813     DestName = getRegName(MI->getOperand(0).getReg());
 814     break;
 815   case X86::VUNPCKLPDZrr:
 816     Src2Name = getRegName(MI->getOperand(2).getReg());
 817     // FALL THROUGH.
 818   case X86::VUNPCKLPDZrm:
 819     DecodeUNPCKLMask(MVT::v8f64, ShuffleMask);
 820     Src1Name = getRegName(MI->getOperand(1).getReg());
 821     DestName = getRegName(MI->getOperand(0).getReg());
 822     break;
 823   case X86::UNPCKLPSrr:
 824   case X86::VUNPCKLPSrr:
 825     Src2Name = getRegName(MI->getOperand(2).getReg());
 826     // FALL THROUGH.
 827   case X86::UNPCKLPSrm:
 828   case X86::VUNPCKLPSrm:
 829     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
 830     Src1Name = getRegName(MI->getOperand(1).getReg());
 831     DestName = getRegName(MI->getOperand(0).getReg());
 832     break;
 833   case X86::VUNPCKLPSYrr:
 834     Src2Name = getRegName(MI->getOperand(2).getReg());
 835     // FALL THROUGH.
 836   case X86::VUNPCKLPSYrm:
 837     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
 838     Src1Name = getRegName(MI->getOperand(1).getReg());
 839     DestName = getRegName(MI->getOperand(0).getReg());
 840     break;
 841   case X86::VUNPCKLPSZrr:
 842     Src2Name = getRegName(MI->getOperand(2).getReg());
 843     // FALL THROUGH.
 844   case X86::VUNPCKLPSZrm:
 845     DecodeUNPCKLMask(MVT::v16f32, ShuffleMask);
 846     Src1Name = getRegName(MI->getOperand(1).getReg());
 847     DestName = getRegName(MI->getOperand(0).getReg());
 848     break;
 849   case X86::UNPCKHPDrr:
 850   case X86::VUNPCKHPDrr:
 851     Src2Name = getRegName(MI->getOperand(2).getReg());
 852     // FALL THROUGH.
 853   case X86::UNPCKHPDrm:
 854   case X86::VUNPCKHPDrm:
 855     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
 856     Src1Name = getRegName(MI->getOperand(1).getReg());
 857     DestName = getRegName(MI->getOperand(0).getReg());
 858     break;
 859   case X86::VUNPCKHPDYrr:
 860     Src2Name = getRegName(MI->getOperand(2).getReg());
 861     // FALL THROUGH.
 862   case X86::VUNPCKHPDYrm:
 863     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
 864     Src1Name = getRegName(MI->getOperand(1).getReg());
 865     DestName = getRegName(MI->getOperand(0).getReg());
 866     break;
 867   case X86::VUNPCKHPDZrr:
 868     Src2Name = getRegName(MI->getOperand(2).getReg());
 869     // FALL THROUGH.
 870   case X86::VUNPCKHPDZrm:
 871     DecodeUNPCKHMask(MVT::v8f64, ShuffleMask);
 872     Src1Name = getRegName(MI->getOperand(1).getReg());
 873     DestName = getRegName(MI->getOperand(0).getReg());
 874     break;
 875   case X86::UNPCKHPSrr:
 876   case X86::VUNPCKHPSrr:
 877     Src2Name = getRegName(MI->getOperand(2).getReg());
 878     // FALL THROUGH.
 879   case X86::UNPCKHPSrm:
 880   case X86::VUNPCKHPSrm:
 881     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
 882     Src1Name = getRegName(MI->getOperand(1).getReg());
 883     DestName = getRegName(MI->getOperand(0).getReg());
 884     break;
 885   case X86::VUNPCKHPSYrr:
 886     Src2Name = getRegName(MI->getOperand(2).getReg());
 887     // FALL THROUGH.
 888   case X86::VUNPCKHPSYrm:
 889     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
 890     Src1Name = getRegName(MI->getOperand(1).getReg());
 891     DestName = getRegName(MI->getOperand(0).getReg());
 892     break;
 893   case X86::VUNPCKHPSZrr:
 894     Src2Name = getRegName(MI->getOperand(2).getReg());
 895     // FALL THROUGH.
 896   case X86::VUNPCKHPSZrm:
 897     DecodeUNPCKHMask(MVT::v16f32, ShuffleMask);
 898     Src1Name = getRegName(MI->getOperand(1).getReg());
 899     DestName = getRegName(MI->getOperand(0).getReg());
 900     break;
 901   case X86::VPERMILPSri:
 902     Src1Name = getRegName(MI->getOperand(1).getReg());
 903     // FALL THROUGH.
 904   case X86::VPERMILPSmi:
 905     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 906       DecodePSHUFMask(MVT::v4f32,
 907                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 908                       ShuffleMask);
 909     DestName = getRegName(MI->getOperand(0).getReg());
 910     break;
 911   case X86::VPERMILPSYri:
 912     Src1Name = getRegName(MI->getOperand(1).getReg());
 913     // FALL THROUGH.
 914   case X86::VPERMILPSYmi:
 915     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 916       DecodePSHUFMask(MVT::v8f32,
 917                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 918                       ShuffleMask);
 919     DestName = getRegName(MI->getOperand(0).getReg());
 920     break;
 921   case X86::VPERMILPDri:
 922     Src1Name = getRegName(MI->getOperand(1).getReg());
 923     // FALL THROUGH.
 924   case X86::VPERMILPDmi:
 925     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 926       DecodePSHUFMask(MVT::v2f64,
 927                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 928                       ShuffleMask);
 929     DestName = getRegName(MI->getOperand(0).getReg());
 930     break;
 931   case X86::VPERMILPDYri:
 932     Src1Name = getRegName(MI->getOperand(1).getReg());
 933     // FALL THROUGH.
 934   case X86::VPERMILPDYmi:
 935     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 936       DecodePSHUFMask(MVT::v4f64,
 937                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 938                       ShuffleMask);
 939     DestName = getRegName(MI->getOperand(0).getReg());
 940     break;
 941   case X86::VPERM2F128rr:
 942   case X86::VPERM2I128rr:
 943     Src2Name = getRegName(MI->getOperand(2).getReg());
 944     // FALL THROUGH.
 945   case X86::VPERM2F128rm:
 946   case X86::VPERM2I128rm:
 947     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 948     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 949       DecodeVPERM2X128Mask(MVT::v4i64,
 950                            MI->getOperand(MI->getNumOperands() - 1).getImm(),
 951                            ShuffleMask);
 952     Src1Name = getRegName(MI->getOperand(1).getReg());
 953     DestName = getRegName(MI->getOperand(0).getReg());
 954     break;
 955   case X86::VPERMQYri:
 956   case X86::VPERMPDYri:
 957     Src1Name = getRegName(MI->getOperand(1).getReg());
 958     // FALL THROUGH.
 959   case X86::VPERMQYmi:
 960   case X86::VPERMPDYmi:
 961     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 962       DecodeVPERMMask(MI->getOperand(MI->getNumOperands() - 1).getImm(),
 963                       ShuffleMask);
 964     DestName = getRegName(MI->getOperand(0).getReg());
 965     break;
 966
 967   case X86::MOVSDrr:
 968   case X86::VMOVSDrr:
 969     Src2Name = getRegName(MI->getOperand(2).getReg());
 970     Src1Name = getRegName(MI->getOperand(1).getReg());
 971     // FALL THROUGH.
 972   case X86::MOVSDrm:
 973   case X86::VMOVSDrm:
 974     DecodeScalarMoveMask(MVT::v2f64, nullptr == Src2Name, ShuffleMask);
 975     DestName = getRegName(MI->getOperand(0).getReg());
 976     break;
 977   case X86::MOVSSrr:
 978   case X86::VMOVSSrr:
 979     Src2Name = getRegName(MI->getOperand(2).getReg());
 980     Src1Name = getRegName(MI->getOperand(1).getReg());
 981     // FALL THROUGH.
 982   case X86::MOVSSrm:
 983   case X86::VMOVSSrm:
 984     DecodeScalarMoveMask(MVT::v4f32, nullptr == Src2Name, ShuffleMask);
 985     DestName = getRegName(MI->getOperand(0).getReg());
 986     break;
 987
 988   case X86::MOVPQI2QIrr:
 989   case X86::MOVZPQILo2PQIrr:
 990   case X86::VMOVPQI2QIrr:
 991   case X86::VMOVZPQILo2PQIrr:
 992     Src1Name = getRegName(MI->getOperand(1).getReg());
 993   // FALL THROUGH.
 994   case X86::MOVQI2PQIrm:
 995   case X86::MOVZQI2PQIrm:
 996   case X86::MOVZPQILo2PQIrm:
 997   case X86::VMOVQI2PQIrm:
 998   case X86::VMOVZQI2PQIrm:
 999   case X86::VMOVZPQILo2PQIrm:
1000     DecodeZeroMoveLowMask(MVT::v2i64, ShuffleMask);
1001     DestName = getRegName(MI->getOperand(0).getReg());
1002     break;
1003   case X86::MOVDI2PDIrm:
1004   case X86::VMOVDI2PDIrm:
1005     DecodeZeroMoveLowMask(MVT::v4i32, ShuffleMask);
1006     DestName = getRegName(MI->getOperand(0).getReg());
1007     break;
1008
1009   case X86::EXTRQI:
1010     if (MI->getOperand(2).isImm() &&
1011         MI->getOperand(3).isImm())
1012       DecodeEXTRQIMask(MI->getOperand(2).getImm(),
1013                        MI->getOperand(3).getImm(),
1014                        ShuffleMask);
1015
1016     DestName = getRegName(MI->getOperand(0).getReg());
1017     Src1Name = getRegName(MI->getOperand(1).getReg());
1018     break;
1019
1020   case X86::INSERTQI:
1021     if (MI->getOperand(3).isImm() &&
1022         MI->getOperand(4).isImm())
1023       DecodeINSERTQIMask(MI->getOperand(3).getImm(),
1024                          MI->getOperand(4).getImm(),
1025                          ShuffleMask);
1026
1027     DestName = getRegName(MI->getOperand(0).getReg());
1028     Src1Name = getRegName(MI->getOperand(1).getReg());
1029     Src2Name = getRegName(MI->getOperand(2).getReg());
1030     break;
1031
1032   case X86::PMOVZXBWrr:
1033   case X86::PMOVZXBDrr:
1034   case X86::PMOVZXBQrr:
1035   case X86::PMOVZXWDrr:
1036   case X86::PMOVZXWQrr:
1037   case X86::PMOVZXDQrr:
1038   case X86::VPMOVZXBWrr:
1039   case X86::VPMOVZXBDrr:
1040   case X86::VPMOVZXBQrr:
1041   case X86::VPMOVZXWDrr:
1042   case X86::VPMOVZXWQrr:
1043   case X86::VPMOVZXDQrr:
1044   case X86::VPMOVZXBWYrr:
1045   case X86::VPMOVZXBDYrr:
1046   case X86::VPMOVZXBQYrr:
1047   case X86::VPMOVZXWDYrr:
1048   case X86::VPMOVZXWQYrr:
1049   case X86::VPMOVZXDQYrr:
1050     Src1Name = getRegName(MI->getOperand(1).getReg());
1051   // FALL THROUGH.
1052   case X86::PMOVZXBWrm:
1053   case X86::PMOVZXBDrm:
1054   case X86::PMOVZXBQrm:
1055   case X86::PMOVZXWDrm:
1056   case X86::PMOVZXWQrm:
1057   case X86::PMOVZXDQrm:
1058   case X86::VPMOVZXBWrm:
1059   case X86::VPMOVZXBDrm:
1060   case X86::VPMOVZXBQrm:
1061   case X86::VPMOVZXWDrm:
1062   case X86::VPMOVZXWQrm:
1063   case X86::VPMOVZXDQrm:
1064   case X86::VPMOVZXBWYrm:
1065   case X86::VPMOVZXBDYrm:
1066   case X86::VPMOVZXBQYrm:
1067   case X86::VPMOVZXWDYrm:
1068   case X86::VPMOVZXWQYrm:
1069   case X86::VPMOVZXDQYrm: {
1070     MVT SrcVT, DstVT;
1071     getZeroExtensionTypes(MI, SrcVT, DstVT);
1072     DecodeZeroExtendMask(SrcVT, DstVT, ShuffleMask);
1073     DestName = getRegName(MI->getOperand(0).getReg());
1074   } break;
1075   }
1076
1077   // The only comments we decode are shuffles, so give up if we were unable to
1078   // decode a shuffle mask.
1079   if (ShuffleMask.empty())
1080     return false;
1081
1082   if (!DestName) DestName = Src1Name;
1083   OS << (DestName ? DestName : "mem") << " = ";
1084
1085   // If the two sources are the same, canonicalize the input elements to be
1086   // from the first src so that we get larger element spans.
1087   if (Src1Name == Src2Name) {
1088     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
1089       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
1090           ShuffleMask[i] >= (int)e)   // From second mask.
1091         ShuffleMask[i] -= e;
1092     }
1093   }
1094
1095   // The shuffle mask specifies which elements of the src1/src2 fill in the
1096   // destination, with a few sentinel values.  Loop through and print them
1097   // out.
1098   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
1099     if (i != 0)
1100       OS << ',';
1101     if (ShuffleMask[i] == SM_SentinelZero) {
1102       OS << "zero";
1103       continue;
1104     }
1105
1106     // Otherwise, it must come from src1 or src2.  Print the span of elements
1107     // that comes from this src.
1108     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
1109     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
1110     OS << (SrcName ? SrcName : "mem") << '[';
1111     bool IsFirst = true;
1112     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
1113            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
1114       if (!IsFirst)
1115         OS << ',';
1116       else
1117         IsFirst = false;
1118       if (ShuffleMask[i] == SM_SentinelUndef)
1119         OS << "u";
1120       else
1121         OS << ShuffleMask[i] % ShuffleMask.size();
1122       ++i;
1123     }
1124     OS << ']';
1125     --i; // For loop increments element #.
1126   }
1127   //MI->print(OS, 0);
1128   OS << "\n";
1129
1130   // We successfully added a comment to this instruction.
1131   return true;
1132 }