lib/Target/X86/InstPrinter/X86InstComments.cpp

   1 //===-- X86InstComments.cpp - Generate verbose-asm comments for instrs ----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This defines functionality used to emit comments about X86 instructions to
  11 // an output stream for -fverbose-asm.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "X86InstComments.h"
  16 #include "MCTargetDesc/X86MCTargetDesc.h"
  17 #include "Utils/X86ShuffleDecode.h"
  18 #include "llvm/MC/MCInst.h"
  19 #include "llvm/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<unsigned, 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(1).getReg());
  38     Src2Name = getRegName(MI->getOperand(2).getReg());
  39     DecodeINSERTPSMask(MI->getOperand(3).getImm(), ShuffleMask);
  40     break;
  41
  42   case X86::MOVLHPSrr:
  43     Src2Name = getRegName(MI->getOperand(2).getReg());
  44     Src1Name = getRegName(MI->getOperand(0).getReg());
  45     DecodeMOVLHPSMask(2, ShuffleMask);
  46     break;
  47
  48   case X86::MOVHLPSrr:
  49     Src2Name = getRegName(MI->getOperand(2).getReg());
  50     Src1Name = getRegName(MI->getOperand(0).getReg());
  51     DecodeMOVHLPSMask(2, ShuffleMask);
  52     break;
  53
  54   case X86::PSHUFDri:
  55     Src1Name = getRegName(MI->getOperand(1).getReg());
  56     // FALL THROUGH.
  57   case X86::PSHUFDmi:
  58     DestName = getRegName(MI->getOperand(0).getReg());
  59     DecodePSHUFMask(4, MI->getOperand(MI->getNumOperands()-1).getImm(),
  60                     ShuffleMask);
  61     break;
  62
  63   case X86::PSHUFHWri:
  64     Src1Name = getRegName(MI->getOperand(1).getReg());
  65     // FALL THROUGH.
  66   case X86::PSHUFHWmi:
  67     DestName = getRegName(MI->getOperand(0).getReg());
  68     DecodePSHUFHWMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
  69                       ShuffleMask);
  70     break;
  71   case X86::PSHUFLWri:
  72     Src1Name = getRegName(MI->getOperand(1).getReg());
  73     // FALL THROUGH.
  74   case X86::PSHUFLWmi:
  75     DestName = getRegName(MI->getOperand(0).getReg());
  76     DecodePSHUFLWMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
  77                       ShuffleMask);
  78     break;
  79
  80   case X86::PUNPCKHBWrr:
  81     Src2Name = getRegName(MI->getOperand(2).getReg());
  82     // FALL THROUGH.
  83   case X86::PUNPCKHBWrm:
  84     Src1Name = getRegName(MI->getOperand(0).getReg());
  85     DecodePUNPCKHMask(16, ShuffleMask);
  86     break;
  87   case X86::PUNPCKHWDrr:
  88     Src2Name = getRegName(MI->getOperand(2).getReg());
  89     // FALL THROUGH.
  90   case X86::PUNPCKHWDrm:
  91     Src1Name = getRegName(MI->getOperand(0).getReg());
  92     DecodePUNPCKHMask(8, ShuffleMask);
  93     break;
  94   case X86::PUNPCKHDQrr:
  95     Src2Name = getRegName(MI->getOperand(2).getReg());
  96     // FALL THROUGH.
  97   case X86::PUNPCKHDQrm:
  98     Src1Name = getRegName(MI->getOperand(0).getReg());
  99     DecodePUNPCKHMask(4, ShuffleMask);
 100     break;
 101   case X86::PUNPCKHQDQrr:
 102     Src2Name = getRegName(MI->getOperand(2).getReg());
 103     // FALL THROUGH.
 104   case X86::PUNPCKHQDQrm:
 105     Src1Name = getRegName(MI->getOperand(0).getReg());
 106     DecodePUNPCKHMask(2, ShuffleMask);
 107     break;
 108
 109   case X86::PUNPCKLBWrr:
 110     Src2Name = getRegName(MI->getOperand(2).getReg());
 111     // FALL THROUGH.
 112   case X86::PUNPCKLBWrm:
 113     Src1Name = getRegName(MI->getOperand(0).getReg());
 114     DecodePUNPCKLBWMask(16, ShuffleMask);
 115     break;
 116   case X86::PUNPCKLWDrr:
 117     Src2Name = getRegName(MI->getOperand(2).getReg());
 118     // FALL THROUGH.
 119   case X86::PUNPCKLWDrm:
 120     Src1Name = getRegName(MI->getOperand(0).getReg());
 121     DecodePUNPCKLWDMask(8, ShuffleMask);
 122     break;
 123   case X86::PUNPCKLDQrr:
 124     Src2Name = getRegName(MI->getOperand(2).getReg());
 125     // FALL THROUGH.
 126   case X86::PUNPCKLDQrm:
 127     Src1Name = getRegName(MI->getOperand(0).getReg());
 128     DecodePUNPCKLDQMask(4, ShuffleMask);
 129     break;
 130   case X86::PUNPCKLQDQrr:
 131     Src2Name = getRegName(MI->getOperand(2).getReg());
 132     // FALL THROUGH.
 133   case X86::PUNPCKLQDQrm:
 134     Src1Name = getRegName(MI->getOperand(0).getReg());
 135     DecodePUNPCKLQDQMask(2, ShuffleMask);
 136     break;
 137
 138   case X86::SHUFPDrri:
 139     Src2Name = getRegName(MI->getOperand(2).getReg());
 140     // FALL THROUGH.
 141   case X86::SHUFPDrmi:
 142     DecodeSHUFPSMask(2, MI->getOperand(3).getImm(), ShuffleMask);
 143     Src1Name = getRegName(MI->getOperand(0).getReg());
 144     break;
 145
 146   case X86::SHUFPSrri:
 147     Src2Name = getRegName(MI->getOperand(2).getReg());
 148     // FALL THROUGH.
 149   case X86::SHUFPSrmi:
 150     DecodeSHUFPSMask(4, MI->getOperand(3).getImm(), ShuffleMask);
 151     Src1Name = getRegName(MI->getOperand(0).getReg());
 152     break;
 153
 154   case X86::UNPCKLPDrr:
 155     Src2Name = getRegName(MI->getOperand(2).getReg());
 156     // FALL THROUGH.
 157   case X86::UNPCKLPDrm:
 158     DecodeUNPCKLPDMask(2, ShuffleMask);
 159     Src1Name = getRegName(MI->getOperand(0).getReg());
 160     break;
 161   case X86::VUNPCKLPDrr:
 162     Src2Name = getRegName(MI->getOperand(2).getReg());
 163     // FALL THROUGH.
 164   case X86::VUNPCKLPDrm:
 165     DecodeUNPCKLPDMask(2, ShuffleMask);
 166     Src1Name = getRegName(MI->getOperand(1).getReg());
 167     break;
 168   case X86::VUNPCKLPDYrr:
 169     Src2Name = getRegName(MI->getOperand(2).getReg());
 170     // FALL THROUGH.
 171   case X86::VUNPCKLPDYrm:
 172     DecodeUNPCKLPDMask(4, ShuffleMask);
 173     Src1Name = getRegName(MI->getOperand(1).getReg());
 174     break;
 175   case X86::UNPCKLPSrr:
 176     Src2Name = getRegName(MI->getOperand(2).getReg());
 177     // FALL THROUGH.
 178   case X86::UNPCKLPSrm:
 179     DecodeUNPCKLPSMask(4, ShuffleMask);
 180     Src1Name = getRegName(MI->getOperand(0).getReg());
 181     break;
 182   case X86::VUNPCKLPSrr:
 183     Src2Name = getRegName(MI->getOperand(2).getReg());
 184     // FALL THROUGH.
 185   case X86::VUNPCKLPSrm:
 186     DecodeUNPCKLPSMask(4, ShuffleMask);
 187     Src1Name = getRegName(MI->getOperand(1).getReg());
 188     break;
 189   case X86::VUNPCKLPSYrr:
 190     Src2Name = getRegName(MI->getOperand(2).getReg());
 191     // FALL THROUGH.
 192   case X86::VUNPCKLPSYrm:
 193     DecodeUNPCKLPSMask(8, ShuffleMask);
 194     Src1Name = getRegName(MI->getOperand(1).getReg());
 195     break;
 196   case X86::UNPCKHPDrr:
 197     Src2Name = getRegName(MI->getOperand(2).getReg());
 198     // FALL THROUGH.
 199   case X86::UNPCKHPDrm:
 200     DecodeUNPCKHPDMask(2, ShuffleMask);
 201     Src1Name = getRegName(MI->getOperand(0).getReg());
 202     break;
 203   case X86::VUNPCKHPDrr:
 204     Src2Name = getRegName(MI->getOperand(2).getReg());
 205     // FALL THROUGH.
 206   case X86::VUNPCKHPDrm:
 207     DecodeUNPCKHPDMask(2, ShuffleMask);
 208     Src1Name = getRegName(MI->getOperand(1).getReg());
 209     break;
 210   case X86::VUNPCKHPDYrr:
 211     Src2Name = getRegName(MI->getOperand(2).getReg());
 212     // FALL THROUGH.
 213   case X86::VUNPCKHPDYrm:
 214     DecodeUNPCKLPDMask(4, ShuffleMask);
 215     Src1Name = getRegName(MI->getOperand(1).getReg());
 216     break;
 217   case X86::UNPCKHPSrr:
 218     Src2Name = getRegName(MI->getOperand(2).getReg());
 219     // FALL THROUGH.
 220   case X86::UNPCKHPSrm:
 221     DecodeUNPCKHPSMask(4, ShuffleMask);
 222     Src1Name = getRegName(MI->getOperand(0).getReg());
 223     break;
 224   case X86::VUNPCKHPSrr:
 225     Src2Name = getRegName(MI->getOperand(2).getReg());
 226     // FALL THROUGH.
 227   case X86::VUNPCKHPSrm:
 228     DecodeUNPCKHPSMask(4, ShuffleMask);
 229     Src1Name = getRegName(MI->getOperand(1).getReg());
 230     break;
 231   case X86::VUNPCKHPSYrr:
 232     Src2Name = getRegName(MI->getOperand(2).getReg());
 233     // FALL THROUGH.
 234   case X86::VUNPCKHPSYrm:
 235     DecodeUNPCKHPSMask(8, ShuffleMask);
 236     Src1Name = getRegName(MI->getOperand(1).getReg());
 237     break;
 238   case X86::VPERMILPSri:
 239     DecodeVPERMILPSMask(4, MI->getOperand(2).getImm(),
 240                         ShuffleMask);
 241     Src1Name = getRegName(MI->getOperand(0).getReg());
 242     break;
 243   case X86::VPERMILPSYri:
 244     DecodeVPERMILPSMask(8, MI->getOperand(2).getImm(),
 245                         ShuffleMask);
 246     Src1Name = getRegName(MI->getOperand(0).getReg());
 247     break;
 248   case X86::VPERMILPDri:
 249     DecodeVPERMILPDMask(2, MI->getOperand(2).getImm(),
 250                         ShuffleMask);
 251     Src1Name = getRegName(MI->getOperand(0).getReg());
 252     break;
 253   case X86::VPERMILPDYri:
 254     DecodeVPERMILPDMask(4, MI->getOperand(2).getImm(),
 255                         ShuffleMask);
 256     Src1Name = getRegName(MI->getOperand(0).getReg());
 257     break;
 258   case X86::VPERM2F128rr:
 259     DecodeVPERM2F128Mask(MI->getOperand(3).getImm(), ShuffleMask);
 260     Src1Name = getRegName(MI->getOperand(1).getReg());
 261     Src2Name = getRegName(MI->getOperand(2).getReg());
 262     break;
 263   }
 264
 265
 266   // If this was a shuffle operation, print the shuffle mask.
 267   if (!ShuffleMask.empty()) {
 268     if (DestName == 0) DestName = Src1Name;
 269     OS << (DestName ? DestName : "mem") << " = ";
 270
 271     // If the two sources are the same, canonicalize the input elements to be
 272     // from the first src so that we get larger element spans.
 273     if (Src1Name == Src2Name) {
 274       for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 275         if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 276             ShuffleMask[i] >= e)        // From second mask.
 277           ShuffleMask[i] -= e;
 278       }
 279     }
 280
 281     // The shuffle mask specifies which elements of the src1/src2 fill in the
 282     // destination, with a few sentinel values.  Loop through and print them
 283     // out.
 284     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 285       if (i != 0)
 286         OS << ',';
 287       if (ShuffleMask[i] == SM_SentinelZero) {
 288         OS << "zero";
 289         continue;
 290       }
 291
 292       // Otherwise, it must come from src1 or src2.  Print the span of elements
 293       // that comes from this src.
 294       bool isSrc1 = ShuffleMask[i] < ShuffleMask.size();
 295       const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 296       OS << (SrcName ? SrcName : "mem") << '[';
 297       bool IsFirst = true;
 298       while (i != e &&
 299              (int)ShuffleMask[i] >= 0 &&
 300              (ShuffleMask[i] < ShuffleMask.size()) == isSrc1) {
 301         if (!IsFirst)
 302           OS << ',';
 303         else
 304           IsFirst = false;
 305         OS << ShuffleMask[i] % ShuffleMask.size();
 306         ++i;
 307       }
 308       OS << ']';
 309       --i;  // For loop increments element #.
 310     }
 311     //MI->print(OS, 0);
 312     OS << "\n";
 313   }
 314
 315 }