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/CodeGen/MachineValueType.h"
  20 #include "llvm/Support/raw_ostream.h"
  21
  22 using namespace llvm;
  23
  24 //===----------------------------------------------------------------------===//
  25 // Top Level Entrypoint
  26 //===----------------------------------------------------------------------===//
  27
  28 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints
  29 /// newline terminated strings to the specified string if desired.  This
  30 /// information is shown in disassembly dumps when verbose assembly is enabled.
  31 bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
  32                                   const char *(*getRegName)(unsigned)) {
  33   // If this is a shuffle operation, the switch should fill in this state.
  34   SmallVector<int, 8> ShuffleMask;
  35   const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
  36
  37   switch (MI->getOpcode()) {
  38   default:
  39     // Not an instruction for which we can decode comments.
  40     return false;
  41
  42   case X86::BLENDPDrri:
  43   case X86::VBLENDPDrri:
  44     Src2Name = getRegName(MI->getOperand(2).getReg());
  45     // FALL THROUGH.
  46   case X86::BLENDPDrmi:
  47   case X86::VBLENDPDrmi:
  48     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  49       DecodeBLENDMask(MVT::v2f64,
  50                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  51                       ShuffleMask);
  52     Src1Name = getRegName(MI->getOperand(1).getReg());
  53     DestName = getRegName(MI->getOperand(0).getReg());
  54     break;
  55   case X86::VBLENDPDYrri:
  56     Src2Name = getRegName(MI->getOperand(2).getReg());
  57     // FALL THROUGH.
  58   case X86::VBLENDPDYrmi:
  59     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  60       DecodeBLENDMask(MVT::v4f64,
  61                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  62                       ShuffleMask);
  63     Src1Name = getRegName(MI->getOperand(1).getReg());
  64     DestName = getRegName(MI->getOperand(0).getReg());
  65     break;
  66
  67   case X86::BLENDPSrri:
  68   case X86::VBLENDPSrri:
  69     Src2Name = getRegName(MI->getOperand(2).getReg());
  70     // FALL THROUGH.
  71   case X86::BLENDPSrmi:
  72   case X86::VBLENDPSrmi:
  73     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  74       DecodeBLENDMask(MVT::v4f32,
  75                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  76                       ShuffleMask);
  77     Src1Name = getRegName(MI->getOperand(1).getReg());
  78     DestName = getRegName(MI->getOperand(0).getReg());
  79     break;
  80   case X86::VBLENDPSYrri:
  81     Src2Name = getRegName(MI->getOperand(2).getReg());
  82     // FALL THROUGH.
  83   case X86::VBLENDPSYrmi:
  84     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  85       DecodeBLENDMask(MVT::v8f32,
  86                       MI->getOperand(MI->getNumOperands()-1).getImm(),
  87                       ShuffleMask);
  88     Src1Name = getRegName(MI->getOperand(1).getReg());
  89     DestName = getRegName(MI->getOperand(0).getReg());
  90     break;
  91
  92   case X86::PBLENDWrri:
  93   case X86::VPBLENDWrri:
  94     Src2Name = getRegName(MI->getOperand(2).getReg());
  95     // FALL THROUGH.
  96   case X86::PBLENDWrmi:
  97   case X86::VPBLENDWrmi:
  98     if(MI->getOperand(MI->getNumOperands()-1).isImm())
  99       DecodeBLENDMask(MVT::v8i16,
 100                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 101                       ShuffleMask);
 102     Src1Name = getRegName(MI->getOperand(1).getReg());
 103     DestName = getRegName(MI->getOperand(0).getReg());
 104     break;
 105   case X86::VPBLENDWYrri:
 106     Src2Name = getRegName(MI->getOperand(2).getReg());
 107     // FALL THROUGH.
 108   case X86::VPBLENDWYrmi:
 109     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 110       DecodeBLENDMask(MVT::v16i16,
 111                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 112                       ShuffleMask);
 113     Src1Name = getRegName(MI->getOperand(1).getReg());
 114     DestName = getRegName(MI->getOperand(0).getReg());
 115     break;
 116
 117   case X86::VPBLENDDrri:
 118     Src2Name = getRegName(MI->getOperand(2).getReg());
 119     // FALL THROUGH.
 120   case X86::VPBLENDDrmi:
 121     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 122       DecodeBLENDMask(MVT::v4i32,
 123                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 124                       ShuffleMask);
 125     Src1Name = getRegName(MI->getOperand(1).getReg());
 126     DestName = getRegName(MI->getOperand(0).getReg());
 127     break;
 128
 129   case X86::VPBLENDDYrri:
 130     Src2Name = getRegName(MI->getOperand(2).getReg());
 131     // FALL THROUGH.
 132   case X86::VPBLENDDYrmi:
 133     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 134       DecodeBLENDMask(MVT::v8i32,
 135                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 136                       ShuffleMask);
 137     Src1Name = getRegName(MI->getOperand(1).getReg());
 138     DestName = getRegName(MI->getOperand(0).getReg());
 139     break;
 140
 141   case X86::INSERTPSrr:
 142   case X86::VINSERTPSrr:
 143     Src2Name = getRegName(MI->getOperand(2).getReg());
 144     // FALL THROUGH.
 145   case X86::INSERTPSrm:
 146   case X86::VINSERTPSrm:
 147     DestName = getRegName(MI->getOperand(0).getReg());
 148     Src1Name = getRegName(MI->getOperand(1).getReg());
 149     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 150       DecodeINSERTPSMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 151                          ShuffleMask);
 152     break;
 153
 154   case X86::MOVLHPSrr:
 155   case X86::VMOVLHPSrr:
 156     Src2Name = getRegName(MI->getOperand(2).getReg());
 157     Src1Name = getRegName(MI->getOperand(1).getReg());
 158     DestName = getRegName(MI->getOperand(0).getReg());
 159     DecodeMOVLHPSMask(2, ShuffleMask);
 160     break;
 161
 162   case X86::MOVHLPSrr:
 163   case X86::VMOVHLPSrr:
 164     Src2Name = getRegName(MI->getOperand(2).getReg());
 165     Src1Name = getRegName(MI->getOperand(1).getReg());
 166     DestName = getRegName(MI->getOperand(0).getReg());
 167     DecodeMOVHLPSMask(2, ShuffleMask);
 168     break;
 169
 170   case X86::MOVSLDUPrr:
 171   case X86::VMOVSLDUPrr:
 172     Src1Name = getRegName(MI->getOperand(1).getReg());
 173     // FALL THROUGH.
 174   case X86::MOVSLDUPrm:
 175   case X86::VMOVSLDUPrm:
 176     DestName = getRegName(MI->getOperand(0).getReg());
 177     DecodeMOVSLDUPMask(MVT::v4f32, ShuffleMask);
 178     break;
 179
 180   case X86::VMOVSHDUPYrr:
 181     Src1Name = getRegName(MI->getOperand(1).getReg());
 182     // FALL THROUGH.
 183   case X86::VMOVSHDUPYrm:
 184     DestName = getRegName(MI->getOperand(0).getReg());
 185     DecodeMOVSHDUPMask(MVT::v8f32, ShuffleMask);
 186     break;
 187
 188   case X86::VMOVSLDUPYrr:
 189     Src1Name = getRegName(MI->getOperand(1).getReg());
 190     // FALL THROUGH.
 191   case X86::VMOVSLDUPYrm:
 192     DestName = getRegName(MI->getOperand(0).getReg());
 193     DecodeMOVSLDUPMask(MVT::v8f32, ShuffleMask);
 194     break;
 195
 196   case X86::MOVSHDUPrr:
 197   case X86::VMOVSHDUPrr:
 198     Src1Name = getRegName(MI->getOperand(1).getReg());
 199     // FALL THROUGH.
 200   case X86::MOVSHDUPrm:
 201   case X86::VMOVSHDUPrm:
 202     DestName = getRegName(MI->getOperand(0).getReg());
 203     DecodeMOVSHDUPMask(MVT::v4f32, ShuffleMask);\r
 204     break;\r
 205 \r
 206   case X86::VMOVDDUPYrr:\r
 207     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 208     // FALL THROUGH.\r
 209   case X86::VMOVDDUPYrm:\r
 210     DestName = getRegName(MI->getOperand(0).getReg());\r
 211     DecodeMOVDDUPMask(MVT::v4f64, ShuffleMask);\r
 212     break;\r
 213 \r
 214   case X86::MOVDDUPrr:\r
 215   case X86::VMOVDDUPrr:\r
 216     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 217     // FALL THROUGH.\r
 218   case X86::MOVDDUPrm:\r
 219   case X86::VMOVDDUPrm:\r
 220     DestName = getRegName(MI->getOperand(0).getReg());\r
 221     DecodeMOVDDUPMask(MVT::v2f64, ShuffleMask);\r
 222     break;\r
 223 \r
 224   case X86::PSLLDQri:\r
 225   case X86::VPSLLDQri:\r
 226     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 227     DestName = getRegName(MI->getOperand(0).getReg());
 228     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 229       DecodePSLLDQMask(MVT::v16i8,
 230                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 231                        ShuffleMask);
 232     break;
 233
 234   case X86::VPSLLDQYri:
 235     Src1Name = getRegName(MI->getOperand(1).getReg());
 236     DestName = getRegName(MI->getOperand(0).getReg());
 237     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 238       DecodePSLLDQMask(MVT::v32i8,
 239                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 240                        ShuffleMask);
 241     break;
 242
 243   case X86::PSRLDQri:
 244   case X86::VPSRLDQri:
 245     Src1Name = getRegName(MI->getOperand(1).getReg());
 246     DestName = getRegName(MI->getOperand(0).getReg());
 247     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 248       DecodePSRLDQMask(MVT::v16i8,
 249                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 250                        ShuffleMask);
 251     break;
 252
 253   case X86::VPSRLDQYri:
 254     Src1Name = getRegName(MI->getOperand(1).getReg());
 255     DestName = getRegName(MI->getOperand(0).getReg());
 256     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 257       DecodePSRLDQMask(MVT::v32i8,
 258                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 259                        ShuffleMask);
 260     break;
 261
 262   case X86::PALIGNR128rr:
 263   case X86::VPALIGNR128rr:
 264     Src1Name = getRegName(MI->getOperand(2).getReg());
 265     // FALL THROUGH.
 266   case X86::PALIGNR128rm:
 267   case X86::VPALIGNR128rm:
 268     Src2Name = getRegName(MI->getOperand(1).getReg());
 269     DestName = getRegName(MI->getOperand(0).getReg());
 270     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 271       DecodePALIGNRMask(MVT::v16i8,
 272                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 273                         ShuffleMask);
 274     break;
 275   case X86::VPALIGNR256rr:
 276     Src1Name = getRegName(MI->getOperand(2).getReg());
 277     // FALL THROUGH.
 278   case X86::VPALIGNR256rm:
 279     Src2Name = getRegName(MI->getOperand(1).getReg());
 280     DestName = getRegName(MI->getOperand(0).getReg());
 281     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 282       DecodePALIGNRMask(MVT::v32i8,
 283                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 284                         ShuffleMask);
 285     break;
 286
 287   case X86::PSHUFDri:
 288   case X86::VPSHUFDri:
 289     Src1Name = getRegName(MI->getOperand(1).getReg());
 290     // FALL THROUGH.
 291   case X86::PSHUFDmi:
 292   case X86::VPSHUFDmi:
 293     DestName = getRegName(MI->getOperand(0).getReg());
 294     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 295       DecodePSHUFMask(MVT::v4i32,
 296                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 297                       ShuffleMask);
 298     break;
 299   case X86::VPSHUFDYri:
 300     Src1Name = getRegName(MI->getOperand(1).getReg());
 301     // FALL THROUGH.
 302   case X86::VPSHUFDYmi:
 303     DestName = getRegName(MI->getOperand(0).getReg());
 304     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 305       DecodePSHUFMask(MVT::v8i32,
 306                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 307                       ShuffleMask);
 308     break;
 309
 310
 311   case X86::PSHUFHWri:
 312   case X86::VPSHUFHWri:
 313     Src1Name = getRegName(MI->getOperand(1).getReg());
 314     // FALL THROUGH.
 315   case X86::PSHUFHWmi:
 316   case X86::VPSHUFHWmi:
 317     DestName = getRegName(MI->getOperand(0).getReg());
 318     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 319       DecodePSHUFHWMask(MVT::v8i16,
 320                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 321                         ShuffleMask);
 322     break;
 323   case X86::VPSHUFHWYri:
 324     Src1Name = getRegName(MI->getOperand(1).getReg());
 325     // FALL THROUGH.
 326   case X86::VPSHUFHWYmi:
 327     DestName = getRegName(MI->getOperand(0).getReg());
 328     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 329       DecodePSHUFHWMask(MVT::v16i16,
 330                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 331                         ShuffleMask);
 332     break;
 333   case X86::PSHUFLWri:
 334   case X86::VPSHUFLWri:
 335     Src1Name = getRegName(MI->getOperand(1).getReg());
 336     // FALL THROUGH.
 337   case X86::PSHUFLWmi:
 338   case X86::VPSHUFLWmi:
 339     DestName = getRegName(MI->getOperand(0).getReg());
 340     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 341       DecodePSHUFLWMask(MVT::v8i16,
 342                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 343                         ShuffleMask);
 344     break;
 345   case X86::VPSHUFLWYri:
 346     Src1Name = getRegName(MI->getOperand(1).getReg());
 347     // FALL THROUGH.
 348   case X86::VPSHUFLWYmi:
 349     DestName = getRegName(MI->getOperand(0).getReg());
 350     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 351       DecodePSHUFLWMask(MVT::v16i16,
 352                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 353                         ShuffleMask);
 354     break;
 355
 356   case X86::PUNPCKHBWrr:
 357   case X86::VPUNPCKHBWrr:
 358     Src2Name = getRegName(MI->getOperand(2).getReg());
 359     // FALL THROUGH.
 360   case X86::PUNPCKHBWrm:
 361   case X86::VPUNPCKHBWrm:
 362     Src1Name = getRegName(MI->getOperand(1).getReg());
 363     DestName = getRegName(MI->getOperand(0).getReg());
 364     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
 365     break;
 366   case X86::VPUNPCKHBWYrr:
 367     Src2Name = getRegName(MI->getOperand(2).getReg());
 368     // FALL THROUGH.
 369   case X86::VPUNPCKHBWYrm:
 370     Src1Name = getRegName(MI->getOperand(1).getReg());
 371     DestName = getRegName(MI->getOperand(0).getReg());
 372     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
 373     break;
 374   case X86::PUNPCKHWDrr:
 375   case X86::VPUNPCKHWDrr:
 376     Src2Name = getRegName(MI->getOperand(2).getReg());
 377     // FALL THROUGH.
 378   case X86::PUNPCKHWDrm:
 379   case X86::VPUNPCKHWDrm:
 380     Src1Name = getRegName(MI->getOperand(1).getReg());
 381     DestName = getRegName(MI->getOperand(0).getReg());
 382     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
 383     break;
 384   case X86::VPUNPCKHWDYrr:
 385     Src2Name = getRegName(MI->getOperand(2).getReg());
 386     // FALL THROUGH.
 387   case X86::VPUNPCKHWDYrm:
 388     Src1Name = getRegName(MI->getOperand(1).getReg());
 389     DestName = getRegName(MI->getOperand(0).getReg());
 390     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
 391     break;
 392   case X86::PUNPCKHDQrr:
 393   case X86::VPUNPCKHDQrr:
 394     Src2Name = getRegName(MI->getOperand(2).getReg());
 395     // FALL THROUGH.
 396   case X86::PUNPCKHDQrm:
 397   case X86::VPUNPCKHDQrm:
 398     Src1Name = getRegName(MI->getOperand(1).getReg());
 399     DestName = getRegName(MI->getOperand(0).getReg());
 400     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
 401     break;
 402   case X86::VPUNPCKHDQYrr:
 403     Src2Name = getRegName(MI->getOperand(2).getReg());
 404     // FALL THROUGH.
 405   case X86::VPUNPCKHDQYrm:
 406     Src1Name = getRegName(MI->getOperand(1).getReg());
 407     DestName = getRegName(MI->getOperand(0).getReg());
 408     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
 409     break;
 410   case X86::VPUNPCKHDQZrr:
 411     Src2Name = getRegName(MI->getOperand(2).getReg());
 412     // FALL THROUGH.
 413   case X86::VPUNPCKHDQZrm:
 414     Src1Name = getRegName(MI->getOperand(1).getReg());
 415     DestName = getRegName(MI->getOperand(0).getReg());
 416     DecodeUNPCKHMask(MVT::v16i32, ShuffleMask);
 417     break;
 418   case X86::PUNPCKHQDQrr:
 419   case X86::VPUNPCKHQDQrr:
 420     Src2Name = getRegName(MI->getOperand(2).getReg());
 421     // FALL THROUGH.
 422   case X86::PUNPCKHQDQrm:
 423   case X86::VPUNPCKHQDQrm:
 424     Src1Name = getRegName(MI->getOperand(1).getReg());
 425     DestName = getRegName(MI->getOperand(0).getReg());
 426     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
 427     break;
 428   case X86::VPUNPCKHQDQYrr:
 429     Src2Name = getRegName(MI->getOperand(2).getReg());
 430     // FALL THROUGH.
 431   case X86::VPUNPCKHQDQYrm:
 432     Src1Name = getRegName(MI->getOperand(1).getReg());
 433     DestName = getRegName(MI->getOperand(0).getReg());
 434     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
 435     break;
 436   case X86::VPUNPCKHQDQZrr:
 437     Src2Name = getRegName(MI->getOperand(2).getReg());
 438     // FALL THROUGH.
 439   case X86::VPUNPCKHQDQZrm:
 440     Src1Name = getRegName(MI->getOperand(1).getReg());
 441     DestName = getRegName(MI->getOperand(0).getReg());
 442     DecodeUNPCKHMask(MVT::v8i64, ShuffleMask);
 443     break;
 444
 445   case X86::PUNPCKLBWrr:
 446   case X86::VPUNPCKLBWrr:
 447     Src2Name = getRegName(MI->getOperand(2).getReg());
 448     // FALL THROUGH.
 449   case X86::PUNPCKLBWrm:
 450   case X86::VPUNPCKLBWrm:
 451     Src1Name = getRegName(MI->getOperand(1).getReg());
 452     DestName = getRegName(MI->getOperand(0).getReg());
 453     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
 454     break;
 455   case X86::VPUNPCKLBWYrr:
 456     Src2Name = getRegName(MI->getOperand(2).getReg());
 457     // FALL THROUGH.
 458   case X86::VPUNPCKLBWYrm:
 459     Src1Name = getRegName(MI->getOperand(1).getReg());
 460     DestName = getRegName(MI->getOperand(0).getReg());
 461     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
 462     break;
 463   case X86::PUNPCKLWDrr:
 464   case X86::VPUNPCKLWDrr:
 465     Src2Name = getRegName(MI->getOperand(2).getReg());
 466     // FALL THROUGH.
 467   case X86::PUNPCKLWDrm:
 468   case X86::VPUNPCKLWDrm:
 469     Src1Name = getRegName(MI->getOperand(1).getReg());
 470     DestName = getRegName(MI->getOperand(0).getReg());
 471     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
 472     break;
 473   case X86::VPUNPCKLWDYrr:
 474     Src2Name = getRegName(MI->getOperand(2).getReg());
 475     // FALL THROUGH.
 476   case X86::VPUNPCKLWDYrm:
 477     Src1Name = getRegName(MI->getOperand(1).getReg());
 478     DestName = getRegName(MI->getOperand(0).getReg());
 479     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
 480     break;
 481   case X86::PUNPCKLDQrr:
 482   case X86::VPUNPCKLDQrr:
 483     Src2Name = getRegName(MI->getOperand(2).getReg());
 484     // FALL THROUGH.
 485   case X86::PUNPCKLDQrm:
 486   case X86::VPUNPCKLDQrm:
 487     Src1Name = getRegName(MI->getOperand(1).getReg());
 488     DestName = getRegName(MI->getOperand(0).getReg());
 489     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
 490     break;
 491   case X86::VPUNPCKLDQYrr:
 492     Src2Name = getRegName(MI->getOperand(2).getReg());
 493     // FALL THROUGH.
 494   case X86::VPUNPCKLDQYrm:
 495     Src1Name = getRegName(MI->getOperand(1).getReg());
 496     DestName = getRegName(MI->getOperand(0).getReg());
 497     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
 498     break;
 499   case X86::VPUNPCKLDQZrr:
 500     Src2Name = getRegName(MI->getOperand(2).getReg());
 501     // FALL THROUGH.
 502   case X86::VPUNPCKLDQZrm:
 503     Src1Name = getRegName(MI->getOperand(1).getReg());
 504     DestName = getRegName(MI->getOperand(0).getReg());
 505     DecodeUNPCKLMask(MVT::v16i32, ShuffleMask);
 506     break;
 507   case X86::PUNPCKLQDQrr:
 508   case X86::VPUNPCKLQDQrr:
 509     Src2Name = getRegName(MI->getOperand(2).getReg());
 510     // FALL THROUGH.
 511   case X86::PUNPCKLQDQrm:
 512   case X86::VPUNPCKLQDQrm:
 513     Src1Name = getRegName(MI->getOperand(1).getReg());
 514     DestName = getRegName(MI->getOperand(0).getReg());
 515     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
 516     break;
 517   case X86::VPUNPCKLQDQYrr:
 518     Src2Name = getRegName(MI->getOperand(2).getReg());
 519     // FALL THROUGH.
 520   case X86::VPUNPCKLQDQYrm:
 521     Src1Name = getRegName(MI->getOperand(1).getReg());
 522     DestName = getRegName(MI->getOperand(0).getReg());
 523     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
 524     break;
 525   case X86::VPUNPCKLQDQZrr:
 526     Src2Name = getRegName(MI->getOperand(2).getReg());
 527     // FALL THROUGH.
 528   case X86::VPUNPCKLQDQZrm:
 529     Src1Name = getRegName(MI->getOperand(1).getReg());
 530     DestName = getRegName(MI->getOperand(0).getReg());
 531     DecodeUNPCKLMask(MVT::v8i64, ShuffleMask);
 532     break;
 533
 534   case X86::SHUFPDrri:
 535   case X86::VSHUFPDrri:
 536     Src2Name = getRegName(MI->getOperand(2).getReg());
 537     // FALL THROUGH.
 538   case X86::SHUFPDrmi:
 539   case X86::VSHUFPDrmi:
 540     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 541       DecodeSHUFPMask(MVT::v2f64,
 542                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 543                       ShuffleMask);
 544     Src1Name = getRegName(MI->getOperand(1).getReg());
 545     DestName = getRegName(MI->getOperand(0).getReg());
 546     break;
 547   case X86::VSHUFPDYrri:
 548     Src2Name = getRegName(MI->getOperand(2).getReg());
 549     // FALL THROUGH.
 550   case X86::VSHUFPDYrmi:
 551     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 552       DecodeSHUFPMask(MVT::v4f64,
 553                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 554                       ShuffleMask);
 555     Src1Name = getRegName(MI->getOperand(1).getReg());
 556     DestName = getRegName(MI->getOperand(0).getReg());
 557     break;
 558
 559   case X86::SHUFPSrri:
 560   case X86::VSHUFPSrri:
 561     Src2Name = getRegName(MI->getOperand(2).getReg());
 562     // FALL THROUGH.
 563   case X86::SHUFPSrmi:
 564   case X86::VSHUFPSrmi:
 565     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 566       DecodeSHUFPMask(MVT::v4f32,
 567                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 568                       ShuffleMask);
 569     Src1Name = getRegName(MI->getOperand(1).getReg());
 570     DestName = getRegName(MI->getOperand(0).getReg());
 571     break;
 572   case X86::VSHUFPSYrri:
 573     Src2Name = getRegName(MI->getOperand(2).getReg());
 574     // FALL THROUGH.
 575   case X86::VSHUFPSYrmi:
 576     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 577       DecodeSHUFPMask(MVT::v8f32,
 578                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 579                       ShuffleMask);
 580     Src1Name = getRegName(MI->getOperand(1).getReg());
 581     DestName = getRegName(MI->getOperand(0).getReg());
 582     break;
 583
 584   case X86::UNPCKLPDrr:
 585   case X86::VUNPCKLPDrr:
 586     Src2Name = getRegName(MI->getOperand(2).getReg());
 587     // FALL THROUGH.
 588   case X86::UNPCKLPDrm:
 589   case X86::VUNPCKLPDrm:
 590     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
 591     Src1Name = getRegName(MI->getOperand(1).getReg());
 592     DestName = getRegName(MI->getOperand(0).getReg());
 593     break;
 594   case X86::VUNPCKLPDYrr:
 595     Src2Name = getRegName(MI->getOperand(2).getReg());
 596     // FALL THROUGH.
 597   case X86::VUNPCKLPDYrm:
 598     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
 599     Src1Name = getRegName(MI->getOperand(1).getReg());
 600     DestName = getRegName(MI->getOperand(0).getReg());
 601     break;
 602   case X86::VUNPCKLPDZrr:
 603     Src2Name = getRegName(MI->getOperand(2).getReg());
 604     // FALL THROUGH.
 605   case X86::VUNPCKLPDZrm:
 606     DecodeUNPCKLMask(MVT::v8f64, ShuffleMask);
 607     Src1Name = getRegName(MI->getOperand(1).getReg());
 608     DestName = getRegName(MI->getOperand(0).getReg());
 609     break;
 610   case X86::UNPCKLPSrr:
 611   case X86::VUNPCKLPSrr:
 612     Src2Name = getRegName(MI->getOperand(2).getReg());
 613     // FALL THROUGH.
 614   case X86::UNPCKLPSrm:
 615   case X86::VUNPCKLPSrm:
 616     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
 617     Src1Name = getRegName(MI->getOperand(1).getReg());
 618     DestName = getRegName(MI->getOperand(0).getReg());
 619     break;
 620   case X86::VUNPCKLPSYrr:
 621     Src2Name = getRegName(MI->getOperand(2).getReg());
 622     // FALL THROUGH.
 623   case X86::VUNPCKLPSYrm:
 624     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
 625     Src1Name = getRegName(MI->getOperand(1).getReg());
 626     DestName = getRegName(MI->getOperand(0).getReg());
 627     break;
 628   case X86::VUNPCKLPSZrr:
 629     Src2Name = getRegName(MI->getOperand(2).getReg());
 630     // FALL THROUGH.
 631   case X86::VUNPCKLPSZrm:
 632     DecodeUNPCKLMask(MVT::v16f32, ShuffleMask);
 633     Src1Name = getRegName(MI->getOperand(1).getReg());
 634     DestName = getRegName(MI->getOperand(0).getReg());
 635     break;
 636   case X86::UNPCKHPDrr:
 637   case X86::VUNPCKHPDrr:
 638     Src2Name = getRegName(MI->getOperand(2).getReg());
 639     // FALL THROUGH.
 640   case X86::UNPCKHPDrm:
 641   case X86::VUNPCKHPDrm:
 642     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
 643     Src1Name = getRegName(MI->getOperand(1).getReg());
 644     DestName = getRegName(MI->getOperand(0).getReg());
 645     break;
 646   case X86::VUNPCKHPDYrr:
 647     Src2Name = getRegName(MI->getOperand(2).getReg());
 648     // FALL THROUGH.
 649   case X86::VUNPCKHPDYrm:
 650     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
 651     Src1Name = getRegName(MI->getOperand(1).getReg());
 652     DestName = getRegName(MI->getOperand(0).getReg());
 653     break;
 654   case X86::VUNPCKHPDZrr:
 655     Src2Name = getRegName(MI->getOperand(2).getReg());
 656     // FALL THROUGH.
 657   case X86::VUNPCKHPDZrm:
 658     DecodeUNPCKHMask(MVT::v8f64, ShuffleMask);
 659     Src1Name = getRegName(MI->getOperand(1).getReg());
 660     DestName = getRegName(MI->getOperand(0).getReg());
 661     break;
 662   case X86::UNPCKHPSrr:
 663   case X86::VUNPCKHPSrr:
 664     Src2Name = getRegName(MI->getOperand(2).getReg());
 665     // FALL THROUGH.
 666   case X86::UNPCKHPSrm:
 667   case X86::VUNPCKHPSrm:
 668     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
 669     Src1Name = getRegName(MI->getOperand(1).getReg());
 670     DestName = getRegName(MI->getOperand(0).getReg());
 671     break;
 672   case X86::VUNPCKHPSYrr:
 673     Src2Name = getRegName(MI->getOperand(2).getReg());
 674     // FALL THROUGH.
 675   case X86::VUNPCKHPSYrm:
 676     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
 677     Src1Name = getRegName(MI->getOperand(1).getReg());
 678     DestName = getRegName(MI->getOperand(0).getReg());
 679     break;
 680   case X86::VUNPCKHPSZrr:
 681     Src2Name = getRegName(MI->getOperand(2).getReg());
 682     // FALL THROUGH.
 683   case X86::VUNPCKHPSZrm:
 684     DecodeUNPCKHMask(MVT::v16f32, ShuffleMask);
 685     Src1Name = getRegName(MI->getOperand(1).getReg());
 686     DestName = getRegName(MI->getOperand(0).getReg());
 687     break;
 688   case X86::VPERMILPSri:
 689     Src1Name = getRegName(MI->getOperand(1).getReg());
 690     // FALL THROUGH.
 691   case X86::VPERMILPSmi:
 692     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 693       DecodePSHUFMask(MVT::v4f32,
 694                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 695                       ShuffleMask);
 696     DestName = getRegName(MI->getOperand(0).getReg());
 697     break;
 698   case X86::VPERMILPSYri:
 699     Src1Name = getRegName(MI->getOperand(1).getReg());
 700     // FALL THROUGH.
 701   case X86::VPERMILPSYmi:
 702     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 703       DecodePSHUFMask(MVT::v8f32,
 704                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 705                       ShuffleMask);
 706     DestName = getRegName(MI->getOperand(0).getReg());
 707     break;
 708   case X86::VPERMILPDri:
 709     Src1Name = getRegName(MI->getOperand(1).getReg());
 710     // FALL THROUGH.
 711   case X86::VPERMILPDmi:
 712     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 713       DecodePSHUFMask(MVT::v2f64,
 714                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 715                       ShuffleMask);
 716     DestName = getRegName(MI->getOperand(0).getReg());
 717     break;
 718   case X86::VPERMILPDYri:
 719     Src1Name = getRegName(MI->getOperand(1).getReg());
 720     // FALL THROUGH.
 721   case X86::VPERMILPDYmi:
 722     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 723       DecodePSHUFMask(MVT::v4f64,
 724                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 725                       ShuffleMask);
 726     DestName = getRegName(MI->getOperand(0).getReg());
 727     break;
 728   case X86::VPERM2F128rr:
 729   case X86::VPERM2I128rr:
 730     Src2Name = getRegName(MI->getOperand(2).getReg());
 731     // FALL THROUGH.
 732   case X86::VPERM2F128rm:
 733   case X86::VPERM2I128rm:
 734     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 735     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 736       DecodeVPERM2X128Mask(MVT::v4i64,
 737                            MI->getOperand(MI->getNumOperands()-1).getImm(),
 738                            ShuffleMask);
 739     Src1Name = getRegName(MI->getOperand(1).getReg());
 740     DestName = getRegName(MI->getOperand(0).getReg());
 741     break;
 742   case X86::VPERMQYri:
 743   case X86::VPERMPDYri:
 744     Src1Name = getRegName(MI->getOperand(1).getReg());
 745     // FALL THROUGH.
 746   case X86::VPERMQYmi:
 747   case X86::VPERMPDYmi:
 748     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 749       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 750                       ShuffleMask);
 751     DestName = getRegName(MI->getOperand(0).getReg());
 752     break;
 753   }
 754
 755   // The only comments we decode are shuffles, so give up if we were unable to
 756   // decode a shuffle mask.
 757   if (ShuffleMask.empty())
 758     return false;
 759
 760   if (!DestName) DestName = Src1Name;
 761   OS << (DestName ? DestName : "mem") << " = ";
 762
 763   // If the two sources are the same, canonicalize the input elements to be
 764   // from the first src so that we get larger element spans.
 765   if (Src1Name == Src2Name) {
 766     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 767       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 768           ShuffleMask[i] >= (int)e)        // From second mask.
 769         ShuffleMask[i] -= e;
 770     }
 771   }
 772
 773   // The shuffle mask specifies which elements of the src1/src2 fill in the
 774   // destination, with a few sentinel values.  Loop through and print them
 775   // out.
 776   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 777     if (i != 0)
 778       OS << ',';
 779     if (ShuffleMask[i] == SM_SentinelZero) {
 780       OS << "zero";
 781       continue;
 782     }
 783
 784     // Otherwise, it must come from src1 or src2.  Print the span of elements
 785     // that comes from this src.
 786     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
 787     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 788     OS << (SrcName ? SrcName : "mem") << '[';
 789     bool IsFirst = true;
 790     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
 791            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
 792       if (!IsFirst)
 793         OS << ',';
 794       else
 795         IsFirst = false;
 796       if (ShuffleMask[i] == SM_SentinelUndef)
 797         OS << "u";
 798       else
 799         OS << ShuffleMask[i] % ShuffleMask.size();
 800       ++i;
 801     }
 802     OS << ']';
 803     --i;  // For loop increments element #.
 804   }
 805   //MI->print(OS, 0);
 806   OS << "\n";
 807
 808   // We successfully added a comment to this instruction.
 809   return true;
 810 }