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