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