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