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 //===----------------------------------------------------------------------===//
  25 // Top Level Entrypoint
  26 //===----------------------------------------------------------------------===//
  27
  28 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints
  29 /// newline terminated strings to the specified string if desired.  This
  30 /// information is shown in disassembly dumps when verbose assembly is enabled.
  31 bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
  32                                   const char *(*getRegName)(unsigned)) {
  33   // If this is a shuffle operation, the switch should fill in this state.
  34   SmallVector<int, 8> ShuffleMask;
  35   const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
  36
  37   switch (MI->getOpcode()) {
  38   default:
  39     // Not an instruction for which we can decode comments.
  40     return false;
  41
  42   case X86::BLENDPDrri:
  43   case X86::VBLENDPDrri:
  44     Src2Name = getRegName(MI->getOperand(2).getReg());
  45     // FALL THROUGH.
  46   case X86::BLENDPDrmi:
  47   case X86::VBLENDPDrmi:
  48     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  49       DecodeBLENDMask(MVT::v2f64,
  50                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  51                       ShuffleMask);
  52     Src1Name = getRegName(MI->getOperand(1).getReg());
  53     DestName = getRegName(MI->getOperand(0).getReg());
  54     break;
  55   case X86::VBLENDPDYrri:
  56     Src2Name = getRegName(MI->getOperand(2).getReg());
  57     // FALL THROUGH.
  58   case X86::VBLENDPDYrmi:
  59     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  60       DecodeBLENDMask(MVT::v4f64,
  61                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  62                       ShuffleMask);
  63     Src1Name = getRegName(MI->getOperand(1).getReg());
  64     DestName = getRegName(MI->getOperand(0).getReg());
  65     break;
  66
  67   case X86::BLENDPSrri:
  68   case X86::VBLENDPSrri:
  69     Src2Name = getRegName(MI->getOperand(2).getReg());
  70     // FALL THROUGH.
  71   case X86::BLENDPSrmi:
  72   case X86::VBLENDPSrmi:
  73     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  74       DecodeBLENDMask(MVT::v4f32,
  75                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  76                       ShuffleMask);
  77     Src1Name = getRegName(MI->getOperand(1).getReg());
  78     DestName = getRegName(MI->getOperand(0).getReg());
  79     break;
  80   case X86::VBLENDPSYrri:
  81     Src2Name = getRegName(MI->getOperand(2).getReg());
  82     // FALL THROUGH.
  83   case X86::VBLENDPSYrmi:
  84     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  85       DecodeBLENDMask(MVT::v8f32,
  86                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  87                       ShuffleMask);
  88     Src1Name = getRegName(MI->getOperand(1).getReg());
  89     DestName = getRegName(MI->getOperand(0).getReg());
  90     break;
  91
  92   case X86::PBLENDWrri:
  93   case X86::VPBLENDWrri:
  94     Src2Name = getRegName(MI->getOperand(2).getReg());
  95     // FALL THROUGH.
  96   case X86::PBLENDWrmi:
  97   case X86::VPBLENDWrmi:
  98     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  99       DecodeBLENDMask(MVT::v8i16,
 100                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 101                       ShuffleMask);
 102     Src1Name = getRegName(MI->getOperand(1).getReg());
 103     DestName = getRegName(MI->getOperand(0).getReg());
 104     break;
 105   case X86::VPBLENDWYrri:
 106     Src2Name = getRegName(MI->getOperand(2).getReg());
 107     // FALL THROUGH.
 108   case X86::VPBLENDWYrmi:
 109     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 110       DecodeBLENDMask(MVT::v16i16,
 111                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 112                       ShuffleMask);
 113     Src1Name = getRegName(MI->getOperand(1).getReg());
 114     DestName = getRegName(MI->getOperand(0).getReg());
 115     break;
 116
 117   case X86::VPBLENDDrri:
 118     Src2Name = getRegName(MI->getOperand(2).getReg());
 119     // FALL THROUGH.
 120   case X86::VPBLENDDrmi:
 121     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 122       DecodeBLENDMask(MVT::v4i32,
 123                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 124                       ShuffleMask);
 125     Src1Name = getRegName(MI->getOperand(1).getReg());
 126     DestName = getRegName(MI->getOperand(0).getReg());
 127     break;
 128
 129   case X86::VPBLENDDYrri:
 130     Src2Name = getRegName(MI->getOperand(2).getReg());
 131     // FALL THROUGH.
 132   case X86::VPBLENDDYrmi:
 133     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 134       DecodeBLENDMask(MVT::v8i32,
 135                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 136                       ShuffleMask);
 137     Src1Name = getRegName(MI->getOperand(1).getReg());
 138     DestName = getRegName(MI->getOperand(0).getReg());
 139     break;
 140
 141   case X86::INSERTPSrr:
 142   case X86::VINSERTPSrr:
 143     DestName = getRegName(MI->getOperand(0).getReg());
 144     Src1Name = getRegName(MI->getOperand(1).getReg());
 145     Src2Name = getRegName(MI->getOperand(2).getReg());
 146     if(MI->getOperand(3).isImm())
 147       DecodeINSERTPSMask(MI->getOperand(3).getImm(), ShuffleMask);
 148     break;
 149
 150   case X86::MOVLHPSrr:
 151   case X86::VMOVLHPSrr:
 152     Src2Name = getRegName(MI->getOperand(2).getReg());
 153     Src1Name = getRegName(MI->getOperand(1).getReg());
 154     DestName = getRegName(MI->getOperand(0).getReg());
 155     DecodeMOVLHPSMask(2, ShuffleMask);
 156     break;
 157
 158   case X86::MOVHLPSrr:
 159   case X86::VMOVHLPSrr:
 160     Src2Name = getRegName(MI->getOperand(2).getReg());
 161     Src1Name = getRegName(MI->getOperand(1).getReg());
 162     DestName = getRegName(MI->getOperand(0).getReg());
 163     DecodeMOVHLPSMask(2, ShuffleMask);
 164     break;
 165
 166   case X86::MOVSLDUPrr:
 167   case X86::VMOVSLDUPrr:
 168     Src1Name = getRegName(MI->getOperand(1).getReg());
 169     // FALL THROUGH.
 170   case X86::MOVSLDUPrm:
 171   case X86::VMOVSLDUPrm:
 172     DestName = getRegName(MI->getOperand(0).getReg());
 173     DecodeMOVSLDUPMask(MVT::v4f32, ShuffleMask);
 174     break;
 175
 176   case X86::VMOVSHDUPYrr:
 177     Src1Name = getRegName(MI->getOperand(1).getReg());
 178     // FALL THROUGH.
 179   case X86::VMOVSHDUPYrm:
 180     DestName = getRegName(MI->getOperand(0).getReg());
 181     DecodeMOVSHDUPMask(MVT::v8f32, ShuffleMask);
 182     break;
 183
 184   case X86::VMOVSLDUPYrr:
 185     Src1Name = getRegName(MI->getOperand(1).getReg());
 186     // FALL THROUGH.
 187   case X86::VMOVSLDUPYrm:
 188     DestName = getRegName(MI->getOperand(0).getReg());
 189     DecodeMOVSLDUPMask(MVT::v8f32, ShuffleMask);
 190     break;
 191
 192   case X86::MOVSHDUPrr:
 193   case X86::VMOVSHDUPrr:
 194     Src1Name = getRegName(MI->getOperand(1).getReg());
 195     // FALL THROUGH.
 196   case X86::MOVSHDUPrm:
 197   case X86::VMOVSHDUPrm:
 198     DestName = getRegName(MI->getOperand(0).getReg());
 199     DecodeMOVSHDUPMask(MVT::v4f32, ShuffleMask);
 200     break;
 201
 202   case X86::PALIGNR128rr:
 203   case X86::VPALIGNR128rr:
 204     Src1Name = getRegName(MI->getOperand(2).getReg());
 205     // FALL THROUGH.
 206   case X86::PALIGNR128rm:
 207   case X86::VPALIGNR128rm:
 208     Src2Name = getRegName(MI->getOperand(1).getReg());
 209     DestName = getRegName(MI->getOperand(0).getReg());
 210     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 211       DecodePALIGNRMask(MVT::v16i8,
 212                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 213                         ShuffleMask);
 214     break;
 215   case X86::VPALIGNR256rr:
 216     Src1Name = getRegName(MI->getOperand(2).getReg());
 217     // FALL THROUGH.
 218   case X86::VPALIGNR256rm:
 219     Src2Name = getRegName(MI->getOperand(1).getReg());
 220     DestName = getRegName(MI->getOperand(0).getReg());
 221     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 222       DecodePALIGNRMask(MVT::v32i8,
 223                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 224                         ShuffleMask);
 225     break;
 226
 227   case X86::PSHUFDri:
 228   case X86::VPSHUFDri:
 229     Src1Name = getRegName(MI->getOperand(1).getReg());
 230     // FALL THROUGH.
 231   case X86::PSHUFDmi:
 232   case X86::VPSHUFDmi:
 233     DestName = getRegName(MI->getOperand(0).getReg());
 234     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 235       DecodePSHUFMask(MVT::v4i32,
 236                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 237                       ShuffleMask);
 238     break;
 239   case X86::VPSHUFDYri:
 240     Src1Name = getRegName(MI->getOperand(1).getReg());
 241     // FALL THROUGH.
 242   case X86::VPSHUFDYmi:
 243     DestName = getRegName(MI->getOperand(0).getReg());
 244     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 245       DecodePSHUFMask(MVT::v8i32,
 246                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 247                       ShuffleMask);
 248     break;
 249
 250
 251   case X86::PSHUFHWri:
 252   case X86::VPSHUFHWri:
 253     Src1Name = getRegName(MI->getOperand(1).getReg());
 254     // FALL THROUGH.
 255   case X86::PSHUFHWmi:
 256   case X86::VPSHUFHWmi:
 257     DestName = getRegName(MI->getOperand(0).getReg());
 258     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 259       DecodePSHUFHWMask(MVT::v8i16,
 260                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 261                         ShuffleMask);
 262     break;
 263   case X86::VPSHUFHWYri:
 264     Src1Name = getRegName(MI->getOperand(1).getReg());
 265     // FALL THROUGH.
 266   case X86::VPSHUFHWYmi:
 267     DestName = getRegName(MI->getOperand(0).getReg());
 268     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 269       DecodePSHUFHWMask(MVT::v16i16,
 270                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 271                         ShuffleMask);
 272     break;
 273   case X86::PSHUFLWri:
 274   case X86::VPSHUFLWri:
 275     Src1Name = getRegName(MI->getOperand(1).getReg());
 276     // FALL THROUGH.
 277   case X86::PSHUFLWmi:
 278   case X86::VPSHUFLWmi:
 279     DestName = getRegName(MI->getOperand(0).getReg());
 280     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 281       DecodePSHUFLWMask(MVT::v8i16,
 282                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 283                         ShuffleMask);
 284     break;
 285   case X86::VPSHUFLWYri:
 286     Src1Name = getRegName(MI->getOperand(1).getReg());
 287     // FALL THROUGH.
 288   case X86::VPSHUFLWYmi:
 289     DestName = getRegName(MI->getOperand(0).getReg());
 290     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 291       DecodePSHUFLWMask(MVT::v16i16,
 292                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 293                         ShuffleMask);
 294     break;
 295
 296   case X86::PUNPCKHBWrr:
 297   case X86::VPUNPCKHBWrr:
 298     Src2Name = getRegName(MI->getOperand(2).getReg());
 299     // FALL THROUGH.
 300   case X86::PUNPCKHBWrm:
 301   case X86::VPUNPCKHBWrm:
 302     Src1Name = getRegName(MI->getOperand(1).getReg());
 303     DestName = getRegName(MI->getOperand(0).getReg());
 304     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
 305     break;
 306   case X86::VPUNPCKHBWYrr:
 307     Src2Name = getRegName(MI->getOperand(2).getReg());
 308     // FALL THROUGH.
 309   case X86::VPUNPCKHBWYrm:
 310     Src1Name = getRegName(MI->getOperand(1).getReg());
 311     DestName = getRegName(MI->getOperand(0).getReg());
 312     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
 313     break;
 314   case X86::PUNPCKHWDrr:
 315   case X86::VPUNPCKHWDrr:
 316     Src2Name = getRegName(MI->getOperand(2).getReg());
 317     // FALL THROUGH.
 318   case X86::PUNPCKHWDrm:
 319   case X86::VPUNPCKHWDrm:
 320     Src1Name = getRegName(MI->getOperand(1).getReg());
 321     DestName = getRegName(MI->getOperand(0).getReg());
 322     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
 323     break;
 324   case X86::VPUNPCKHWDYrr:
 325     Src2Name = getRegName(MI->getOperand(2).getReg());
 326     // FALL THROUGH.
 327   case X86::VPUNPCKHWDYrm:
 328     Src1Name = getRegName(MI->getOperand(1).getReg());
 329     DestName = getRegName(MI->getOperand(0).getReg());
 330     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
 331     break;
 332   case X86::PUNPCKHDQrr:
 333   case X86::VPUNPCKHDQrr:
 334     Src2Name = getRegName(MI->getOperand(2).getReg());
 335     // FALL THROUGH.
 336   case X86::PUNPCKHDQrm:
 337   case X86::VPUNPCKHDQrm:
 338     Src1Name = getRegName(MI->getOperand(1).getReg());
 339     DestName = getRegName(MI->getOperand(0).getReg());
 340     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
 341     break;
 342   case X86::VPUNPCKHDQYrr:
 343     Src2Name = getRegName(MI->getOperand(2).getReg());
 344     // FALL THROUGH.
 345   case X86::VPUNPCKHDQYrm:
 346     Src1Name = getRegName(MI->getOperand(1).getReg());
 347     DestName = getRegName(MI->getOperand(0).getReg());
 348     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
 349     break;
 350   case X86::PUNPCKHQDQrr:
 351   case X86::VPUNPCKHQDQrr:
 352     Src2Name = getRegName(MI->getOperand(2).getReg());
 353     // FALL THROUGH.
 354   case X86::PUNPCKHQDQrm:
 355   case X86::VPUNPCKHQDQrm:
 356     Src1Name = getRegName(MI->getOperand(1).getReg());
 357     DestName = getRegName(MI->getOperand(0).getReg());
 358     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
 359     break;
 360   case X86::VPUNPCKHQDQYrr:
 361     Src2Name = getRegName(MI->getOperand(2).getReg());
 362     // FALL THROUGH.
 363   case X86::VPUNPCKHQDQYrm:
 364     Src1Name = getRegName(MI->getOperand(1).getReg());
 365     DestName = getRegName(MI->getOperand(0).getReg());
 366     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
 367     break;
 368
 369   case X86::PUNPCKLBWrr:
 370   case X86::VPUNPCKLBWrr:
 371     Src2Name = getRegName(MI->getOperand(2).getReg());
 372     // FALL THROUGH.
 373   case X86::PUNPCKLBWrm:
 374   case X86::VPUNPCKLBWrm:
 375     Src1Name = getRegName(MI->getOperand(1).getReg());
 376     DestName = getRegName(MI->getOperand(0).getReg());
 377     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
 378     break;
 379   case X86::VPUNPCKLBWYrr:
 380     Src2Name = getRegName(MI->getOperand(2).getReg());
 381     // FALL THROUGH.
 382   case X86::VPUNPCKLBWYrm:
 383     Src1Name = getRegName(MI->getOperand(1).getReg());
 384     DestName = getRegName(MI->getOperand(0).getReg());
 385     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
 386     break;
 387   case X86::PUNPCKLWDrr:
 388   case X86::VPUNPCKLWDrr:
 389     Src2Name = getRegName(MI->getOperand(2).getReg());
 390     // FALL THROUGH.
 391   case X86::PUNPCKLWDrm:
 392   case X86::VPUNPCKLWDrm:
 393     Src1Name = getRegName(MI->getOperand(1).getReg());
 394     DestName = getRegName(MI->getOperand(0).getReg());
 395     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
 396     break;
 397   case X86::VPUNPCKLWDYrr:
 398     Src2Name = getRegName(MI->getOperand(2).getReg());
 399     // FALL THROUGH.
 400   case X86::VPUNPCKLWDYrm:
 401     Src1Name = getRegName(MI->getOperand(1).getReg());
 402     DestName = getRegName(MI->getOperand(0).getReg());
 403     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
 404     break;
 405   case X86::PUNPCKLDQrr:
 406   case X86::VPUNPCKLDQrr:
 407     Src2Name = getRegName(MI->getOperand(2).getReg());
 408     // FALL THROUGH.
 409   case X86::PUNPCKLDQrm:
 410   case X86::VPUNPCKLDQrm:
 411     Src1Name = getRegName(MI->getOperand(1).getReg());
 412     DestName = getRegName(MI->getOperand(0).getReg());
 413     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
 414     break;
 415   case X86::VPUNPCKLDQYrr:
 416     Src2Name = getRegName(MI->getOperand(2).getReg());
 417     // FALL THROUGH.
 418   case X86::VPUNPCKLDQYrm:
 419     Src1Name = getRegName(MI->getOperand(1).getReg());
 420     DestName = getRegName(MI->getOperand(0).getReg());
 421     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
 422     break;
 423   case X86::PUNPCKLQDQrr:
 424   case X86::VPUNPCKLQDQrr:
 425     Src2Name = getRegName(MI->getOperand(2).getReg());
 426     // FALL THROUGH.
 427   case X86::PUNPCKLQDQrm:
 428   case X86::VPUNPCKLQDQrm:
 429     Src1Name = getRegName(MI->getOperand(1).getReg());
 430     DestName = getRegName(MI->getOperand(0).getReg());
 431     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
 432     break;
 433   case X86::VPUNPCKLQDQYrr:
 434     Src2Name = getRegName(MI->getOperand(2).getReg());
 435     // FALL THROUGH.
 436   case X86::VPUNPCKLQDQYrm:
 437     Src1Name = getRegName(MI->getOperand(1).getReg());
 438     DestName = getRegName(MI->getOperand(0).getReg());
 439     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
 440     break;
 441
 442   case X86::SHUFPDrri:
 443   case X86::VSHUFPDrri:
 444     Src2Name = getRegName(MI->getOperand(2).getReg());
 445     // FALL THROUGH.
 446   case X86::SHUFPDrmi:
 447   case X86::VSHUFPDrmi:
 448     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 449       DecodeSHUFPMask(MVT::v2f64,
 450                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 451                       ShuffleMask);
 452     Src1Name = getRegName(MI->getOperand(1).getReg());
 453     DestName = getRegName(MI->getOperand(0).getReg());
 454     break;
 455   case X86::VSHUFPDYrri:
 456     Src2Name = getRegName(MI->getOperand(2).getReg());
 457     // FALL THROUGH.
 458   case X86::VSHUFPDYrmi:
 459     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 460       DecodeSHUFPMask(MVT::v4f64,
 461                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 462                       ShuffleMask);
 463     Src1Name = getRegName(MI->getOperand(1).getReg());
 464     DestName = getRegName(MI->getOperand(0).getReg());
 465     break;
 466
 467   case X86::SHUFPSrri:
 468   case X86::VSHUFPSrri:
 469     Src2Name = getRegName(MI->getOperand(2).getReg());
 470     // FALL THROUGH.
 471   case X86::SHUFPSrmi:
 472   case X86::VSHUFPSrmi:
 473     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 474       DecodeSHUFPMask(MVT::v4f32,
 475                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 476                       ShuffleMask);
 477     Src1Name = getRegName(MI->getOperand(1).getReg());
 478     DestName = getRegName(MI->getOperand(0).getReg());
 479     break;
 480   case X86::VSHUFPSYrri:
 481     Src2Name = getRegName(MI->getOperand(2).getReg());
 482     // FALL THROUGH.
 483   case X86::VSHUFPSYrmi:
 484     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 485       DecodeSHUFPMask(MVT::v8f32,
 486                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 487                       ShuffleMask);
 488     Src1Name = getRegName(MI->getOperand(1).getReg());
 489     DestName = getRegName(MI->getOperand(0).getReg());
 490     break;
 491
 492   case X86::UNPCKLPDrr:
 493   case X86::VUNPCKLPDrr:
 494     Src2Name = getRegName(MI->getOperand(2).getReg());
 495     // FALL THROUGH.
 496   case X86::UNPCKLPDrm:
 497   case X86::VUNPCKLPDrm:
 498     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
 499     Src1Name = getRegName(MI->getOperand(1).getReg());
 500     DestName = getRegName(MI->getOperand(0).getReg());
 501     break;
 502   case X86::VUNPCKLPDYrr:
 503     Src2Name = getRegName(MI->getOperand(2).getReg());
 504     // FALL THROUGH.
 505   case X86::VUNPCKLPDYrm:
 506     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
 507     Src1Name = getRegName(MI->getOperand(1).getReg());
 508     DestName = getRegName(MI->getOperand(0).getReg());
 509     break;
 510   case X86::UNPCKLPSrr:
 511   case X86::VUNPCKLPSrr:
 512     Src2Name = getRegName(MI->getOperand(2).getReg());
 513     // FALL THROUGH.
 514   case X86::UNPCKLPSrm:
 515   case X86::VUNPCKLPSrm:
 516     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
 517     Src1Name = getRegName(MI->getOperand(1).getReg());
 518     DestName = getRegName(MI->getOperand(0).getReg());
 519     break;
 520   case X86::VUNPCKLPSYrr:
 521     Src2Name = getRegName(MI->getOperand(2).getReg());
 522     // FALL THROUGH.
 523   case X86::VUNPCKLPSYrm:
 524     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
 525     Src1Name = getRegName(MI->getOperand(1).getReg());
 526     DestName = getRegName(MI->getOperand(0).getReg());
 527     break;
 528   case X86::UNPCKHPDrr:
 529   case X86::VUNPCKHPDrr:
 530     Src2Name = getRegName(MI->getOperand(2).getReg());
 531     // FALL THROUGH.
 532   case X86::UNPCKHPDrm:
 533   case X86::VUNPCKHPDrm:
 534     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
 535     Src1Name = getRegName(MI->getOperand(1).getReg());
 536     DestName = getRegName(MI->getOperand(0).getReg());
 537     break;
 538   case X86::VUNPCKHPDYrr:
 539     Src2Name = getRegName(MI->getOperand(2).getReg());
 540     // FALL THROUGH.
 541   case X86::VUNPCKHPDYrm:
 542     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
 543     Src1Name = getRegName(MI->getOperand(1).getReg());
 544     DestName = getRegName(MI->getOperand(0).getReg());
 545     break;
 546   case X86::UNPCKHPSrr:
 547   case X86::VUNPCKHPSrr:
 548     Src2Name = getRegName(MI->getOperand(2).getReg());
 549     // FALL THROUGH.
 550   case X86::UNPCKHPSrm:
 551   case X86::VUNPCKHPSrm:
 552     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
 553     Src1Name = getRegName(MI->getOperand(1).getReg());
 554     DestName = getRegName(MI->getOperand(0).getReg());
 555     break;
 556   case X86::VUNPCKHPSYrr:
 557     Src2Name = getRegName(MI->getOperand(2).getReg());
 558     // FALL THROUGH.
 559   case X86::VUNPCKHPSYrm:
 560     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
 561     Src1Name = getRegName(MI->getOperand(1).getReg());
 562     DestName = getRegName(MI->getOperand(0).getReg());
 563     break;
 564   case X86::VPERMILPSri:
 565     Src1Name = getRegName(MI->getOperand(1).getReg());
 566     // FALL THROUGH.
 567   case X86::VPERMILPSmi:
 568     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 569       DecodePSHUFMask(MVT::v4f32,
 570                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 571                       ShuffleMask);
 572     DestName = getRegName(MI->getOperand(0).getReg());
 573     break;
 574   case X86::VPERMILPSYri:
 575     Src1Name = getRegName(MI->getOperand(1).getReg());
 576     // FALL THROUGH.
 577   case X86::VPERMILPSYmi:
 578     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 579       DecodePSHUFMask(MVT::v8f32,
 580                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 581                       ShuffleMask);
 582     DestName = getRegName(MI->getOperand(0).getReg());
 583     break;
 584   case X86::VPERMILPDri:
 585     Src1Name = getRegName(MI->getOperand(1).getReg());
 586     // FALL THROUGH.
 587   case X86::VPERMILPDmi:
 588     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 589       DecodePSHUFMask(MVT::v2f64,
 590                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 591                       ShuffleMask);
 592     DestName = getRegName(MI->getOperand(0).getReg());
 593     break;
 594   case X86::VPERMILPDYri:
 595     Src1Name = getRegName(MI->getOperand(1).getReg());
 596     // FALL THROUGH.
 597   case X86::VPERMILPDYmi:
 598     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 599       DecodePSHUFMask(MVT::v4f64,
 600                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 601                       ShuffleMask);
 602     DestName = getRegName(MI->getOperand(0).getReg());
 603     break;
 604   case X86::VPERM2F128rr:
 605   case X86::VPERM2I128rr:
 606     Src2Name = getRegName(MI->getOperand(2).getReg());
 607     // FALL THROUGH.
 608   case X86::VPERM2F128rm:
 609   case X86::VPERM2I128rm:
 610     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 611     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 612       DecodeVPERM2X128Mask(MVT::v4i64,
 613                            MI->getOperand(MI->getNumOperands()-1).getImm(),
 614                            ShuffleMask);
 615     Src1Name = getRegName(MI->getOperand(1).getReg());
 616     DestName = getRegName(MI->getOperand(0).getReg());
 617     break;
 618   case X86::VPERMQYri:
 619   case X86::VPERMPDYri:
 620     Src1Name = getRegName(MI->getOperand(1).getReg());
 621     // FALL THROUGH.
 622   case X86::VPERMQYmi:
 623   case X86::VPERMPDYmi:
 624     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 625       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 626                       ShuffleMask);
 627     DestName = getRegName(MI->getOperand(0).getReg());
 628     break;
 629   }
 630
 631   // The only comments we decode are shuffles, so give up if we were unable to
 632   // decode a shuffle mask.
 633   if (ShuffleMask.empty())
 634     return false;
 635
 636   if (!DestName) DestName = Src1Name;
 637   OS << (DestName ? DestName : "mem") << " = ";
 638
 639   // If the two sources are the same, canonicalize the input elements to be
 640   // from the first src so that we get larger element spans.
 641   if (Src1Name == Src2Name) {
 642     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 643       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 644           ShuffleMask[i] >= (int)e)        // From second mask.
 645         ShuffleMask[i] -= e;
 646     }
 647   }
 648
 649   // The shuffle mask specifies which elements of the src1/src2 fill in the
 650   // destination, with a few sentinel values.  Loop through and print them
 651   // out.
 652   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 653     if (i != 0)
 654       OS << ',';
 655     if (ShuffleMask[i] == SM_SentinelZero) {
 656       OS << "zero";
 657       continue;
 658     }
 659
 660     // Otherwise, it must come from src1 or src2.  Print the span of elements
 661     // that comes from this src.
 662     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
 663     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 664     OS << (SrcName ? SrcName : "mem") << '[';
 665     bool IsFirst = true;
 666     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
 667            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
 668       if (!IsFirst)
 669         OS << ',';
 670       else
 671         IsFirst = false;
 672       if (ShuffleMask[i] == SM_SentinelUndef)
 673         OS << "u";
 674       else
 675         OS << ShuffleMask[i] % ShuffleMask.size();
 676       ++i;
 677     }
 678     OS << ']';
 679     --i;  // For loop increments element #.
 680   }
 681   //MI->print(OS, 0);
 682   OS << "\n";
 683
 684   // We successfully added a comment to this instruction.
 685   return true;
 686 }