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::PSLLDQri:
 203   case X86::VPSLLDQri:
 204     Src1Name = getRegName(MI->getOperand(1).getReg());
 205     DestName = getRegName(MI->getOperand(0).getReg());
 206     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 207       DecodePSLLDQMask(MVT::v16i8,
 208                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 209                        ShuffleMask);
 210     break;
 211
 212   case X86::VPSLLDQYri:
 213     Src1Name = getRegName(MI->getOperand(1).getReg());
 214     DestName = getRegName(MI->getOperand(0).getReg());
 215     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 216       DecodePSLLDQMask(MVT::v32i8,
 217                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 218                        ShuffleMask);
 219     break;
 220
 221   case X86::PSRLDQri:
 222   case X86::VPSRLDQri:
 223     Src1Name = getRegName(MI->getOperand(1).getReg());
 224     DestName = getRegName(MI->getOperand(0).getReg());
 225     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 226       DecodePSRLDQMask(MVT::v16i8,
 227                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 228                        ShuffleMask);
 229     break;
 230
 231   case X86::VPSRLDQYri:
 232     Src1Name = getRegName(MI->getOperand(1).getReg());
 233     DestName = getRegName(MI->getOperand(0).getReg());
 234     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 235       DecodePSRLDQMask(MVT::v32i8,
 236                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 237                        ShuffleMask);
 238     break;
 239
 240   case X86::PALIGNR128rr:
 241   case X86::VPALIGNR128rr:
 242     Src1Name = getRegName(MI->getOperand(2).getReg());
 243     // FALL THROUGH.
 244   case X86::PALIGNR128rm:
 245   case X86::VPALIGNR128rm:
 246     Src2Name = getRegName(MI->getOperand(1).getReg());
 247     DestName = getRegName(MI->getOperand(0).getReg());
 248     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 249       DecodePALIGNRMask(MVT::v16i8,
 250                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 251                         ShuffleMask);
 252     break;
 253   case X86::VPALIGNR256rr:
 254     Src1Name = getRegName(MI->getOperand(2).getReg());
 255     // FALL THROUGH.
 256   case X86::VPALIGNR256rm:
 257     Src2Name = getRegName(MI->getOperand(1).getReg());
 258     DestName = getRegName(MI->getOperand(0).getReg());
 259     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 260       DecodePALIGNRMask(MVT::v32i8,
 261                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 262                         ShuffleMask);
 263     break;
 264
 265   case X86::PSHUFDri:
 266   case X86::VPSHUFDri:
 267     Src1Name = getRegName(MI->getOperand(1).getReg());
 268     // FALL THROUGH.
 269   case X86::PSHUFDmi:
 270   case X86::VPSHUFDmi:
 271     DestName = getRegName(MI->getOperand(0).getReg());
 272     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 273       DecodePSHUFMask(MVT::v4i32,
 274                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 275                       ShuffleMask);
 276     break;
 277   case X86::VPSHUFDYri:
 278     Src1Name = getRegName(MI->getOperand(1).getReg());
 279     // FALL THROUGH.
 280   case X86::VPSHUFDYmi:
 281     DestName = getRegName(MI->getOperand(0).getReg());
 282     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 283       DecodePSHUFMask(MVT::v8i32,
 284                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 285                       ShuffleMask);
 286     break;
 287
 288
 289   case X86::PSHUFHWri:
 290   case X86::VPSHUFHWri:
 291     Src1Name = getRegName(MI->getOperand(1).getReg());
 292     // FALL THROUGH.
 293   case X86::PSHUFHWmi:
 294   case X86::VPSHUFHWmi:
 295     DestName = getRegName(MI->getOperand(0).getReg());
 296     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 297       DecodePSHUFHWMask(MVT::v8i16,
 298                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 299                         ShuffleMask);
 300     break;
 301   case X86::VPSHUFHWYri:
 302     Src1Name = getRegName(MI->getOperand(1).getReg());
 303     // FALL THROUGH.
 304   case X86::VPSHUFHWYmi:
 305     DestName = getRegName(MI->getOperand(0).getReg());
 306     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 307       DecodePSHUFHWMask(MVT::v16i16,
 308                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 309                         ShuffleMask);
 310     break;
 311   case X86::PSHUFLWri:
 312   case X86::VPSHUFLWri:
 313     Src1Name = getRegName(MI->getOperand(1).getReg());
 314     // FALL THROUGH.
 315   case X86::PSHUFLWmi:
 316   case X86::VPSHUFLWmi:
 317     DestName = getRegName(MI->getOperand(0).getReg());
 318     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 319       DecodePSHUFLWMask(MVT::v8i16,
 320                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 321                         ShuffleMask);
 322     break;
 323   case X86::VPSHUFLWYri:
 324     Src1Name = getRegName(MI->getOperand(1).getReg());
 325     // FALL THROUGH.
 326   case X86::VPSHUFLWYmi:
 327     DestName = getRegName(MI->getOperand(0).getReg());
 328     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 329       DecodePSHUFLWMask(MVT::v16i16,
 330                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 331                         ShuffleMask);
 332     break;
 333
 334   case X86::PUNPCKHBWrr:
 335   case X86::VPUNPCKHBWrr:
 336     Src2Name = getRegName(MI->getOperand(2).getReg());
 337     // FALL THROUGH.
 338   case X86::PUNPCKHBWrm:
 339   case X86::VPUNPCKHBWrm:
 340     Src1Name = getRegName(MI->getOperand(1).getReg());
 341     DestName = getRegName(MI->getOperand(0).getReg());
 342     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
 343     break;
 344   case X86::VPUNPCKHBWYrr:
 345     Src2Name = getRegName(MI->getOperand(2).getReg());
 346     // FALL THROUGH.
 347   case X86::VPUNPCKHBWYrm:
 348     Src1Name = getRegName(MI->getOperand(1).getReg());
 349     DestName = getRegName(MI->getOperand(0).getReg());
 350     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
 351     break;
 352   case X86::PUNPCKHWDrr:
 353   case X86::VPUNPCKHWDrr:
 354     Src2Name = getRegName(MI->getOperand(2).getReg());
 355     // FALL THROUGH.
 356   case X86::PUNPCKHWDrm:
 357   case X86::VPUNPCKHWDrm:
 358     Src1Name = getRegName(MI->getOperand(1).getReg());
 359     DestName = getRegName(MI->getOperand(0).getReg());
 360     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
 361     break;
 362   case X86::VPUNPCKHWDYrr:
 363     Src2Name = getRegName(MI->getOperand(2).getReg());
 364     // FALL THROUGH.
 365   case X86::VPUNPCKHWDYrm:
 366     Src1Name = getRegName(MI->getOperand(1).getReg());
 367     DestName = getRegName(MI->getOperand(0).getReg());
 368     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
 369     break;
 370   case X86::PUNPCKHDQrr:
 371   case X86::VPUNPCKHDQrr:
 372     Src2Name = getRegName(MI->getOperand(2).getReg());
 373     // FALL THROUGH.
 374   case X86::PUNPCKHDQrm:
 375   case X86::VPUNPCKHDQrm:
 376     Src1Name = getRegName(MI->getOperand(1).getReg());
 377     DestName = getRegName(MI->getOperand(0).getReg());
 378     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
 379     break;
 380   case X86::VPUNPCKHDQYrr:
 381     Src2Name = getRegName(MI->getOperand(2).getReg());
 382     // FALL THROUGH.
 383   case X86::VPUNPCKHDQYrm:
 384     Src1Name = getRegName(MI->getOperand(1).getReg());
 385     DestName = getRegName(MI->getOperand(0).getReg());
 386     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
 387     break;
 388   case X86::PUNPCKHQDQrr:
 389   case X86::VPUNPCKHQDQrr:
 390     Src2Name = getRegName(MI->getOperand(2).getReg());
 391     // FALL THROUGH.
 392   case X86::PUNPCKHQDQrm:
 393   case X86::VPUNPCKHQDQrm:
 394     Src1Name = getRegName(MI->getOperand(1).getReg());
 395     DestName = getRegName(MI->getOperand(0).getReg());
 396     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
 397     break;
 398   case X86::VPUNPCKHQDQYrr:
 399     Src2Name = getRegName(MI->getOperand(2).getReg());
 400     // FALL THROUGH.
 401   case X86::VPUNPCKHQDQYrm:
 402     Src1Name = getRegName(MI->getOperand(1).getReg());
 403     DestName = getRegName(MI->getOperand(0).getReg());
 404     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
 405     break;
 406
 407   case X86::PUNPCKLBWrr:
 408   case X86::VPUNPCKLBWrr:
 409     Src2Name = getRegName(MI->getOperand(2).getReg());
 410     // FALL THROUGH.
 411   case X86::PUNPCKLBWrm:
 412   case X86::VPUNPCKLBWrm:
 413     Src1Name = getRegName(MI->getOperand(1).getReg());
 414     DestName = getRegName(MI->getOperand(0).getReg());
 415     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
 416     break;
 417   case X86::VPUNPCKLBWYrr:
 418     Src2Name = getRegName(MI->getOperand(2).getReg());
 419     // FALL THROUGH.
 420   case X86::VPUNPCKLBWYrm:
 421     Src1Name = getRegName(MI->getOperand(1).getReg());
 422     DestName = getRegName(MI->getOperand(0).getReg());
 423     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
 424     break;
 425   case X86::PUNPCKLWDrr:
 426   case X86::VPUNPCKLWDrr:
 427     Src2Name = getRegName(MI->getOperand(2).getReg());
 428     // FALL THROUGH.
 429   case X86::PUNPCKLWDrm:
 430   case X86::VPUNPCKLWDrm:
 431     Src1Name = getRegName(MI->getOperand(1).getReg());
 432     DestName = getRegName(MI->getOperand(0).getReg());
 433     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
 434     break;
 435   case X86::VPUNPCKLWDYrr:
 436     Src2Name = getRegName(MI->getOperand(2).getReg());
 437     // FALL THROUGH.
 438   case X86::VPUNPCKLWDYrm:
 439     Src1Name = getRegName(MI->getOperand(1).getReg());
 440     DestName = getRegName(MI->getOperand(0).getReg());
 441     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
 442     break;
 443   case X86::PUNPCKLDQrr:
 444   case X86::VPUNPCKLDQrr:
 445     Src2Name = getRegName(MI->getOperand(2).getReg());
 446     // FALL THROUGH.
 447   case X86::PUNPCKLDQrm:
 448   case X86::VPUNPCKLDQrm:
 449     Src1Name = getRegName(MI->getOperand(1).getReg());
 450     DestName = getRegName(MI->getOperand(0).getReg());
 451     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
 452     break;
 453   case X86::VPUNPCKLDQYrr:
 454     Src2Name = getRegName(MI->getOperand(2).getReg());
 455     // FALL THROUGH.
 456   case X86::VPUNPCKLDQYrm:
 457     Src1Name = getRegName(MI->getOperand(1).getReg());
 458     DestName = getRegName(MI->getOperand(0).getReg());
 459     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
 460     break;
 461   case X86::PUNPCKLQDQrr:
 462   case X86::VPUNPCKLQDQrr:
 463     Src2Name = getRegName(MI->getOperand(2).getReg());
 464     // FALL THROUGH.
 465   case X86::PUNPCKLQDQrm:
 466   case X86::VPUNPCKLQDQrm:
 467     Src1Name = getRegName(MI->getOperand(1).getReg());
 468     DestName = getRegName(MI->getOperand(0).getReg());
 469     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
 470     break;
 471   case X86::VPUNPCKLQDQYrr:
 472     Src2Name = getRegName(MI->getOperand(2).getReg());
 473     // FALL THROUGH.
 474   case X86::VPUNPCKLQDQYrm:
 475     Src1Name = getRegName(MI->getOperand(1).getReg());
 476     DestName = getRegName(MI->getOperand(0).getReg());
 477     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
 478     break;
 479
 480   case X86::SHUFPDrri:
 481   case X86::VSHUFPDrri:
 482     Src2Name = getRegName(MI->getOperand(2).getReg());
 483     // FALL THROUGH.
 484   case X86::SHUFPDrmi:
 485   case X86::VSHUFPDrmi:
 486     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 487       DecodeSHUFPMask(MVT::v2f64,
 488                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 489                       ShuffleMask);
 490     Src1Name = getRegName(MI->getOperand(1).getReg());
 491     DestName = getRegName(MI->getOperand(0).getReg());
 492     break;
 493   case X86::VSHUFPDYrri:
 494     Src2Name = getRegName(MI->getOperand(2).getReg());
 495     // FALL THROUGH.
 496   case X86::VSHUFPDYrmi:
 497     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 498       DecodeSHUFPMask(MVT::v4f64,
 499                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 500                       ShuffleMask);
 501     Src1Name = getRegName(MI->getOperand(1).getReg());
 502     DestName = getRegName(MI->getOperand(0).getReg());
 503     break;
 504
 505   case X86::SHUFPSrri:
 506   case X86::VSHUFPSrri:
 507     Src2Name = getRegName(MI->getOperand(2).getReg());
 508     // FALL THROUGH.
 509   case X86::SHUFPSrmi:
 510   case X86::VSHUFPSrmi:
 511     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 512       DecodeSHUFPMask(MVT::v4f32,
 513                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 514                       ShuffleMask);
 515     Src1Name = getRegName(MI->getOperand(1).getReg());
 516     DestName = getRegName(MI->getOperand(0).getReg());
 517     break;
 518   case X86::VSHUFPSYrri:
 519     Src2Name = getRegName(MI->getOperand(2).getReg());
 520     // FALL THROUGH.
 521   case X86::VSHUFPSYrmi:
 522     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 523       DecodeSHUFPMask(MVT::v8f32,
 524                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 525                       ShuffleMask);
 526     Src1Name = getRegName(MI->getOperand(1).getReg());
 527     DestName = getRegName(MI->getOperand(0).getReg());
 528     break;
 529
 530   case X86::UNPCKLPDrr:
 531   case X86::VUNPCKLPDrr:
 532     Src2Name = getRegName(MI->getOperand(2).getReg());
 533     // FALL THROUGH.
 534   case X86::UNPCKLPDrm:
 535   case X86::VUNPCKLPDrm:
 536     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
 537     Src1Name = getRegName(MI->getOperand(1).getReg());
 538     DestName = getRegName(MI->getOperand(0).getReg());
 539     break;
 540   case X86::VUNPCKLPDYrr:
 541     Src2Name = getRegName(MI->getOperand(2).getReg());
 542     // FALL THROUGH.
 543   case X86::VUNPCKLPDYrm:
 544     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
 545     Src1Name = getRegName(MI->getOperand(1).getReg());
 546     DestName = getRegName(MI->getOperand(0).getReg());
 547     break;
 548   case X86::UNPCKLPSrr:
 549   case X86::VUNPCKLPSrr:
 550     Src2Name = getRegName(MI->getOperand(2).getReg());
 551     // FALL THROUGH.
 552   case X86::UNPCKLPSrm:
 553   case X86::VUNPCKLPSrm:
 554     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
 555     Src1Name = getRegName(MI->getOperand(1).getReg());
 556     DestName = getRegName(MI->getOperand(0).getReg());
 557     break;
 558   case X86::VUNPCKLPSYrr:
 559     Src2Name = getRegName(MI->getOperand(2).getReg());
 560     // FALL THROUGH.
 561   case X86::VUNPCKLPSYrm:
 562     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
 563     Src1Name = getRegName(MI->getOperand(1).getReg());
 564     DestName = getRegName(MI->getOperand(0).getReg());
 565     break;
 566   case X86::UNPCKHPDrr:
 567   case X86::VUNPCKHPDrr:
 568     Src2Name = getRegName(MI->getOperand(2).getReg());
 569     // FALL THROUGH.
 570   case X86::UNPCKHPDrm:
 571   case X86::VUNPCKHPDrm:
 572     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
 573     Src1Name = getRegName(MI->getOperand(1).getReg());
 574     DestName = getRegName(MI->getOperand(0).getReg());
 575     break;
 576   case X86::VUNPCKHPDYrr:
 577     Src2Name = getRegName(MI->getOperand(2).getReg());
 578     // FALL THROUGH.
 579   case X86::VUNPCKHPDYrm:
 580     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
 581     Src1Name = getRegName(MI->getOperand(1).getReg());
 582     DestName = getRegName(MI->getOperand(0).getReg());
 583     break;
 584   case X86::UNPCKHPSrr:
 585   case X86::VUNPCKHPSrr:
 586     Src2Name = getRegName(MI->getOperand(2).getReg());
 587     // FALL THROUGH.
 588   case X86::UNPCKHPSrm:
 589   case X86::VUNPCKHPSrm:
 590     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
 591     Src1Name = getRegName(MI->getOperand(1).getReg());
 592     DestName = getRegName(MI->getOperand(0).getReg());
 593     break;
 594   case X86::VUNPCKHPSYrr:
 595     Src2Name = getRegName(MI->getOperand(2).getReg());
 596     // FALL THROUGH.
 597   case X86::VUNPCKHPSYrm:
 598     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
 599     Src1Name = getRegName(MI->getOperand(1).getReg());
 600     DestName = getRegName(MI->getOperand(0).getReg());
 601     break;
 602   case X86::VPERMILPSri:
 603     Src1Name = getRegName(MI->getOperand(1).getReg());
 604     // FALL THROUGH.
 605   case X86::VPERMILPSmi:
 606     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 607       DecodePSHUFMask(MVT::v4f32,
 608                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 609                       ShuffleMask);
 610     DestName = getRegName(MI->getOperand(0).getReg());
 611     break;
 612   case X86::VPERMILPSYri:
 613     Src1Name = getRegName(MI->getOperand(1).getReg());
 614     // FALL THROUGH.
 615   case X86::VPERMILPSYmi:
 616     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 617       DecodePSHUFMask(MVT::v8f32,
 618                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 619                       ShuffleMask);
 620     DestName = getRegName(MI->getOperand(0).getReg());
 621     break;
 622   case X86::VPERMILPDri:
 623     Src1Name = getRegName(MI->getOperand(1).getReg());
 624     // FALL THROUGH.
 625   case X86::VPERMILPDmi:
 626     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 627       DecodePSHUFMask(MVT::v2f64,
 628                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 629                       ShuffleMask);
 630     DestName = getRegName(MI->getOperand(0).getReg());
 631     break;
 632   case X86::VPERMILPDYri:
 633     Src1Name = getRegName(MI->getOperand(1).getReg());
 634     // FALL THROUGH.
 635   case X86::VPERMILPDYmi:
 636     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 637       DecodePSHUFMask(MVT::v4f64,
 638                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 639                       ShuffleMask);
 640     DestName = getRegName(MI->getOperand(0).getReg());
 641     break;
 642   case X86::VPERM2F128rr:
 643   case X86::VPERM2I128rr:
 644     Src2Name = getRegName(MI->getOperand(2).getReg());
 645     // FALL THROUGH.
 646   case X86::VPERM2F128rm:
 647   case X86::VPERM2I128rm:
 648     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 649     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 650       DecodeVPERM2X128Mask(MVT::v4i64,
 651                            MI->getOperand(MI->getNumOperands()-1).getImm(),
 652                            ShuffleMask);
 653     Src1Name = getRegName(MI->getOperand(1).getReg());
 654     DestName = getRegName(MI->getOperand(0).getReg());
 655     break;
 656   case X86::VPERMQYri:
 657   case X86::VPERMPDYri:
 658     Src1Name = getRegName(MI->getOperand(1).getReg());
 659     // FALL THROUGH.
 660   case X86::VPERMQYmi:
 661   case X86::VPERMPDYmi:
 662     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 663       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 664                       ShuffleMask);
 665     DestName = getRegName(MI->getOperand(0).getReg());
 666     break;
 667   }
 668
 669   // The only comments we decode are shuffles, so give up if we were unable to
 670   // decode a shuffle mask.
 671   if (ShuffleMask.empty())
 672     return false;
 673
 674   if (!DestName) DestName = Src1Name;
 675   OS << (DestName ? DestName : "mem") << " = ";
 676
 677   // If the two sources are the same, canonicalize the input elements to be
 678   // from the first src so that we get larger element spans.
 679   if (Src1Name == Src2Name) {
 680     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 681       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 682           ShuffleMask[i] >= (int)e)        // From second mask.
 683         ShuffleMask[i] -= e;
 684     }
 685   }
 686
 687   // The shuffle mask specifies which elements of the src1/src2 fill in the
 688   // destination, with a few sentinel values.  Loop through and print them
 689   // out.
 690   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 691     if (i != 0)
 692       OS << ',';
 693     if (ShuffleMask[i] == SM_SentinelZero) {
 694       OS << "zero";
 695       continue;
 696     }
 697
 698     // Otherwise, it must come from src1 or src2.  Print the span of elements
 699     // that comes from this src.
 700     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
 701     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 702     OS << (SrcName ? SrcName : "mem") << '[';
 703     bool IsFirst = true;
 704     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
 705            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
 706       if (!IsFirst)
 707         OS << ',';
 708       else
 709         IsFirst = false;
 710       if (ShuffleMask[i] == SM_SentinelUndef)
 711         OS << "u";
 712       else
 713         OS << ShuffleMask[i] % ShuffleMask.size();
 714       ++i;
 715     }
 716     OS << ']';
 717     --i;  // For loop increments element #.
 718   }
 719   //MI->print(OS, 0);
 720   OS << "\n";
 721
 722   // We successfully added a comment to this instruction.
 723   return true;
 724 }