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