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