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