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