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_VSHUF(Inst, src)                          \
 159   CASE_MASK_INS_COMMON(SHUFF##Inst, Z, r##src##i)      \
 160   CASE_MASK_INS_COMMON(SHUFI##Inst, Z, r##src##i)      \
 161   CASE_MASK_INS_COMMON(SHUFF##Inst, Z256, r##src##i)   \
 162   CASE_MASK_INS_COMMON(SHUFI##Inst, Z256, r##src##i)   \
 163
 164 /// \brief Extracts the types and if it has memory operand for a given
 165 /// (SHUFF32x4/SHUFF64x2/SHUFI32x4/SHUFI64x2) instruction.
 166 static void getVSHUF64x2FamilyInfo(const MCInst *MI, MVT &VT, bool &HasMemOp) {
 167   HasMemOp = false;
 168   switch (MI->getOpcode()) {
 169   default:
 170     llvm_unreachable("Unknown VSHUF64x2 family instructions.");
 171     break;
 172   CASE_VSHUF(64X2, m)
 173     HasMemOp = true;        // FALL THROUGH.
 174   CASE_VSHUF(64X2, r)
 175     VT = getRegOperandVectorVT(MI, MVT::i64, 0);
 176     break;
 177   CASE_VSHUF(32X4, m)
 178     HasMemOp = true;        // FALL THROUGH.
 179   CASE_VSHUF(32X4, r)
 180     VT = getRegOperandVectorVT(MI, MVT::i32, 0);
 181     break;
 182   }
 183 }
 184
 185 //===----------------------------------------------------------------------===//
 186 // Top Level Entrypoint
 187 //===----------------------------------------------------------------------===//
 188
 189 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints
 190 /// newline terminated strings to the specified string if desired.  This
 191 /// information is shown in disassembly dumps when verbose assembly is enabled.
 192 bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
 193                                   const char *(*getRegName)(unsigned)) {
 194   // If this is a shuffle operation, the switch should fill in this state.
 195   SmallVector<int, 8> ShuffleMask;
 196   const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
 197
 198   switch (MI->getOpcode()) {
 199   default:
 200     // Not an instruction for which we can decode comments.
 201     return false;
 202
 203   case X86::BLENDPDrri:
 204   case X86::VBLENDPDrri:
 205   case X86::VBLENDPDYrri:
 206     Src2Name = getRegName(MI->getOperand(2).getReg());
 207     // FALL THROUGH.
 208   case X86::BLENDPDrmi:
 209   case X86::VBLENDPDrmi:
 210   case X86::VBLENDPDYrmi:
 211     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 212       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::f64, 0),
 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   case X86::VBLENDPSYrri:
 222     Src2Name = getRegName(MI->getOperand(2).getReg());
 223     // FALL THROUGH.
 224   case X86::BLENDPSrmi:
 225   case X86::VBLENDPSrmi:
 226   case X86::VBLENDPSYrmi:
 227     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 228       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::f32, 0),
 229                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 230                       ShuffleMask);
 231     Src1Name = getRegName(MI->getOperand(1).getReg());
 232     DestName = getRegName(MI->getOperand(0).getReg());
 233     break;
 234
 235   case X86::PBLENDWrri:
 236   case X86::VPBLENDWrri:
 237   case X86::VPBLENDWYrri:
 238     Src2Name = getRegName(MI->getOperand(2).getReg());
 239     // FALL THROUGH.
 240   case X86::PBLENDWrmi:
 241   case X86::VPBLENDWrmi:
 242   case X86::VPBLENDWYrmi:
 243     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 244       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::i16, 0),
 245                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 246                       ShuffleMask);
 247     Src1Name = getRegName(MI->getOperand(1).getReg());
 248     DestName = getRegName(MI->getOperand(0).getReg());
 249     break;
 250
 251   case X86::VPBLENDDrri:
 252   case X86::VPBLENDDYrri:
 253     Src2Name = getRegName(MI->getOperand(2).getReg());
 254     // FALL THROUGH.
 255   case X86::VPBLENDDrmi:
 256   case X86::VPBLENDDYrmi:
 257     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 258       DecodeBLENDMask(getRegOperandVectorVT(MI, MVT::i32, 0),
 259                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 260                       ShuffleMask);
 261     Src1Name = getRegName(MI->getOperand(1).getReg());
 262     DestName = getRegName(MI->getOperand(0).getReg());
 263     break;
 264
 265   case X86::INSERTPSrr:
 266   case X86::VINSERTPSrr:
 267     Src2Name = getRegName(MI->getOperand(2).getReg());
 268     // FALL THROUGH.
 269   case X86::INSERTPSrm:
 270   case X86::VINSERTPSrm:
 271     DestName = getRegName(MI->getOperand(0).getReg());
 272     Src1Name = getRegName(MI->getOperand(1).getReg());
 273     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 274       DecodeINSERTPSMask(MI->getOperand(MI->getNumOperands() - 1).getImm(),
 275                          ShuffleMask);
 276     break;
 277
 278   case X86::MOVLHPSrr:
 279   case X86::VMOVLHPSrr:
 280     Src2Name = getRegName(MI->getOperand(2).getReg());
 281     Src1Name = getRegName(MI->getOperand(1).getReg());
 282     DestName = getRegName(MI->getOperand(0).getReg());
 283     DecodeMOVLHPSMask(2, ShuffleMask);
 284     break;
 285
 286   case X86::MOVHLPSrr:
 287   case X86::VMOVHLPSrr:
 288     Src2Name = getRegName(MI->getOperand(2).getReg());
 289     Src1Name = getRegName(MI->getOperand(1).getReg());
 290     DestName = getRegName(MI->getOperand(0).getReg());
 291     DecodeMOVHLPSMask(2, ShuffleMask);
 292     break;
 293
 294   CASE_MOVDUP(MOVSLDUP, r)
 295     Src1Name = getRegName(MI->getOperand(MI->getNumOperands() - 1).getReg());
 296     // FALL THROUGH.
 297   CASE_MOVDUP(MOVSLDUP, m) {
 298     MVT VT = getRegOperandVectorVT(MI, MVT::f32, 0);
 299     DestName = getRegName(MI->getOperand(0).getReg());
 300     DecodeMOVSLDUPMask(VT, ShuffleMask);
 301     break;
 302   }
 303
 304   CASE_MOVDUP(MOVSHDUP, r)
 305     Src1Name = getRegName(MI->getOperand(MI->getNumOperands() - 1).getReg());
 306     // FALL THROUGH.
 307   CASE_MOVDUP(MOVSHDUP, m) {
 308     MVT VT = getRegOperandVectorVT(MI, MVT::f32, 0);
 309     DestName = getRegName(MI->getOperand(0).getReg());
 310     DecodeMOVSHDUPMask(VT, ShuffleMask);
 311     break;
 312   }
 313
 314   case X86::VMOVDDUPYrr:
 315     Src1Name = getRegName(MI->getOperand(1).getReg());
 316     // FALL THROUGH.
 317   case X86::VMOVDDUPYrm:
 318     DestName = getRegName(MI->getOperand(0).getReg());
 319     DecodeMOVDDUPMask(MVT::v4f64, ShuffleMask);
 320     break;
 321
 322   case X86::MOVDDUPrr:
 323   case X86::VMOVDDUPrr:
 324     Src1Name = getRegName(MI->getOperand(1).getReg());
 325     // FALL THROUGH.
 326   case X86::MOVDDUPrm:
 327   case X86::VMOVDDUPrm:
 328     DestName = getRegName(MI->getOperand(0).getReg());
 329     DecodeMOVDDUPMask(MVT::v2f64, ShuffleMask);
 330     break;
 331
 332   case X86::PSLLDQri:
 333   case X86::VPSLLDQri:
 334   case X86::VPSLLDQYri:
 335     Src1Name = getRegName(MI->getOperand(1).getReg());
 336     DestName = getRegName(MI->getOperand(0).getReg());
 337     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 338       DecodePSLLDQMask(getRegOperandVectorVT(MI, MVT::i8, 0),
 339                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 340                        ShuffleMask);
 341     break;
 342
 343   case X86::PSRLDQri:
 344   case X86::VPSRLDQri:
 345   case X86::VPSRLDQYri:
 346     Src1Name = getRegName(MI->getOperand(1).getReg());
 347     DestName = getRegName(MI->getOperand(0).getReg());
 348     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 349       DecodePSRLDQMask(getRegOperandVectorVT(MI, MVT::i8, 0),
 350                        MI->getOperand(MI->getNumOperands() - 1).getImm(),
 351                        ShuffleMask);
 352     break;
 353
 354   case X86::PALIGNR128rr:
 355   case X86::VPALIGNR128rr:
 356   case X86::VPALIGNR256rr:
 357     Src1Name = getRegName(MI->getOperand(2).getReg());
 358     // FALL THROUGH.
 359   case X86::PALIGNR128rm:
 360   case X86::VPALIGNR128rm:
 361   case X86::VPALIGNR256rm:
 362     Src2Name = getRegName(MI->getOperand(1).getReg());
 363     DestName = getRegName(MI->getOperand(0).getReg());
 364     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 365       DecodePALIGNRMask(getRegOperandVectorVT(MI, MVT::i8, 0),
 366                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 367                         ShuffleMask);
 368     break;
 369
 370   case X86::PSHUFDri:
 371   case X86::VPSHUFDri:
 372   case X86::VPSHUFDYri:
 373     Src1Name = getRegName(MI->getOperand(1).getReg());
 374     // FALL THROUGH.
 375   case X86::PSHUFDmi:
 376   case X86::VPSHUFDmi:
 377   case X86::VPSHUFDYmi:
 378     DestName = getRegName(MI->getOperand(0).getReg());
 379     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 380       DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::i32, 0),
 381                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 382                       ShuffleMask);
 383     break;
 384
 385   case X86::PSHUFHWri:
 386   case X86::VPSHUFHWri:
 387   case X86::VPSHUFHWYri:
 388     Src1Name = getRegName(MI->getOperand(1).getReg());
 389     // FALL THROUGH.
 390   case X86::PSHUFHWmi:
 391   case X86::VPSHUFHWmi:
 392   case X86::VPSHUFHWYmi:
 393     DestName = getRegName(MI->getOperand(0).getReg());
 394     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 395       DecodePSHUFHWMask(getRegOperandVectorVT(MI, MVT::i16, 0),
 396                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 397                         ShuffleMask);
 398     break;
 399
 400   case X86::PSHUFLWri:
 401   case X86::VPSHUFLWri:
 402   case X86::VPSHUFLWYri:
 403     Src1Name = getRegName(MI->getOperand(1).getReg());
 404     // FALL THROUGH.
 405   case X86::PSHUFLWmi:
 406   case X86::VPSHUFLWmi:
 407   case X86::VPSHUFLWYmi:
 408     DestName = getRegName(MI->getOperand(0).getReg());
 409     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 410       DecodePSHUFLWMask(getRegOperandVectorVT(MI, MVT::i16, 0),
 411                         MI->getOperand(MI->getNumOperands() - 1).getImm(),
 412                         ShuffleMask);
 413     break;
 414
 415   case X86::MMX_PSHUFWri:
 416     Src1Name = getRegName(MI->getOperand(1).getReg());
 417     // FALL THROUGH.
 418   case X86::MMX_PSHUFWmi:
 419     DestName = getRegName(MI->getOperand(0).getReg());
 420     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 421       DecodePSHUFMask(MVT::v4i16,
 422                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 423                       ShuffleMask);
 424     break;
 425
 426   case X86::PSWAPDrr:
 427     Src1Name = getRegName(MI->getOperand(1).getReg());
 428     // FALL THROUGH.
 429   case X86::PSWAPDrm:
 430     DestName = getRegName(MI->getOperand(0).getReg());
 431     DecodePSWAPMask(MVT::v2i32, ShuffleMask);
 432     break;
 433
 434   CASE_UNPCK(PUNPCKHBW, r)
 435   case X86::MMX_PUNPCKHBWirr:
 436     Src2Name = getRegName(MI->getOperand(2).getReg());
 437     // FALL THROUGH.
 438   CASE_UNPCK(PUNPCKHBW, m)
 439   case X86::MMX_PUNPCKHBWirm:
 440     Src1Name = getRegName(MI->getOperand(1).getReg());
 441     DestName = getRegName(MI->getOperand(0).getReg());
 442     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i8, 0), ShuffleMask);
 443     break;
 444
 445   CASE_UNPCK(PUNPCKHWD, r)
 446   case X86::MMX_PUNPCKHWDirr:
 447     Src2Name = getRegName(MI->getOperand(2).getReg());
 448     // FALL THROUGH.
 449   CASE_UNPCK(PUNPCKHWD, m)
 450   case X86::MMX_PUNPCKHWDirm:
 451     Src1Name = getRegName(MI->getOperand(1).getReg());
 452     DestName = getRegName(MI->getOperand(0).getReg());
 453     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i16, 0), ShuffleMask);
 454     break;
 455
 456   CASE_UNPCK(PUNPCKHDQ, r)
 457   case X86::MMX_PUNPCKHDQirr:
 458     Src2Name = getRegName(MI->getOperand(2).getReg());
 459     // FALL THROUGH.
 460   CASE_UNPCK(PUNPCKHDQ, m)
 461   case X86::MMX_PUNPCKHDQirm:
 462     Src1Name = getRegName(MI->getOperand(1).getReg());
 463     DestName = getRegName(MI->getOperand(0).getReg());
 464     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i32, 0), ShuffleMask);
 465     break;
 466
 467   CASE_UNPCK(PUNPCKHQDQ, r)
 468     Src2Name = getRegName(MI->getOperand(2).getReg());
 469     // FALL THROUGH.
 470   CASE_UNPCK(PUNPCKHQDQ, m)
 471     Src1Name = getRegName(MI->getOperand(1).getReg());
 472     DestName = getRegName(MI->getOperand(0).getReg());
 473     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::i64, 0), ShuffleMask);
 474     break;
 475
 476   CASE_UNPCK(PUNPCKLBW, r)
 477   case X86::MMX_PUNPCKLBWirr:
 478     Src2Name = getRegName(MI->getOperand(2).getReg());
 479     // FALL THROUGH.
 480   CASE_UNPCK(PUNPCKLBW, m)
 481   case X86::MMX_PUNPCKLBWirm:
 482     Src1Name = getRegName(MI->getOperand(1).getReg());
 483     DestName = getRegName(MI->getOperand(0).getReg());
 484     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i8, 0), ShuffleMask);
 485     break;
 486
 487   CASE_UNPCK(PUNPCKLWD, r)
 488   case X86::MMX_PUNPCKLWDirr:
 489     Src2Name = getRegName(MI->getOperand(2).getReg());
 490     // FALL THROUGH.
 491   CASE_UNPCK(PUNPCKLWD, m)
 492   case X86::MMX_PUNPCKLWDirm:
 493     Src1Name = getRegName(MI->getOperand(1).getReg());
 494     DestName = getRegName(MI->getOperand(0).getReg());
 495     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i16, 0), ShuffleMask);
 496     break;
 497
 498   CASE_UNPCK(PUNPCKLDQ, r)
 499   case X86::MMX_PUNPCKLDQirr:
 500     Src2Name = getRegName(MI->getOperand(2).getReg());
 501     // FALL THROUGH.
 502   CASE_UNPCK(PUNPCKLDQ, m)
 503   case X86::MMX_PUNPCKLDQirm:
 504     Src1Name = getRegName(MI->getOperand(1).getReg());
 505     DestName = getRegName(MI->getOperand(0).getReg());
 506     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i32, 0), ShuffleMask);
 507     break;
 508
 509   CASE_UNPCK(PUNPCKLQDQ, r)
 510     Src2Name = getRegName(MI->getOperand(2).getReg());
 511     // FALL THROUGH.
 512   CASE_UNPCK(PUNPCKLQDQ, m)
 513     Src1Name = getRegName(MI->getOperand(1).getReg());
 514     DestName = getRegName(MI->getOperand(0).getReg());
 515     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::i64, 0), ShuffleMask);
 516     break;
 517
 518   case X86::SHUFPDrri:
 519   case X86::VSHUFPDrri:
 520   case X86::VSHUFPDYrri:
 521     Src2Name = getRegName(MI->getOperand(2).getReg());
 522     // FALL THROUGH.
 523   case X86::SHUFPDrmi:
 524   case X86::VSHUFPDrmi:
 525   case X86::VSHUFPDYrmi:
 526     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 527       DecodeSHUFPMask(getRegOperandVectorVT(MI, MVT::f64, 0),
 528                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 529                       ShuffleMask);
 530     Src1Name = getRegName(MI->getOperand(1).getReg());
 531     DestName = getRegName(MI->getOperand(0).getReg());
 532     break;
 533
 534   case X86::SHUFPSrri:
 535   case X86::VSHUFPSrri:
 536   case X86::VSHUFPSYrri:
 537     Src2Name = getRegName(MI->getOperand(2).getReg());
 538     // FALL THROUGH.
 539   case X86::SHUFPSrmi:
 540   case X86::VSHUFPSrmi:
 541   case X86::VSHUFPSYrmi:
 542     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 543       DecodeSHUFPMask(getRegOperandVectorVT(MI, MVT::f32, 0),
 544                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 545                       ShuffleMask);
 546     Src1Name = getRegName(MI->getOperand(1).getReg());
 547     DestName = getRegName(MI->getOperand(0).getReg());
 548     break;
 549
 550   CASE_VSHUF(64X2, r)
 551   CASE_VSHUF(64X2, m)
 552   CASE_VSHUF(32X4, r)
 553   CASE_VSHUF(32X4, m) {
 554     MVT VT;
 555     bool HasMemOp;
 556     unsigned NumOp = MI->getNumOperands();
 557     getVSHUF64x2FamilyInfo(MI, VT, HasMemOp);
 558     decodeVSHUF64x2FamilyMask(VT, MI->getOperand(NumOp - 1).getImm(),
 559                               ShuffleMask);
 560     DestName = getRegName(MI->getOperand(0).getReg());
 561     if (HasMemOp) {
 562       assert((NumOp >= 8) && "Expected at least 8 operands!");
 563       Src1Name = getRegName(MI->getOperand(NumOp - 7).getReg());
 564     } else {
 565       assert((NumOp >= 4) && "Expected at least 4 operands!");
 566       Src2Name = getRegName(MI->getOperand(NumOp - 2).getReg());
 567       Src1Name = getRegName(MI->getOperand(NumOp - 3).getReg());
 568     }
 569     break;
 570   }
 571
 572   CASE_UNPCK(UNPCKLPD, r)
 573     Src2Name = getRegName(MI->getOperand(2).getReg());
 574     // FALL THROUGH.
 575   CASE_UNPCK(UNPCKLPD, m)
 576     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::f64, 0), ShuffleMask);
 577     Src1Name = getRegName(MI->getOperand(1).getReg());
 578     DestName = getRegName(MI->getOperand(0).getReg());
 579     break;
 580
 581   CASE_UNPCK(UNPCKLPS, r)
 582     Src2Name = getRegName(MI->getOperand(2).getReg());
 583     // FALL THROUGH.
 584   CASE_UNPCK(UNPCKLPS, m)
 585     DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
 586     Src1Name = getRegName(MI->getOperand(1).getReg());
 587     DestName = getRegName(MI->getOperand(0).getReg());
 588     break;
 589
 590   CASE_UNPCK(UNPCKHPD, r)
 591     Src2Name = getRegName(MI->getOperand(2).getReg());
 592     // FALL THROUGH.
 593   CASE_UNPCK(UNPCKHPD, m)
 594     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::f64, 0), ShuffleMask);
 595     Src1Name = getRegName(MI->getOperand(1).getReg());
 596     DestName = getRegName(MI->getOperand(0).getReg());
 597     break;
 598
 599   CASE_UNPCK(UNPCKHPS, r)
 600     Src2Name = getRegName(MI->getOperand(2).getReg());
 601     // FALL THROUGH.
 602   CASE_UNPCK(UNPCKHPS, m)
 603     DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
 604     Src1Name = getRegName(MI->getOperand(1).getReg());
 605     DestName = getRegName(MI->getOperand(0).getReg());
 606     break;
 607
 608   case X86::VPERMILPSri:
 609   case X86::VPERMILPSYri:
 610     Src1Name = getRegName(MI->getOperand(1).getReg());
 611     // FALL THROUGH.
 612   case X86::VPERMILPSmi:
 613   case X86::VPERMILPSYmi:
 614     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 615       DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::f32, 0),
 616                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 617                       ShuffleMask);
 618     DestName = getRegName(MI->getOperand(0).getReg());
 619     break;
 620
 621   case X86::VPERMILPDri:
 622   case X86::VPERMILPDYri:
 623     Src1Name = getRegName(MI->getOperand(1).getReg());
 624     // FALL THROUGH.
 625   case X86::VPERMILPDmi:
 626   case X86::VPERMILPDYmi:
 627     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 628       DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::f64, 0),
 629                       MI->getOperand(MI->getNumOperands() - 1).getImm(),
 630                       ShuffleMask);
 631     DestName = getRegName(MI->getOperand(0).getReg());
 632     break;
 633
 634   case X86::VPERM2F128rr:
 635   case X86::VPERM2I128rr:
 636     Src2Name = getRegName(MI->getOperand(2).getReg());
 637     // FALL THROUGH.
 638   case X86::VPERM2F128rm:
 639   case X86::VPERM2I128rm:
 640     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 641     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 642       DecodeVPERM2X128Mask(MVT::v4i64,
 643                            MI->getOperand(MI->getNumOperands() - 1).getImm(),
 644                            ShuffleMask);
 645     Src1Name = getRegName(MI->getOperand(1).getReg());
 646     DestName = getRegName(MI->getOperand(0).getReg());
 647     break;
 648
 649   case X86::VPERMQYri:
 650   case X86::VPERMPDYri:
 651     Src1Name = getRegName(MI->getOperand(1).getReg());
 652     // FALL THROUGH.
 653   case X86::VPERMQYmi:
 654   case X86::VPERMPDYmi:
 655     if (MI->getOperand(MI->getNumOperands() - 1).isImm())
 656       DecodeVPERMMask(MI->getOperand(MI->getNumOperands() - 1).getImm(),
 657                       ShuffleMask);
 658     DestName = getRegName(MI->getOperand(0).getReg());
 659     break;
 660
 661   case X86::MOVSDrr:
 662   case X86::VMOVSDrr:
 663     Src2Name = getRegName(MI->getOperand(2).getReg());
 664     Src1Name = getRegName(MI->getOperand(1).getReg());
 665     // FALL THROUGH.
 666   case X86::MOVSDrm:
 667   case X86::VMOVSDrm:
 668     DecodeScalarMoveMask(MVT::v2f64, nullptr == Src2Name, ShuffleMask);
 669     DestName = getRegName(MI->getOperand(0).getReg());
 670     break;
 671   case X86::MOVSSrr:
 672   case X86::VMOVSSrr:
 673     Src2Name = getRegName(MI->getOperand(2).getReg());
 674     Src1Name = getRegName(MI->getOperand(1).getReg());
 675     // FALL THROUGH.
 676   case X86::MOVSSrm:
 677   case X86::VMOVSSrm:
 678     DecodeScalarMoveMask(MVT::v4f32, nullptr == Src2Name, ShuffleMask);
 679     DestName = getRegName(MI->getOperand(0).getReg());
 680     break;
 681
 682   case X86::MOVPQI2QIrr:
 683   case X86::MOVZPQILo2PQIrr:
 684   case X86::VMOVPQI2QIrr:
 685   case X86::VMOVZPQILo2PQIrr:
 686     Src1Name = getRegName(MI->getOperand(1).getReg());
 687   // FALL THROUGH.
 688   case X86::MOVQI2PQIrm:
 689   case X86::MOVZQI2PQIrm:
 690   case X86::MOVZPQILo2PQIrm:
 691   case X86::VMOVQI2PQIrm:
 692   case X86::VMOVZQI2PQIrm:
 693   case X86::VMOVZPQILo2PQIrm:
 694     DecodeZeroMoveLowMask(MVT::v2i64, ShuffleMask);
 695     DestName = getRegName(MI->getOperand(0).getReg());
 696     break;
 697
 698   case X86::MOVDI2PDIrm:
 699   case X86::VMOVDI2PDIrm:
 700     DecodeZeroMoveLowMask(MVT::v4i32, ShuffleMask);
 701     DestName = getRegName(MI->getOperand(0).getReg());
 702     break;
 703
 704   case X86::EXTRQI:
 705     if (MI->getOperand(2).isImm() &&
 706         MI->getOperand(3).isImm())
 707       DecodeEXTRQIMask(MI->getOperand(2).getImm(),
 708                        MI->getOperand(3).getImm(),
 709                        ShuffleMask);
 710
 711     DestName = getRegName(MI->getOperand(0).getReg());
 712     Src1Name = getRegName(MI->getOperand(1).getReg());
 713     break;
 714
 715   case X86::INSERTQI:
 716     if (MI->getOperand(3).isImm() &&
 717         MI->getOperand(4).isImm())
 718       DecodeINSERTQIMask(MI->getOperand(3).getImm(),
 719                          MI->getOperand(4).getImm(),
 720                          ShuffleMask);
 721
 722     DestName = getRegName(MI->getOperand(0).getReg());
 723     Src1Name = getRegName(MI->getOperand(1).getReg());
 724     Src2Name = getRegName(MI->getOperand(2).getReg());
 725     break;
 726
 727   case X86::PMOVZXBWrr:
 728   case X86::PMOVZXBDrr:
 729   case X86::PMOVZXBQrr:
 730   case X86::PMOVZXWDrr:
 731   case X86::PMOVZXWQrr:
 732   case X86::PMOVZXDQrr:
 733   case X86::VPMOVZXBWrr:
 734   case X86::VPMOVZXBDrr:
 735   case X86::VPMOVZXBQrr:
 736   case X86::VPMOVZXWDrr:
 737   case X86::VPMOVZXWQrr:
 738   case X86::VPMOVZXDQrr:
 739   case X86::VPMOVZXBWYrr:
 740   case X86::VPMOVZXBDYrr:
 741   case X86::VPMOVZXBQYrr:
 742   case X86::VPMOVZXWDYrr:
 743   case X86::VPMOVZXWQYrr:
 744   case X86::VPMOVZXDQYrr:
 745     Src1Name = getRegName(MI->getOperand(1).getReg());
 746   // FALL THROUGH.
 747   case X86::PMOVZXBWrm:
 748   case X86::PMOVZXBDrm:
 749   case X86::PMOVZXBQrm:
 750   case X86::PMOVZXWDrm:
 751   case X86::PMOVZXWQrm:
 752   case X86::PMOVZXDQrm:
 753   case X86::VPMOVZXBWrm:
 754   case X86::VPMOVZXBDrm:
 755   case X86::VPMOVZXBQrm:
 756   case X86::VPMOVZXWDrm:
 757   case X86::VPMOVZXWQrm:
 758   case X86::VPMOVZXDQrm:
 759   case X86::VPMOVZXBWYrm:
 760   case X86::VPMOVZXBDYrm:
 761   case X86::VPMOVZXBQYrm:
 762   case X86::VPMOVZXWDYrm:
 763   case X86::VPMOVZXWQYrm:
 764   case X86::VPMOVZXDQYrm: {
 765     MVT SrcVT, DstVT;
 766     getZeroExtensionTypes(MI, SrcVT, DstVT);
 767     DecodeZeroExtendMask(SrcVT, DstVT, ShuffleMask);
 768     DestName = getRegName(MI->getOperand(0).getReg());
 769   } break;
 770   }
 771
 772   // The only comments we decode are shuffles, so give up if we were unable to
 773   // decode a shuffle mask.
 774   if (ShuffleMask.empty())
 775     return false;
 776
 777   if (!DestName) DestName = Src1Name;
 778   OS << (DestName ? DestName : "mem") << " = ";
 779
 780   // If the two sources are the same, canonicalize the input elements to be
 781   // from the first src so that we get larger element spans.
 782   if (Src1Name == Src2Name) {
 783     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 784       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 785           ShuffleMask[i] >= (int)e)   // From second mask.
 786         ShuffleMask[i] -= e;
 787     }
 788   }
 789
 790   // The shuffle mask specifies which elements of the src1/src2 fill in the
 791   // destination, with a few sentinel values.  Loop through and print them
 792   // out.
 793   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 794     if (i != 0)
 795       OS << ',';
 796     if (ShuffleMask[i] == SM_SentinelZero) {
 797       OS << "zero";
 798       continue;
 799     }
 800
 801     // Otherwise, it must come from src1 or src2.  Print the span of elements
 802     // that comes from this src.
 803     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
 804     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 805     OS << (SrcName ? SrcName : "mem") << '[';
 806     bool IsFirst = true;
 807     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
 808            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
 809       if (!IsFirst)
 810         OS << ',';
 811       else
 812         IsFirst = false;
 813       if (ShuffleMask[i] == SM_SentinelUndef)
 814         OS << "u";
 815       else
 816         OS << ShuffleMask[i] % ShuffleMask.size();
 817       ++i;
 818     }
 819     OS << ']';
 820     --i; // For loop increments element #.
 821   }
 822   //MI->print(OS, 0);
 823   OS << "\n";
 824
 825   // We successfully added a comment to this instruction.
 826   return true;
 827 }