Home | History | Annotate | Download | only in InstPrinter 
      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::INSERTPSrr:
     39   case X86::VINSERTPSrr:
     40     DestName = getRegName(MI->getOperand(0).getReg());
     41     Src1Name = getRegName(MI->getOperand(1).getReg());
     42     Src2Name = getRegName(MI->getOperand(2).getReg());
     43     if(MI->getOperand(3).isImm())
     44       DecodeINSERTPSMask(MI->getOperand(3).getImm(), ShuffleMask);
     45     break;
     46 
     47   case X86::MOVLHPSrr:
     48   case X86::VMOVLHPSrr:
     49     Src2Name = getRegName(MI->getOperand(2).getReg());
     50     Src1Name = getRegName(MI->getOperand(1).getReg());
     51     DestName = getRegName(MI->getOperand(0).getReg());
     52     DecodeMOVLHPSMask(2, ShuffleMask);
     53     break;
     54 
     55   case X86::MOVHLPSrr:
     56   case X86::VMOVHLPSrr:
     57     Src2Name = getRegName(MI->getOperand(2).getReg());
     58     Src1Name = getRegName(MI->getOperand(1).getReg());
     59     DestName = getRegName(MI->getOperand(0).getReg());
     60     DecodeMOVHLPSMask(2, ShuffleMask);
     61     break;
     62 
     63   case X86::PALIGNR128rr:
     64   case X86::VPALIGNR128rr:
     65     Src1Name = getRegName(MI->getOperand(2).getReg());
     66     // FALL THROUGH.
     67   case X86::PALIGNR128rm:
     68   case X86::VPALIGNR128rm:
     69     Src2Name = getRegName(MI->getOperand(1).getReg());
     70     DestName = getRegName(MI->getOperand(0).getReg());
     71     if(MI->getOperand(MI->getNumOperands()-1).isImm())
     72       DecodePALIGNRMask(MVT::v16i8,
     73                         MI->getOperand(MI->getNumOperands()-1).getImm(),
     74                         ShuffleMask);
     75     break;
     76   case X86::VPALIGNR256rr:
     77     Src1Name = getRegName(MI->getOperand(2).getReg());
     78     // FALL THROUGH.
     79   case X86::VPALIGNR256rm:
     80     Src2Name = getRegName(MI->getOperand(1).getReg());
     81     DestName = getRegName(MI->getOperand(0).getReg());
     82     if(MI->getOperand(MI->getNumOperands()-1).isImm())
     83       DecodePALIGNRMask(MVT::v32i8,
     84                         MI->getOperand(MI->getNumOperands()-1).getImm(),
     85                         ShuffleMask);
     86     break;
     87 
     88   case X86::PSHUFDri:
     89   case X86::VPSHUFDri:
     90     Src1Name = getRegName(MI->getOperand(1).getReg());
     91     // FALL THROUGH.
     92   case X86::PSHUFDmi:
     93   case X86::VPSHUFDmi:
     94     DestName = getRegName(MI->getOperand(0).getReg());
     95     if(MI->getOperand(MI->getNumOperands()-1).isImm())
     96       DecodePSHUFMask(MVT::v4i32,
     97                       MI->getOperand(MI->getNumOperands()-1).getImm(),
     98                       ShuffleMask);
     99     break;
    100   case X86::VPSHUFDYri:
    101     Src1Name = getRegName(MI->getOperand(1).getReg());
    102     // FALL THROUGH.
    103   case X86::VPSHUFDYmi:
    104     DestName = getRegName(MI->getOperand(0).getReg());
    105     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    106       DecodePSHUFMask(MVT::v8i32,
    107                       MI->getOperand(MI->getNumOperands()-1).getImm(),
    108                       ShuffleMask);
    109     break;
    110 
    111 
    112   case X86::PSHUFHWri:
    113   case X86::VPSHUFHWri:
    114     Src1Name = getRegName(MI->getOperand(1).getReg());
    115     // FALL THROUGH.
    116   case X86::PSHUFHWmi:
    117   case X86::VPSHUFHWmi:
    118     DestName = getRegName(MI->getOperand(0).getReg());
    119     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    120       DecodePSHUFHWMask(MVT::v8i16,
    121                         MI->getOperand(MI->getNumOperands()-1).getImm(),
    122                         ShuffleMask);
    123     break;
    124   case X86::VPSHUFHWYri:
    125     Src1Name = getRegName(MI->getOperand(1).getReg());
    126     // FALL THROUGH.
    127   case X86::VPSHUFHWYmi:
    128     DestName = getRegName(MI->getOperand(0).getReg());
    129     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    130       DecodePSHUFHWMask(MVT::v16i16,
    131                         MI->getOperand(MI->getNumOperands()-1).getImm(),
    132                         ShuffleMask);
    133     break;
    134   case X86::PSHUFLWri:
    135   case X86::VPSHUFLWri:
    136     Src1Name = getRegName(MI->getOperand(1).getReg());
    137     // FALL THROUGH.
    138   case X86::PSHUFLWmi:
    139   case X86::VPSHUFLWmi:
    140     DestName = getRegName(MI->getOperand(0).getReg());
    141     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    142       DecodePSHUFLWMask(MVT::v8i16,
    143                         MI->getOperand(MI->getNumOperands()-1).getImm(),
    144                         ShuffleMask);
    145     break;
    146   case X86::VPSHUFLWYri:
    147     Src1Name = getRegName(MI->getOperand(1).getReg());
    148     // FALL THROUGH.
    149   case X86::VPSHUFLWYmi:
    150     DestName = getRegName(MI->getOperand(0).getReg());
    151     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    152       DecodePSHUFLWMask(MVT::v16i16,
    153                         MI->getOperand(MI->getNumOperands()-1).getImm(),
    154                         ShuffleMask);
    155     break;
    156 
    157   case X86::PUNPCKHBWrr:
    158   case X86::VPUNPCKHBWrr:
    159     Src2Name = getRegName(MI->getOperand(2).getReg());
    160     // FALL THROUGH.
    161   case X86::PUNPCKHBWrm:
    162   case X86::VPUNPCKHBWrm:
    163     Src1Name = getRegName(MI->getOperand(1).getReg());
    164     DestName = getRegName(MI->getOperand(0).getReg());
    165     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
    166     break;
    167   case X86::VPUNPCKHBWYrr:
    168     Src2Name = getRegName(MI->getOperand(2).getReg());
    169     // FALL THROUGH.
    170   case X86::VPUNPCKHBWYrm:
    171     Src1Name = getRegName(MI->getOperand(1).getReg());
    172     DestName = getRegName(MI->getOperand(0).getReg());
    173     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
    174     break;
    175   case X86::PUNPCKHWDrr:
    176   case X86::VPUNPCKHWDrr:
    177     Src2Name = getRegName(MI->getOperand(2).getReg());
    178     // FALL THROUGH.
    179   case X86::PUNPCKHWDrm:
    180   case X86::VPUNPCKHWDrm:
    181     Src1Name = getRegName(MI->getOperand(1).getReg());
    182     DestName = getRegName(MI->getOperand(0).getReg());
    183     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
    184     break;
    185   case X86::VPUNPCKHWDYrr:
    186     Src2Name = getRegName(MI->getOperand(2).getReg());
    187     // FALL THROUGH.
    188   case X86::VPUNPCKHWDYrm:
    189     Src1Name = getRegName(MI->getOperand(1).getReg());
    190     DestName = getRegName(MI->getOperand(0).getReg());
    191     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
    192     break;
    193   case X86::PUNPCKHDQrr:
    194   case X86::VPUNPCKHDQrr:
    195     Src2Name = getRegName(MI->getOperand(2).getReg());
    196     // FALL THROUGH.
    197   case X86::PUNPCKHDQrm:
    198   case X86::VPUNPCKHDQrm:
    199     Src1Name = getRegName(MI->getOperand(1).getReg());
    200     DestName = getRegName(MI->getOperand(0).getReg());
    201     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
    202     break;
    203   case X86::VPUNPCKHDQYrr:
    204     Src2Name = getRegName(MI->getOperand(2).getReg());
    205     // FALL THROUGH.
    206   case X86::VPUNPCKHDQYrm:
    207     Src1Name = getRegName(MI->getOperand(1).getReg());
    208     DestName = getRegName(MI->getOperand(0).getReg());
    209     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
    210     break;
    211   case X86::PUNPCKHQDQrr:
    212   case X86::VPUNPCKHQDQrr:
    213     Src2Name = getRegName(MI->getOperand(2).getReg());
    214     // FALL THROUGH.
    215   case X86::PUNPCKHQDQrm:
    216   case X86::VPUNPCKHQDQrm:
    217     Src1Name = getRegName(MI->getOperand(1).getReg());
    218     DestName = getRegName(MI->getOperand(0).getReg());
    219     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
    220     break;
    221   case X86::VPUNPCKHQDQYrr:
    222     Src2Name = getRegName(MI->getOperand(2).getReg());
    223     // FALL THROUGH.
    224   case X86::VPUNPCKHQDQYrm:
    225     Src1Name = getRegName(MI->getOperand(1).getReg());
    226     DestName = getRegName(MI->getOperand(0).getReg());
    227     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
    228     break;
    229 
    230   case X86::PUNPCKLBWrr:
    231   case X86::VPUNPCKLBWrr:
    232     Src2Name = getRegName(MI->getOperand(2).getReg());
    233     // FALL THROUGH.
    234   case X86::PUNPCKLBWrm:
    235   case X86::VPUNPCKLBWrm:
    236     Src1Name = getRegName(MI->getOperand(1).getReg());
    237     DestName = getRegName(MI->getOperand(0).getReg());
    238     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
    239     break;
    240   case X86::VPUNPCKLBWYrr:
    241     Src2Name = getRegName(MI->getOperand(2).getReg());
    242     // FALL THROUGH.
    243   case X86::VPUNPCKLBWYrm:
    244     Src1Name = getRegName(MI->getOperand(1).getReg());
    245     DestName = getRegName(MI->getOperand(0).getReg());
    246     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
    247     break;
    248   case X86::PUNPCKLWDrr:
    249   case X86::VPUNPCKLWDrr:
    250     Src2Name = getRegName(MI->getOperand(2).getReg());
    251     // FALL THROUGH.
    252   case X86::PUNPCKLWDrm:
    253   case X86::VPUNPCKLWDrm:
    254     Src1Name = getRegName(MI->getOperand(1).getReg());
    255     DestName = getRegName(MI->getOperand(0).getReg());
    256     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
    257     break;
    258   case X86::VPUNPCKLWDYrr:
    259     Src2Name = getRegName(MI->getOperand(2).getReg());
    260     // FALL THROUGH.
    261   case X86::VPUNPCKLWDYrm:
    262     Src1Name = getRegName(MI->getOperand(1).getReg());
    263     DestName = getRegName(MI->getOperand(0).getReg());
    264     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
    265     break;
    266   case X86::PUNPCKLDQrr:
    267   case X86::VPUNPCKLDQrr:
    268     Src2Name = getRegName(MI->getOperand(2).getReg());
    269     // FALL THROUGH.
    270   case X86::PUNPCKLDQrm:
    271   case X86::VPUNPCKLDQrm:
    272     Src1Name = getRegName(MI->getOperand(1).getReg());
    273     DestName = getRegName(MI->getOperand(0).getReg());
    274     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
    275     break;
    276   case X86::VPUNPCKLDQYrr:
    277     Src2Name = getRegName(MI->getOperand(2).getReg());
    278     // FALL THROUGH.
    279   case X86::VPUNPCKLDQYrm:
    280     Src1Name = getRegName(MI->getOperand(1).getReg());
    281     DestName = getRegName(MI->getOperand(0).getReg());
    282     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
    283     break;
    284   case X86::PUNPCKLQDQrr:
    285   case X86::VPUNPCKLQDQrr:
    286     Src2Name = getRegName(MI->getOperand(2).getReg());
    287     // FALL THROUGH.
    288   case X86::PUNPCKLQDQrm:
    289   case X86::VPUNPCKLQDQrm:
    290     Src1Name = getRegName(MI->getOperand(1).getReg());
    291     DestName = getRegName(MI->getOperand(0).getReg());
    292     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
    293     break;
    294   case X86::VPUNPCKLQDQYrr:
    295     Src2Name = getRegName(MI->getOperand(2).getReg());
    296     // FALL THROUGH.
    297   case X86::VPUNPCKLQDQYrm:
    298     Src1Name = getRegName(MI->getOperand(1).getReg());
    299     DestName = getRegName(MI->getOperand(0).getReg());
    300     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
    301     break;
    302 
    303   case X86::SHUFPDrri:
    304   case X86::VSHUFPDrri:
    305     Src2Name = getRegName(MI->getOperand(2).getReg());
    306     // FALL THROUGH.
    307   case X86::SHUFPDrmi:
    308   case X86::VSHUFPDrmi:
    309     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    310       DecodeSHUFPMask(MVT::v2f64,
    311                       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     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    321       DecodeSHUFPMask(MVT::v4f64,
    322                       MI->getOperand(MI->getNumOperands()-1).getImm(),
    323                       ShuffleMask);
    324     Src1Name = getRegName(MI->getOperand(1).getReg());
    325     DestName = getRegName(MI->getOperand(0).getReg());
    326     break;
    327 
    328   case X86::SHUFPSrri:
    329   case X86::VSHUFPSrri:
    330     Src2Name = getRegName(MI->getOperand(2).getReg());
    331     // FALL THROUGH.
    332   case X86::SHUFPSrmi:
    333   case X86::VSHUFPSrmi:
    334     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    335       DecodeSHUFPMask(MVT::v4f32,
    336                       MI->getOperand(MI->getNumOperands()-1).getImm(),
    337                       ShuffleMask);
    338     Src1Name = getRegName(MI->getOperand(1).getReg());
    339     DestName = getRegName(MI->getOperand(0).getReg());
    340     break;
    341   case X86::VSHUFPSYrri:
    342     Src2Name = getRegName(MI->getOperand(2).getReg());
    343     // FALL THROUGH.
    344   case X86::VSHUFPSYrmi:
    345     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    346       DecodeSHUFPMask(MVT::v8f32,
    347                       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   case X86::VUNPCKLPDrr:
    355     Src2Name = getRegName(MI->getOperand(2).getReg());
    356     // FALL THROUGH.
    357   case X86::UNPCKLPDrm:
    358   case X86::VUNPCKLPDrm:
    359     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
    360     Src1Name = getRegName(MI->getOperand(1).getReg());
    361     DestName = getRegName(MI->getOperand(0).getReg());
    362     break;
    363   case X86::VUNPCKLPDYrr:
    364     Src2Name = getRegName(MI->getOperand(2).getReg());
    365     // FALL THROUGH.
    366   case X86::VUNPCKLPDYrm:
    367     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
    368     Src1Name = getRegName(MI->getOperand(1).getReg());
    369     DestName = getRegName(MI->getOperand(0).getReg());
    370     break;
    371   case X86::UNPCKLPSrr:
    372   case X86::VUNPCKLPSrr:
    373     Src2Name = getRegName(MI->getOperand(2).getReg());
    374     // FALL THROUGH.
    375   case X86::UNPCKLPSrm:
    376   case X86::VUNPCKLPSrm:
    377     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
    378     Src1Name = getRegName(MI->getOperand(1).getReg());
    379     DestName = getRegName(MI->getOperand(0).getReg());
    380     break;
    381   case X86::VUNPCKLPSYrr:
    382     Src2Name = getRegName(MI->getOperand(2).getReg());
    383     // FALL THROUGH.
    384   case X86::VUNPCKLPSYrm:
    385     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
    386     Src1Name = getRegName(MI->getOperand(1).getReg());
    387     DestName = getRegName(MI->getOperand(0).getReg());
    388     break;
    389   case X86::UNPCKHPDrr:
    390   case X86::VUNPCKHPDrr:
    391     Src2Name = getRegName(MI->getOperand(2).getReg());
    392     // FALL THROUGH.
    393   case X86::UNPCKHPDrm:
    394   case X86::VUNPCKHPDrm:
    395     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
    396     Src1Name = getRegName(MI->getOperand(1).getReg());
    397     DestName = getRegName(MI->getOperand(0).getReg());
    398     break;
    399   case X86::VUNPCKHPDYrr:
    400     Src2Name = getRegName(MI->getOperand(2).getReg());
    401     // FALL THROUGH.
    402   case X86::VUNPCKHPDYrm:
    403     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
    404     Src1Name = getRegName(MI->getOperand(1).getReg());
    405     DestName = getRegName(MI->getOperand(0).getReg());
    406     break;
    407   case X86::UNPCKHPSrr:
    408   case X86::VUNPCKHPSrr:
    409     Src2Name = getRegName(MI->getOperand(2).getReg());
    410     // FALL THROUGH.
    411   case X86::UNPCKHPSrm:
    412   case X86::VUNPCKHPSrm:
    413     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
    414     Src1Name = getRegName(MI->getOperand(1).getReg());
    415     DestName = getRegName(MI->getOperand(0).getReg());
    416     break;
    417   case X86::VUNPCKHPSYrr:
    418     Src2Name = getRegName(MI->getOperand(2).getReg());
    419     // FALL THROUGH.
    420   case X86::VUNPCKHPSYrm:
    421     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
    422     Src1Name = getRegName(MI->getOperand(1).getReg());
    423     DestName = getRegName(MI->getOperand(0).getReg());
    424     break;
    425   case X86::VPERMILPSri:
    426     Src1Name = getRegName(MI->getOperand(1).getReg());
    427     // FALL THROUGH.
    428   case X86::VPERMILPSmi:
    429     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    430       DecodePSHUFMask(MVT::v4f32,
    431                       MI->getOperand(MI->getNumOperands()-1).getImm(),
    432                       ShuffleMask);
    433     DestName = getRegName(MI->getOperand(0).getReg());
    434     break;
    435   case X86::VPERMILPSYri:
    436     Src1Name = getRegName(MI->getOperand(1).getReg());
    437     // FALL THROUGH.
    438   case X86::VPERMILPSYmi:
    439     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    440       DecodePSHUFMask(MVT::v8f32,
    441                       MI->getOperand(MI->getNumOperands()-1).getImm(),
    442                       ShuffleMask);
    443     DestName = getRegName(MI->getOperand(0).getReg());
    444     break;
    445   case X86::VPERMILPDri:
    446     Src1Name = getRegName(MI->getOperand(1).getReg());
    447     // FALL THROUGH.
    448   case X86::VPERMILPDmi:
    449     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    450       DecodePSHUFMask(MVT::v2f64,
    451                       MI->getOperand(MI->getNumOperands()-1).getImm(),
    452                       ShuffleMask);
    453     DestName = getRegName(MI->getOperand(0).getReg());
    454     break;
    455   case X86::VPERMILPDYri:
    456     Src1Name = getRegName(MI->getOperand(1).getReg());
    457     // FALL THROUGH.
    458   case X86::VPERMILPDYmi:
    459     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    460       DecodePSHUFMask(MVT::v4f64,
    461                       MI->getOperand(MI->getNumOperands()-1).getImm(),
    462                       ShuffleMask);
    463     DestName = getRegName(MI->getOperand(0).getReg());
    464     break;
    465   case X86::VPERM2F128rr:
    466   case X86::VPERM2I128rr:
    467     Src2Name = getRegName(MI->getOperand(2).getReg());
    468     // FALL THROUGH.
    469   case X86::VPERM2F128rm:
    470   case X86::VPERM2I128rm:
    471     // For instruction comments purpose, assume the 256-bit vector is v4i64.
    472     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    473       DecodeVPERM2X128Mask(MVT::v4i64,
    474                            MI->getOperand(MI->getNumOperands()-1).getImm(),
    475                            ShuffleMask);
    476     Src1Name = getRegName(MI->getOperand(1).getReg());
    477     DestName = getRegName(MI->getOperand(0).getReg());
    478     break;
    479   case X86::VPERMQYri:
    480   case X86::VPERMPDYri:
    481     Src1Name = getRegName(MI->getOperand(1).getReg());
    482     // FALL THROUGH.
    483   case X86::VPERMQYmi:
    484   case X86::VPERMPDYmi:
    485     if(MI->getOperand(MI->getNumOperands()-1).isImm())
    486       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
    487                       ShuffleMask);
    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) 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] >= (int)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] < (int)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] < (int)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 }
    543