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