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