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