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