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