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);
 204     break;
 205
 206   case X86::PSLLDQri:
 207   case X86::VPSLLDQri:
 208     Src1Name = getRegName(MI->getOperand(1).getReg());
 209     DestName = getRegName(MI->getOperand(0).getReg());
 210     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 211       DecodePSLLDQMask(MVT::v16i8,
 212                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 213                        ShuffleMask);
 214     break;
 215
 216   case X86::VPSLLDQYri:
 217     Src1Name = getRegName(MI->getOperand(1).getReg());
 218     DestName = getRegName(MI->getOperand(0).getReg());
 219     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 220       DecodePSLLDQMask(MVT::v32i8,
 221                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 222                        ShuffleMask);
 223     break;
 224
 225   case X86::PSRLDQri:
 226   case X86::VPSRLDQri:
 227     Src1Name = getRegName(MI->getOperand(1).getReg());
 228     DestName = getRegName(MI->getOperand(0).getReg());
 229     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 230       DecodePSRLDQMask(MVT::v16i8,
 231                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 232                        ShuffleMask);
 233     break;
 234
 235   case X86::VPSRLDQYri:
 236     Src1Name = getRegName(MI->getOperand(1).getReg());
 237     DestName = getRegName(MI->getOperand(0).getReg());
 238     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 239       DecodePSRLDQMask(MVT::v32i8,
 240                        MI->getOperand(MI->getNumOperands()-1).getImm(),
 241                        ShuffleMask);
 242     break;
 243
 244   case X86::PALIGNR128rr:
 245   case X86::VPALIGNR128rr:
 246     Src1Name = getRegName(MI->getOperand(2).getReg());
 247     // FALL THROUGH.
 248   case X86::PALIGNR128rm:
 249   case X86::VPALIGNR128rm:
 250     Src2Name = getRegName(MI->getOperand(1).getReg());
 251     DestName = getRegName(MI->getOperand(0).getReg());
 252     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 253       DecodePALIGNRMask(MVT::v16i8,
 254                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 255                         ShuffleMask);
 256     break;
 257   case X86::VPALIGNR256rr:
 258     Src1Name = getRegName(MI->getOperand(2).getReg());
 259     // FALL THROUGH.
 260   case X86::VPALIGNR256rm:
 261     Src2Name = getRegName(MI->getOperand(1).getReg());
 262     DestName = getRegName(MI->getOperand(0).getReg());
 263     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 264       DecodePALIGNRMask(MVT::v32i8,
 265                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 266                         ShuffleMask);
 267     break;
 268
 269   case X86::PSHUFDri:
 270   case X86::VPSHUFDri:
 271     Src1Name = getRegName(MI->getOperand(1).getReg());
 272     // FALL THROUGH.
 273   case X86::PSHUFDmi:
 274   case X86::VPSHUFDmi:
 275     DestName = getRegName(MI->getOperand(0).getReg());
 276     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 277       DecodePSHUFMask(MVT::v4i32,
 278                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 279                       ShuffleMask);
 280     break;
 281   case X86::VPSHUFDYri:
 282     Src1Name = getRegName(MI->getOperand(1).getReg());
 283     // FALL THROUGH.
 284   case X86::VPSHUFDYmi:
 285     DestName = getRegName(MI->getOperand(0).getReg());
 286     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 287       DecodePSHUFMask(MVT::v8i32,
 288                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 289                       ShuffleMask);
 290     break;
 291
 292
 293   case X86::PSHUFHWri:
 294   case X86::VPSHUFHWri:
 295     Src1Name = getRegName(MI->getOperand(1).getReg());
 296     // FALL THROUGH.
 297   case X86::PSHUFHWmi:
 298   case X86::VPSHUFHWmi:
 299     DestName = getRegName(MI->getOperand(0).getReg());
 300     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 301       DecodePSHUFHWMask(MVT::v8i16,
 302                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 303                         ShuffleMask);
 304     break;
 305   case X86::VPSHUFHWYri:
 306     Src1Name = getRegName(MI->getOperand(1).getReg());
 307     // FALL THROUGH.
 308   case X86::VPSHUFHWYmi:
 309     DestName = getRegName(MI->getOperand(0).getReg());
 310     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 311       DecodePSHUFHWMask(MVT::v16i16,
 312                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 313                         ShuffleMask);
 314     break;
 315   case X86::PSHUFLWri:
 316   case X86::VPSHUFLWri:
 317     Src1Name = getRegName(MI->getOperand(1).getReg());
 318     // FALL THROUGH.
 319   case X86::PSHUFLWmi:
 320   case X86::VPSHUFLWmi:
 321     DestName = getRegName(MI->getOperand(0).getReg());
 322     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 323       DecodePSHUFLWMask(MVT::v8i16,
 324                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 325                         ShuffleMask);
 326     break;
 327   case X86::VPSHUFLWYri:
 328     Src1Name = getRegName(MI->getOperand(1).getReg());
 329     // FALL THROUGH.
 330   case X86::VPSHUFLWYmi:
 331     DestName = getRegName(MI->getOperand(0).getReg());
 332     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 333       DecodePSHUFLWMask(MVT::v16i16,
 334                         MI->getOperand(MI->getNumOperands()-1).getImm(),
 335                         ShuffleMask);
 336     break;
 337
 338   case X86::PUNPCKHBWrr:
 339   case X86::VPUNPCKHBWrr:
 340     Src2Name = getRegName(MI->getOperand(2).getReg());
 341     // FALL THROUGH.
 342   case X86::PUNPCKHBWrm:
 343   case X86::VPUNPCKHBWrm:
 344     Src1Name = getRegName(MI->getOperand(1).getReg());
 345     DestName = getRegName(MI->getOperand(0).getReg());
 346     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
 347     break;
 348   case X86::VPUNPCKHBWYrr:
 349     Src2Name = getRegName(MI->getOperand(2).getReg());
 350     // FALL THROUGH.
 351   case X86::VPUNPCKHBWYrm:
 352     Src1Name = getRegName(MI->getOperand(1).getReg());
 353     DestName = getRegName(MI->getOperand(0).getReg());
 354     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
 355     break;
 356   case X86::PUNPCKHWDrr:
 357   case X86::VPUNPCKHWDrr:
 358     Src2Name = getRegName(MI->getOperand(2).getReg());
 359     // FALL THROUGH.
 360   case X86::PUNPCKHWDrm:
 361   case X86::VPUNPCKHWDrm:
 362     Src1Name = getRegName(MI->getOperand(1).getReg());
 363     DestName = getRegName(MI->getOperand(0).getReg());
 364     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
 365     break;
 366   case X86::VPUNPCKHWDYrr:
 367     Src2Name = getRegName(MI->getOperand(2).getReg());
 368     // FALL THROUGH.
 369   case X86::VPUNPCKHWDYrm:
 370     Src1Name = getRegName(MI->getOperand(1).getReg());
 371     DestName = getRegName(MI->getOperand(0).getReg());
 372     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
 373     break;
 374   case X86::PUNPCKHDQrr:
 375   case X86::VPUNPCKHDQrr:
 376     Src2Name = getRegName(MI->getOperand(2).getReg());
 377     // FALL THROUGH.
 378   case X86::PUNPCKHDQrm:
 379   case X86::VPUNPCKHDQrm:
 380     Src1Name = getRegName(MI->getOperand(1).getReg());
 381     DestName = getRegName(MI->getOperand(0).getReg());
 382     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
 383     break;
 384   case X86::VPUNPCKHDQYrr:
 385     Src2Name = getRegName(MI->getOperand(2).getReg());
 386     // FALL THROUGH.
 387   case X86::VPUNPCKHDQYrm:
 388     Src1Name = getRegName(MI->getOperand(1).getReg());
 389     DestName = getRegName(MI->getOperand(0).getReg());
 390     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
 391     break;
 392   case X86::PUNPCKHQDQrr:
 393   case X86::VPUNPCKHQDQrr:
 394     Src2Name = getRegName(MI->getOperand(2).getReg());
 395     // FALL THROUGH.
 396   case X86::PUNPCKHQDQrm:
 397   case X86::VPUNPCKHQDQrm:
 398     Src1Name = getRegName(MI->getOperand(1).getReg());
 399     DestName = getRegName(MI->getOperand(0).getReg());
 400     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
 401     break;
 402   case X86::VPUNPCKHQDQYrr:
 403     Src2Name = getRegName(MI->getOperand(2).getReg());
 404     // FALL THROUGH.
 405   case X86::VPUNPCKHQDQYrm:
 406     Src1Name = getRegName(MI->getOperand(1).getReg());
 407     DestName = getRegName(MI->getOperand(0).getReg());
 408     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
 409     break;
 410
 411   case X86::PUNPCKLBWrr:
 412   case X86::VPUNPCKLBWrr:
 413     Src2Name = getRegName(MI->getOperand(2).getReg());
 414     // FALL THROUGH.
 415   case X86::PUNPCKLBWrm:
 416   case X86::VPUNPCKLBWrm:
 417     Src1Name = getRegName(MI->getOperand(1).getReg());
 418     DestName = getRegName(MI->getOperand(0).getReg());
 419     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
 420     break;
 421   case X86::VPUNPCKLBWYrr:
 422     Src2Name = getRegName(MI->getOperand(2).getReg());
 423     // FALL THROUGH.
 424   case X86::VPUNPCKLBWYrm:
 425     Src1Name = getRegName(MI->getOperand(1).getReg());
 426     DestName = getRegName(MI->getOperand(0).getReg());
 427     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
 428     break;
 429   case X86::PUNPCKLWDrr:
 430   case X86::VPUNPCKLWDrr:
 431     Src2Name = getRegName(MI->getOperand(2).getReg());
 432     // FALL THROUGH.
 433   case X86::PUNPCKLWDrm:
 434   case X86::VPUNPCKLWDrm:
 435     Src1Name = getRegName(MI->getOperand(1).getReg());
 436     DestName = getRegName(MI->getOperand(0).getReg());
 437     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
 438     break;
 439   case X86::VPUNPCKLWDYrr:
 440     Src2Name = getRegName(MI->getOperand(2).getReg());
 441     // FALL THROUGH.
 442   case X86::VPUNPCKLWDYrm:
 443     Src1Name = getRegName(MI->getOperand(1).getReg());
 444     DestName = getRegName(MI->getOperand(0).getReg());
 445     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
 446     break;
 447   case X86::PUNPCKLDQrr:
 448   case X86::VPUNPCKLDQrr:
 449     Src2Name = getRegName(MI->getOperand(2).getReg());
 450     // FALL THROUGH.
 451   case X86::PUNPCKLDQrm:
 452   case X86::VPUNPCKLDQrm:
 453     Src1Name = getRegName(MI->getOperand(1).getReg());
 454     DestName = getRegName(MI->getOperand(0).getReg());
 455     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
 456     break;
 457   case X86::VPUNPCKLDQYrr:
 458     Src2Name = getRegName(MI->getOperand(2).getReg());
 459     // FALL THROUGH.
 460   case X86::VPUNPCKLDQYrm:
 461     Src1Name = getRegName(MI->getOperand(1).getReg());
 462     DestName = getRegName(MI->getOperand(0).getReg());
 463     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
 464     break;
 465   case X86::PUNPCKLQDQrr:
 466   case X86::VPUNPCKLQDQrr:
 467     Src2Name = getRegName(MI->getOperand(2).getReg());
 468     // FALL THROUGH.
 469   case X86::PUNPCKLQDQrm:
 470   case X86::VPUNPCKLQDQrm:
 471     Src1Name = getRegName(MI->getOperand(1).getReg());
 472     DestName = getRegName(MI->getOperand(0).getReg());
 473     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
 474     break;
 475   case X86::VPUNPCKLQDQYrr:
 476     Src2Name = getRegName(MI->getOperand(2).getReg());
 477     // FALL THROUGH.
 478   case X86::VPUNPCKLQDQYrm:
 479     Src1Name = getRegName(MI->getOperand(1).getReg());
 480     DestName = getRegName(MI->getOperand(0).getReg());
 481     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
 482     break;
 483
 484   case X86::SHUFPDrri:
 485   case X86::VSHUFPDrri:
 486     Src2Name = getRegName(MI->getOperand(2).getReg());
 487     // FALL THROUGH.
 488   case X86::SHUFPDrmi:
 489   case X86::VSHUFPDrmi:
 490     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 491       DecodeSHUFPMask(MVT::v2f64,
 492                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 493                       ShuffleMask);
 494     Src1Name = getRegName(MI->getOperand(1).getReg());
 495     DestName = getRegName(MI->getOperand(0).getReg());
 496     break;
 497   case X86::VSHUFPDYrri:
 498     Src2Name = getRegName(MI->getOperand(2).getReg());
 499     // FALL THROUGH.
 500   case X86::VSHUFPDYrmi:
 501     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 502       DecodeSHUFPMask(MVT::v4f64,
 503                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 504                       ShuffleMask);
 505     Src1Name = getRegName(MI->getOperand(1).getReg());
 506     DestName = getRegName(MI->getOperand(0).getReg());
 507     break;
 508
 509   case X86::SHUFPSrri:
 510   case X86::VSHUFPSrri:
 511     Src2Name = getRegName(MI->getOperand(2).getReg());
 512     // FALL THROUGH.
 513   case X86::SHUFPSrmi:
 514   case X86::VSHUFPSrmi:
 515     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 516       DecodeSHUFPMask(MVT::v4f32,
 517                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 518                       ShuffleMask);
 519     Src1Name = getRegName(MI->getOperand(1).getReg());
 520     DestName = getRegName(MI->getOperand(0).getReg());
 521     break;
 522   case X86::VSHUFPSYrri:
 523     Src2Name = getRegName(MI->getOperand(2).getReg());
 524     // FALL THROUGH.
 525   case X86::VSHUFPSYrmi:
 526     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 527       DecodeSHUFPMask(MVT::v8f32,
 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
 534   case X86::UNPCKLPDrr:
 535   case X86::VUNPCKLPDrr:
 536     Src2Name = getRegName(MI->getOperand(2).getReg());
 537     // FALL THROUGH.
 538   case X86::UNPCKLPDrm:
 539   case X86::VUNPCKLPDrm:
 540     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
 541     Src1Name = getRegName(MI->getOperand(1).getReg());
 542     DestName = getRegName(MI->getOperand(0).getReg());
 543     break;
 544   case X86::VUNPCKLPDYrr:
 545     Src2Name = getRegName(MI->getOperand(2).getReg());
 546     // FALL THROUGH.
 547   case X86::VUNPCKLPDYrm:
 548     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
 549     Src1Name = getRegName(MI->getOperand(1).getReg());
 550     DestName = getRegName(MI->getOperand(0).getReg());
 551     break;
 552   case X86::UNPCKLPSrr:
 553   case X86::VUNPCKLPSrr:
 554     Src2Name = getRegName(MI->getOperand(2).getReg());
 555     // FALL THROUGH.
 556   case X86::UNPCKLPSrm:
 557   case X86::VUNPCKLPSrm:
 558     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
 559     Src1Name = getRegName(MI->getOperand(1).getReg());
 560     DestName = getRegName(MI->getOperand(0).getReg());
 561     break;
 562   case X86::VUNPCKLPSYrr:
 563     Src2Name = getRegName(MI->getOperand(2).getReg());
 564     // FALL THROUGH.
 565   case X86::VUNPCKLPSYrm:
 566     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
 567     Src1Name = getRegName(MI->getOperand(1).getReg());
 568     DestName = getRegName(MI->getOperand(0).getReg());
 569     break;
 570   case X86::UNPCKHPDrr:
 571   case X86::VUNPCKHPDrr:
 572     Src2Name = getRegName(MI->getOperand(2).getReg());
 573     // FALL THROUGH.
 574   case X86::UNPCKHPDrm:
 575   case X86::VUNPCKHPDrm:
 576     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
 577     Src1Name = getRegName(MI->getOperand(1).getReg());
 578     DestName = getRegName(MI->getOperand(0).getReg());
 579     break;
 580   case X86::VUNPCKHPDYrr:
 581     Src2Name = getRegName(MI->getOperand(2).getReg());
 582     // FALL THROUGH.
 583   case X86::VUNPCKHPDYrm:
 584     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
 585     Src1Name = getRegName(MI->getOperand(1).getReg());
 586     DestName = getRegName(MI->getOperand(0).getReg());
 587     break;
 588   case X86::UNPCKHPSrr:
 589   case X86::VUNPCKHPSrr:
 590     Src2Name = getRegName(MI->getOperand(2).getReg());
 591     // FALL THROUGH.
 592   case X86::UNPCKHPSrm:
 593   case X86::VUNPCKHPSrm:
 594     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
 595     Src1Name = getRegName(MI->getOperand(1).getReg());
 596     DestName = getRegName(MI->getOperand(0).getReg());
 597     break;
 598   case X86::VUNPCKHPSYrr:
 599     Src2Name = getRegName(MI->getOperand(2).getReg());
 600     // FALL THROUGH.
 601   case X86::VUNPCKHPSYrm:
 602     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
 603     Src1Name = getRegName(MI->getOperand(1).getReg());
 604     DestName = getRegName(MI->getOperand(0).getReg());
 605     break;
 606   case X86::VPERMILPSri:
 607     Src1Name = getRegName(MI->getOperand(1).getReg());
 608     // FALL THROUGH.
 609   case X86::VPERMILPSmi:
 610     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 611       DecodePSHUFMask(MVT::v4f32,
 612                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 613                       ShuffleMask);
 614     DestName = getRegName(MI->getOperand(0).getReg());
 615     break;
 616   case X86::VPERMILPSYri:
 617     Src1Name = getRegName(MI->getOperand(1).getReg());
 618     // FALL THROUGH.
 619   case X86::VPERMILPSYmi:
 620     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 621       DecodePSHUFMask(MVT::v8f32,
 622                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 623                       ShuffleMask);
 624     DestName = getRegName(MI->getOperand(0).getReg());
 625     break;
 626   case X86::VPERMILPDri:
 627     Src1Name = getRegName(MI->getOperand(1).getReg());
 628     // FALL THROUGH.
 629   case X86::VPERMILPDmi:
 630     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 631       DecodePSHUFMask(MVT::v2f64,
 632                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 633                       ShuffleMask);
 634     DestName = getRegName(MI->getOperand(0).getReg());
 635     break;
 636   case X86::VPERMILPDYri:
 637     Src1Name = getRegName(MI->getOperand(1).getReg());
 638     // FALL THROUGH.
 639   case X86::VPERMILPDYmi:
 640     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 641       DecodePSHUFMask(MVT::v4f64,
 642                       MI->getOperand(MI->getNumOperands()-1).getImm(),
 643                       ShuffleMask);
 644     DestName = getRegName(MI->getOperand(0).getReg());
 645     break;
 646   case X86::VPERM2F128rr:
 647   case X86::VPERM2I128rr:
 648     Src2Name = getRegName(MI->getOperand(2).getReg());
 649     // FALL THROUGH.
 650   case X86::VPERM2F128rm:
 651   case X86::VPERM2I128rm:
 652     // For instruction comments purpose, assume the 256-bit vector is v4i64.
 653     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 654       DecodeVPERM2X128Mask(MVT::v4i64,
 655                            MI->getOperand(MI->getNumOperands()-1).getImm(),
 656                            ShuffleMask);
 657     Src1Name = getRegName(MI->getOperand(1).getReg());
 658     DestName = getRegName(MI->getOperand(0).getReg());
 659     break;
 660   case X86::VPERMQYri:
 661   case X86::VPERMPDYri:
 662     Src1Name = getRegName(MI->getOperand(1).getReg());
 663     // FALL THROUGH.
 664   case X86::VPERMQYmi:
 665   case X86::VPERMPDYmi:
 666     if(MI->getOperand(MI->getNumOperands()-1).isImm())
 667       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 668                       ShuffleMask);
 669     DestName = getRegName(MI->getOperand(0).getReg());
 670     break;
 671   }
 672
 673   // The only comments we decode are shuffles, so give up if we were unable to
 674   // decode a shuffle mask.
 675   if (ShuffleMask.empty())
 676     return false;
 677
 678   if (!DestName) DestName = Src1Name;
 679   OS << (DestName ? DestName : "mem") << " = ";
 680
 681   // If the two sources are the same, canonicalize the input elements to be
 682   // from the first src so that we get larger element spans.
 683   if (Src1Name == Src2Name) {
 684     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 685       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 686           ShuffleMask[i] >= (int)e)        // From second mask.
 687         ShuffleMask[i] -= e;
 688     }
 689   }
 690
 691   // The shuffle mask specifies which elements of the src1/src2 fill in the
 692   // destination, with a few sentinel values.  Loop through and print them
 693   // out.
 694   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 695     if (i != 0)
 696       OS << ',';
 697     if (ShuffleMask[i] == SM_SentinelZero) {
 698       OS << "zero";
 699       continue;
 700     }
 701
 702     // Otherwise, it must come from src1 or src2.  Print the span of elements
 703     // that comes from this src.
 704     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
 705     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 706     OS << (SrcName ? SrcName : "mem") << '[';
 707     bool IsFirst = true;
 708     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
 709            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
 710       if (!IsFirst)
 711         OS << ',';
 712       else
 713         IsFirst = false;
 714       if (ShuffleMask[i] == SM_SentinelUndef)
 715         OS << "u";
 716       else
 717         OS << ShuffleMask[i] % ShuffleMask.size();
 718       ++i;
 719     }
 720     OS << ']';
 721     --i;  // For loop increments element #.
 722   }
 723   //MI->print(OS, 0);
 724   OS << "\n";
 725
 726   // We successfully added a comment to this instruction.
 727   return true;
 728 }