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/Support/raw_ostream.h"
  20 using namespace llvm;
  21
  22 //===----------------------------------------------------------------------===//
  23 // Top Level Entrypoint
  24 //===----------------------------------------------------------------------===//
  25
  26 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints
  27 /// newline terminated strings to the specified string if desired.  This
  28 /// information is shown in disassembly dumps when verbose assembly is enabled.
  29 void llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
  30                                   const char *(*getRegName)(unsigned)) {
  31   // If this is a shuffle operation, the switch should fill in this state.
  32   SmallVector<int, 8> ShuffleMask;
  33   const char *DestName = 0, *Src1Name = 0, *Src2Name = 0;
  34
  35   switch (MI->getOpcode()) {
  36   case X86::INSERTPSrr:
  37   case X86::VINSERTPSrr:
  38     DestName = getRegName(MI->getOperand(0).getReg());
  39     Src1Name = getRegName(MI->getOperand(1).getReg());
  40     Src2Name = getRegName(MI->getOperand(2).getReg());
  41     if(MI->getOperand(3).isImm())
  42       DecodeINSERTPSMask(MI->getOperand(3).getImm(), ShuffleMask);
  43     break;
  44
  45   case X86::MOVLHPSrr:
  46   case X86::VMOVLHPSrr:
  47     Src2Name = getRegName(MI->getOperand(2).getReg());
  48     Src1Name = getRegName(MI->getOperand(1).getReg());
  49     DestName = getRegName(MI->getOperand(0).getReg());
  50     DecodeMOVLHPSMask(2, ShuffleMask);
  51     break;
  52
  53   case X86::MOVHLPSrr:
  54   case X86::VMOVHLPSrr:
  55     Src2Name = getRegName(MI->getOperand(2).getReg());
  56     Src1Name = getRegName(MI->getOperand(1).getReg());
  57     DestName = getRegName(MI->getOperand(0).getReg());
  58     DecodeMOVHLPSMask(2, ShuffleMask);
  59     break;
  60
  61   case X86::PALIGNR128rr:
  62   case X86::VPALIGNR128rr:
  63     Src1Name = getRegName(MI->getOperand(2).getReg());
  64     // FALL THROUGH.
  65   case X86::PALIGNR128rm:
  66   case X86::VPALIGNR128rm:
  67     Src2Name = getRegName(MI->getOperand(1).getReg());
  68     DestName = getRegName(MI->getOperand(0).getReg());
  69     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  70       DecodePALIGNRMask(MVT::v16i8,
  71                         MI->getOperand(MI->getNumOperands()-1).getImm(),
  72                         ShuffleMask);
  73     break;
  74   case X86::VPALIGNR256rr:
  75     Src1Name = getRegName(MI->getOperand(2).getReg());
  76     // FALL THROUGH.
  77   case X86::VPALIGNR256rm:
  78     Src2Name = getRegName(MI->getOperand(1).getReg());
  79     DestName = getRegName(MI->getOperand(0).getReg());
  80     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  81       DecodePALIGNRMask(MVT::v32i8,
  82                         MI->getOperand(MI->getNumOperands()-1).getImm(),
  83                         ShuffleMask);
  84     break;
  85
  86   case X86::PSHUFDri:
  87   case X86::VPSHUFDri:
  88     Src1Name = getRegName(MI->getOperand(1).getReg());
  89     // FALL THROUGH.
  90   case X86::PSHUFDmi:
  91   case X86::VPSHUFDmi:
  92     DestName = getRegName(MI->getOperand(0).getReg());
  93     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  94       DecodePSHUFMask(MVT::v4i32,
  95                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  96                       ShuffleMask);
  97     break;
  98   case X86::VPSHUFDYri:
  99     Src1Name = getRegName(MI->getOperand(1).getReg());
 100     // FALL THROUGH.
 101   case X86::VPSHUFDYmi:
 102     DestName = getRegName(MI->getOperand(0).getReg());
 103     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 104       DecodePSHUFMask(MVT::v8i32,
 105                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 106                       ShuffleMask);
 107     break;
 108
 109
 110   case X86::PSHUFHWri:
 111   case X86::VPSHUFHWri:
 112     Src1Name = getRegName(MI->getOperand(1).getReg());
 113     // FALL THROUGH.
 114   case X86::PSHUFHWmi:
 115   case X86::VPSHUFHWmi:
 116     DestName = getRegName(MI->getOperand(0).getReg());
 117     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 118       DecodePSHUFHWMask(MVT::v8i16,
 119                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 120                         ShuffleMask);
 121     break;
 122   case X86::VPSHUFHWYri:
 123     Src1Name = getRegName(MI->getOperand(1).getReg());
 124     // FALL THROUGH.
 125   case X86::VPSHUFHWYmi:
 126     DestName = getRegName(MI->getOperand(0).getReg());
 127     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 128       DecodePSHUFHWMask(MVT::v16i16,
 129                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 130                         ShuffleMask);
 131     break;
 132   case X86::PSHUFLWri:
 133   case X86::VPSHUFLWri:
 134     Src1Name = getRegName(MI->getOperand(1).getReg());
 135     // FALL THROUGH.
 136   case X86::PSHUFLWmi:
 137   case X86::VPSHUFLWmi:
 138     DestName = getRegName(MI->getOperand(0).getReg());
 139     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 140       DecodePSHUFLWMask(MVT::v8i16,
 141                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 142                         ShuffleMask);
 143     break;
 144   case X86::VPSHUFLWYri:
 145     Src1Name = getRegName(MI->getOperand(1).getReg());
 146     // FALL THROUGH.
 147   case X86::VPSHUFLWYmi:
 148     DestName = getRegName(MI->getOperand(0).getReg());
 149     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 150       DecodePSHUFLWMask(MVT::v16i16,
 151                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 152                         ShuffleMask);
 153     break;
 154
 155   case X86::PUNPCKHBWrr:
 156   case X86::VPUNPCKHBWrr:
 157     Src2Name = getRegName(MI->getOperand(2).getReg());
 158     // FALL THROUGH.
 159   case X86::PUNPCKHBWrm:
 160   case X86::VPUNPCKHBWrm:
 161     Src1Name = getRegName(MI->getOperand(1).getReg());
 162     DestName = getRegName(MI->getOperand(0).getReg());
 163     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
 164     break;
 165   case X86::VPUNPCKHBWYrr:
 166     Src2Name = getRegName(MI->getOperand(2).getReg());
 167     // FALL THROUGH.
 168   case X86::VPUNPCKHBWYrm:
 169     Src1Name = getRegName(MI->getOperand(1).getReg());
 170     DestName = getRegName(MI->getOperand(0).getReg());
 171     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
 172     break;
 173   case X86::PUNPCKHWDrr:
 174   case X86::VPUNPCKHWDrr:
 175     Src2Name = getRegName(MI->getOperand(2).getReg());
 176     // FALL THROUGH.
 177   case X86::PUNPCKHWDrm:
 178   case X86::VPUNPCKHWDrm:
 179     Src1Name = getRegName(MI->getOperand(1).getReg());
 180     DestName = getRegName(MI->getOperand(0).getReg());
 181     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
 182     break;
 183   case X86::VPUNPCKHWDYrr:
 184     Src2Name = getRegName(MI->getOperand(2).getReg());
 185     // FALL THROUGH.
 186   case X86::VPUNPCKHWDYrm:
 187     Src1Name = getRegName(MI->getOperand(1).getReg());
 188     DestName = getRegName(MI->getOperand(0).getReg());
 189     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
 190     break;
 191   case X86::PUNPCKHDQrr:
 192   case X86::VPUNPCKHDQrr:
 193     Src2Name = getRegName(MI->getOperand(2).getReg());
 194     // FALL THROUGH.
 195   case X86::PUNPCKHDQrm:
 196   case X86::VPUNPCKHDQrm:
 197     Src1Name = getRegName(MI->getOperand(1).getReg());
 198     DestName = getRegName(MI->getOperand(0).getReg());
 199     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
 200     break;
 201   case X86::VPUNPCKHDQYrr:
 202     Src2Name = getRegName(MI->getOperand(2).getReg());
 203     // FALL THROUGH.
 204   case X86::VPUNPCKHDQYrm:
 205     Src1Name = getRegName(MI->getOperand(1).getReg());
 206     DestName = getRegName(MI->getOperand(0).getReg());
 207     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
 208     break;
 209   case X86::PUNPCKHQDQrr:
 210   case X86::VPUNPCKHQDQrr:
 211     Src2Name = getRegName(MI->getOperand(2).getReg());
 212     // FALL THROUGH.
 213   case X86::PUNPCKHQDQrm:
 214   case X86::VPUNPCKHQDQrm:
 215     Src1Name = getRegName(MI->getOperand(1).getReg());
 216     DestName = getRegName(MI->getOperand(0).getReg());
 217     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
 218     break;
 219   case X86::VPUNPCKHQDQYrr:
 220     Src2Name = getRegName(MI->getOperand(2).getReg());
 221     // FALL THROUGH.
 222   case X86::VPUNPCKHQDQYrm:
 223     Src1Name = getRegName(MI->getOperand(1).getReg());
 224     DestName = getRegName(MI->getOperand(0).getReg());
 225     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
 226     break;
 227
 228   case X86::PUNPCKLBWrr:
 229   case X86::VPUNPCKLBWrr:
 230     Src2Name = getRegName(MI->getOperand(2).getReg());
 231     // FALL THROUGH.
 232   case X86::PUNPCKLBWrm:
 233   case X86::VPUNPCKLBWrm:
 234     Src1Name = getRegName(MI->getOperand(1).getReg());
 235     DestName = getRegName(MI->getOperand(0).getReg());
 236     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
 237     break;
 238   case X86::VPUNPCKLBWYrr:
 239     Src2Name = getRegName(MI->getOperand(2).getReg());
 240     // FALL THROUGH.
 241   case X86::VPUNPCKLBWYrm:
 242     Src1Name = getRegName(MI->getOperand(1).getReg());
 243     DestName = getRegName(MI->getOperand(0).getReg());
 244     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
 245     break;
 246   case X86::PUNPCKLWDrr:
 247   case X86::VPUNPCKLWDrr:
 248     Src2Name = getRegName(MI->getOperand(2).getReg());
 249     // FALL THROUGH.
 250   case X86::PUNPCKLWDrm:
 251   case X86::VPUNPCKLWDrm:
 252     Src1Name = getRegName(MI->getOperand(1).getReg());
 253     DestName = getRegName(MI->getOperand(0).getReg());
 254     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
 255     break;
 256   case X86::VPUNPCKLWDYrr:
 257     Src2Name = getRegName(MI->getOperand(2).getReg());
 258     // FALL THROUGH.
 259   case X86::VPUNPCKLWDYrm:
 260     Src1Name = getRegName(MI->getOperand(1).getReg());
 261     DestName = getRegName(MI->getOperand(0).getReg());
 262     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
 263     break;
 264   case X86::PUNPCKLDQrr:
 265   case X86::VPUNPCKLDQrr:
 266     Src2Name = getRegName(MI->getOperand(2).getReg());
 267     // FALL THROUGH.
 268   case X86::PUNPCKLDQrm:
 269   case X86::VPUNPCKLDQrm:
 270     Src1Name = getRegName(MI->getOperand(1).getReg());
 271     DestName = getRegName(MI->getOperand(0).getReg());
 272     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
 273     break;
 274   case X86::VPUNPCKLDQYrr:
 275     Src2Name = getRegName(MI->getOperand(2).getReg());
 276     // FALL THROUGH.
 277   case X86::VPUNPCKLDQYrm:
 278     Src1Name = getRegName(MI->getOperand(1).getReg());
 279     DestName = getRegName(MI->getOperand(0).getReg());
 280     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
 281     break;
 282   case X86::PUNPCKLQDQrr:
 283   case X86::VPUNPCKLQDQrr:
 284     Src2Name = getRegName(MI->getOperand(2).getReg());
 285     // FALL THROUGH.
 286   case X86::PUNPCKLQDQrm:
 287   case X86::VPUNPCKLQDQrm:
 288     Src1Name = getRegName(MI->getOperand(1).getReg());
 289     DestName = getRegName(MI->getOperand(0).getReg());
 290     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
 291     break;
 292   case X86::VPUNPCKLQDQYrr:
 293     Src2Name = getRegName(MI->getOperand(2).getReg());
 294     // FALL THROUGH.
 295   case X86::VPUNPCKLQDQYrm:
 296     Src1Name = getRegName(MI->getOperand(1).getReg());
 297     DestName = getRegName(MI->getOperand(0).getReg());
 298     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
 299     break;
 300
 301   case X86::SHUFPDrri:
 302   case X86::VSHUFPDrri:
 303     Src2Name = getRegName(MI->getOperand(2).getReg());
 304     // FALL THROUGH.
 305   case X86::SHUFPDrmi:
 306   case X86::VSHUFPDrmi:
 307     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 308       DecodeSHUFPMask(MVT::v2f64,
 309                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 310                       ShuffleMask);
 311     Src1Name = getRegName(MI->getOperand(1).getReg());
 312     DestName = getRegName(MI->getOperand(0).getReg());
 313     break;
 314   case X86::VSHUFPDYrri:
 315     Src2Name = getRegName(MI->getOperand(2).getReg());
 316     // FALL THROUGH.
 317   case X86::VSHUFPDYrmi:
 318     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 319       DecodeSHUFPMask(MVT::v4f64,
 320                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 321                       ShuffleMask);
 322     Src1Name = getRegName(MI->getOperand(1).getReg());
 323     DestName = getRegName(MI->getOperand(0).getReg());
 324     break;
 325
 326   case X86::SHUFPSrri:
 327   case X86::VSHUFPSrri:
 328     Src2Name = getRegName(MI->getOperand(2).getReg());
 329     // FALL THROUGH.
 330   case X86::SHUFPSrmi:
 331   case X86::VSHUFPSrmi:
 332     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 333       DecodeSHUFPMask(MVT::v4f32,
 334                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 335                       ShuffleMask);
 336     Src1Name = getRegName(MI->getOperand(1).getReg());
 337     DestName = getRegName(MI->getOperand(0).getReg());
 338     break;
 339   case X86::VSHUFPSYrri:
 340     Src2Name = getRegName(MI->getOperand(2).getReg());
 341     // FALL THROUGH.
 342   case X86::VSHUFPSYrmi:
 343     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 344       DecodeSHUFPMask(MVT::v8f32,
 345                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 346                       ShuffleMask);
 347     Src1Name = getRegName(MI->getOperand(1).getReg());
 348     DestName = getRegName(MI->getOperand(0).getReg());
 349     break;
 350
 351   case X86::UNPCKLPDrr:
 352   case X86::VUNPCKLPDrr:
 353     Src2Name = getRegName(MI->getOperand(2).getReg());
 354     // FALL THROUGH.
 355   case X86::UNPCKLPDrm:
 356   case X86::VUNPCKLPDrm:
 357     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
 358     Src1Name = getRegName(MI->getOperand(1).getReg());
 359     DestName = getRegName(MI->getOperand(0).getReg());
 360     break;
 361   case X86::VUNPCKLPDYrr:
 362     Src2Name = getRegName(MI->getOperand(2).getReg());
 363     // FALL THROUGH.
 364   case X86::VUNPCKLPDYrm:
 365     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
 366     Src1Name = getRegName(MI->getOperand(1).getReg());
 367     DestName = getRegName(MI->getOperand(0).getReg());
 368     break;
 369   case X86::UNPCKLPSrr:
 370   case X86::VUNPCKLPSrr:
 371     Src2Name = getRegName(MI->getOperand(2).getReg());
 372     // FALL THROUGH.
 373   case X86::UNPCKLPSrm:
 374   case X86::VUNPCKLPSrm:
 375     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
 376     Src1Name = getRegName(MI->getOperand(1).getReg());
 377     DestName = getRegName(MI->getOperand(0).getReg());
 378     break;
 379   case X86::VUNPCKLPSYrr:
 380     Src2Name = getRegName(MI->getOperand(2).getReg());
 381     // FALL THROUGH.
 382   case X86::VUNPCKLPSYrm:
 383     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
 384     Src1Name = getRegName(MI->getOperand(1).getReg());
 385     DestName = getRegName(MI->getOperand(0).getReg());
 386     break;
 387   case X86::UNPCKHPDrr:
 388   case X86::VUNPCKHPDrr:
 389     Src2Name = getRegName(MI->getOperand(2).getReg());
 390     // FALL THROUGH.
 391   case X86::UNPCKHPDrm:
 392   case X86::VUNPCKHPDrm:
 393     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
 394     Src1Name = getRegName(MI->getOperand(1).getReg());
 395     DestName = getRegName(MI->getOperand(0).getReg());
 396     break;
 397   case X86::VUNPCKHPDYrr:
 398     Src2Name = getRegName(MI->getOperand(2).getReg());
 399     // FALL THROUGH.
 400   case X86::VUNPCKHPDYrm:
 401     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
 402     Src1Name = getRegName(MI->getOperand(1).getReg());
 403     DestName = getRegName(MI->getOperand(0).getReg());
 404     break;
 405   case X86::UNPCKHPSrr:
 406   case X86::VUNPCKHPSrr:
 407     Src2Name = getRegName(MI->getOperand(2).getReg());
 408     // FALL THROUGH.
 409   case X86::UNPCKHPSrm:
 410   case X86::VUNPCKHPSrm:
 411     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
 412     Src1Name = getRegName(MI->getOperand(1).getReg());
 413     DestName = getRegName(MI->getOperand(0).getReg());
 414     break;
 415   case X86::VUNPCKHPSYrr:
 416     Src2Name = getRegName(MI->getOperand(2).getReg());
 417     // FALL THROUGH.
 418   case X86::VUNPCKHPSYrm:
 419     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
 420     Src1Name = getRegName(MI->getOperand(1).getReg());
 421     DestName = getRegName(MI->getOperand(0).getReg());
 422     break;
 423   case X86::VPERMILPSri:
 424     Src1Name = getRegName(MI->getOperand(1).getReg());
 425     // FALL THROUGH.
 426   case X86::VPERMILPSmi:
 427     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 428       DecodePSHUFMask(MVT::v4f32,
 429                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 430                       ShuffleMask);
 431     DestName = getRegName(MI->getOperand(0).getReg());
 432     break;
 433   case X86::VPERMILPSYri:
 434     Src1Name = getRegName(MI->getOperand(1).getReg());
 435     // FALL THROUGH.
 436   case X86::VPERMILPSYmi:
 437     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 438       DecodePSHUFMask(MVT::v8f32,
 439                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 440                       ShuffleMask);
 441     DestName = getRegName(MI->getOperand(0).getReg());
 442     break;
 443   case X86::VPERMILPDri:
 444     Src1Name = getRegName(MI->getOperand(1).getReg());
 445     // FALL THROUGH.
 446   case X86::VPERMILPDmi:
 447     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 448       DecodePSHUFMask(MVT::v2f64,
 449                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 450                       ShuffleMask);
 451     DestName = getRegName(MI->getOperand(0).getReg());
 452     break;
 453   case X86::VPERMILPDYri:
 454     Src1Name = getRegName(MI->getOperand(1).getReg());
 455     // FALL THROUGH.
 456   case X86::VPERMILPDYmi:
 457     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 458       DecodePSHUFMask(MVT::v4f64,
 459                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 460                       ShuffleMask);
 461     DestName = getRegName(MI->getOperand(0).getReg());
 462     break;
 463   case X86::VPERM2F128rr:
 464   case X86::VPERM2I128rr:
 465     Src2Name = getRegName(MI->getOperand(2).getReg());
 466     // FALL THROUGH.
 467   case X86::VPERM2F128rm:
 468   case X86::VPERM2I128rm:
 469     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 470     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 471       DecodeVPERM2X128Mask(MVT::v4i64,
 472                            MI->getOperand(MI->getNumOperands()-1).getImm(),
 473                            ShuffleMask);
 474     Src1Name = getRegName(MI->getOperand(1).getReg());
 475     DestName = getRegName(MI->getOperand(0).getReg());
 476     break;
 477   case X86::VPERMQYri:
 478   case X86::VPERMPDYri:
 479     Src1Name = getRegName(MI->getOperand(1).getReg());
 480     // FALL THROUGH.
 481   case X86::VPERMQYmi:
 482   case X86::VPERMPDYmi:
 483     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 484       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 485                       ShuffleMask);
 486     DestName = getRegName(MI->getOperand(0).getReg());
 487     break;
 488   }
 489
 490
 491   // If this was a shuffle operation, print the shuffle mask.
 492   if (!ShuffleMask.empty()) {
 493     if (DestName == 0) DestName = Src1Name;
 494     OS << (DestName ? DestName : "mem") << " = ";
 495
 496     // If the two sources are the same, canonicalize the input elements to be
 497     // from the first src so that we get larger element spans.
 498     if (Src1Name == Src2Name) {
 499       for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 500         if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 501             ShuffleMask[i] >= (int)e)        // From second mask.
 502           ShuffleMask[i] -= e;
 503       }
 504     }
 505
 506     // The shuffle mask specifies which elements of the src1/src2 fill in the
 507     // destination, with a few sentinel values.  Loop through and print them
 508     // out.
 509     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 510       if (i != 0)
 511         OS << ',';
 512       if (ShuffleMask[i] == SM_SentinelZero) {
 513         OS << "zero";
 514         continue;
 515       }
 516
 517       // Otherwise, it must come from src1 or src2.  Print the span of elements
 518       // that comes from this src.
 519       bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
 520       const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 521       OS << (SrcName ? SrcName : "mem") << '[';
 522       bool IsFirst = true;
 523       while (i != e &&
 524              (int)ShuffleMask[i] >= 0 &&
 525              (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
 526         if (!IsFirst)
 527           OS << ',';
 528         else
 529           IsFirst = false;
 530         OS << ShuffleMask[i] % ShuffleMask.size();
 531         ++i;
 532       }
 533       OS << ']';
 534       --i;  // For loop increments element #.
 535     }
 536     //MI->print(OS, 0);
 537     OS << "\n";
 538   }
 539
 540 }