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