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(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(4, MI->getOperand(MI->getNumOperands()-1).getImm(),
  80                     ShuffleMask);
  81     break;
  82
  83   case X86::PSHUFHWri:
  84   case X86::VPSHUFHWri:
  85     Src1Name = getRegName(MI->getOperand(1).getReg());
  86     // FALL THROUGH.
  87   case X86::PSHUFHWmi:
  88   case X86::VPSHUFHWmi:
  89     DestName = getRegName(MI->getOperand(0).getReg());
  90     DecodePSHUFHWMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
  91                       ShuffleMask);
  92     break;
  93   case X86::PSHUFLWri:
  94   case X86::VPSHUFLWri:
  95     Src1Name = getRegName(MI->getOperand(1).getReg());
  96     // FALL THROUGH.
  97   case X86::PSHUFLWmi:
  98   case X86::VPSHUFLWmi:
  99     DestName = getRegName(MI->getOperand(0).getReg());
 100     DecodePSHUFLWMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 101                       ShuffleMask);
 102     break;
 103
 104   case X86::PUNPCKHBWrr:
 105     Src2Name = getRegName(MI->getOperand(2).getReg());
 106     // FALL THROUGH.
 107   case X86::PUNPCKHBWrm:
 108     Src1Name = getRegName(MI->getOperand(0).getReg());
 109     DecodePUNPCKHMask(16, ShuffleMask);
 110     break;
 111   case X86::PUNPCKHWDrr:
 112     Src2Name = getRegName(MI->getOperand(2).getReg());
 113     // FALL THROUGH.
 114   case X86::PUNPCKHWDrm:
 115     Src1Name = getRegName(MI->getOperand(0).getReg());
 116     DecodePUNPCKHMask(8, ShuffleMask);
 117     break;
 118   case X86::PUNPCKHDQrr:
 119     Src2Name = getRegName(MI->getOperand(2).getReg());
 120     // FALL THROUGH.
 121   case X86::PUNPCKHDQrm:
 122     Src1Name = getRegName(MI->getOperand(0).getReg());
 123     DecodePUNPCKHMask(4, ShuffleMask);
 124     break;
 125   case X86::PUNPCKHQDQrr:
 126     Src2Name = getRegName(MI->getOperand(2).getReg());
 127     // FALL THROUGH.
 128   case X86::PUNPCKHQDQrm:
 129     Src1Name = getRegName(MI->getOperand(0).getReg());
 130     DecodePUNPCKHMask(2, ShuffleMask);
 131     break;
 132
 133   case X86::PUNPCKLBWrr:
 134     Src2Name = getRegName(MI->getOperand(2).getReg());
 135     // FALL THROUGH.
 136   case X86::PUNPCKLBWrm:
 137     Src1Name = getRegName(MI->getOperand(0).getReg());
 138     DecodePUNPCKLBWMask(16, ShuffleMask);
 139     break;
 140   case X86::PUNPCKLWDrr:
 141     Src2Name = getRegName(MI->getOperand(2).getReg());
 142     // FALL THROUGH.
 143   case X86::PUNPCKLWDrm:
 144     Src1Name = getRegName(MI->getOperand(0).getReg());
 145     DecodePUNPCKLWDMask(8, ShuffleMask);
 146     break;
 147   case X86::PUNPCKLDQrr:
 148     Src2Name = getRegName(MI->getOperand(2).getReg());
 149     // FALL THROUGH.
 150   case X86::PUNPCKLDQrm:
 151     Src1Name = getRegName(MI->getOperand(0).getReg());
 152     DecodePUNPCKLDQMask(4, ShuffleMask);
 153     break;
 154   case X86::PUNPCKLQDQrr:
 155     Src2Name = getRegName(MI->getOperand(2).getReg());
 156     // FALL THROUGH.
 157   case X86::PUNPCKLQDQrm:
 158     Src1Name = getRegName(MI->getOperand(0).getReg());
 159     DecodePUNPCKLQDQMask(2, ShuffleMask);
 160     break;
 161
 162   case X86::SHUFPDrri:
 163     Src2Name = getRegName(MI->getOperand(2).getReg());
 164     // FALL THROUGH.
 165   case X86::SHUFPDrmi:
 166     DecodeSHUFPSMask(2, MI->getOperand(3).getImm(), ShuffleMask);
 167     Src1Name = getRegName(MI->getOperand(0).getReg());
 168     break;
 169   case X86::VSHUFPDrri:
 170     Src2Name = getRegName(MI->getOperand(2).getReg());
 171     // FALL THROUGH.
 172   case X86::VSHUFPDrmi:
 173     DecodeSHUFPSMask(2, MI->getOperand(3).getImm(), ShuffleMask);
 174     Src1Name = getRegName(MI->getOperand(1).getReg());
 175     DestName = getRegName(MI->getOperand(0).getReg());
 176     break;
 177
 178   case X86::SHUFPSrri:
 179     Src2Name = getRegName(MI->getOperand(2).getReg());
 180     // FALL THROUGH.
 181   case X86::SHUFPSrmi:
 182     DecodeSHUFPSMask(4, MI->getOperand(3).getImm(), ShuffleMask);
 183     Src1Name = getRegName(MI->getOperand(0).getReg());
 184     break;
 185   case X86::VSHUFPSrri:
 186     Src2Name = getRegName(MI->getOperand(2).getReg());
 187     // FALL THROUGH.
 188   case X86::VSHUFPSrmi:
 189     DecodeSHUFPSMask(4, MI->getOperand(3).getImm(), ShuffleMask);
 190     Src1Name = getRegName(MI->getOperand(1).getReg());
 191     DestName = getRegName(MI->getOperand(0).getReg());
 192     break;
 193
 194   case X86::UNPCKLPDrr:
 195     Src2Name = getRegName(MI->getOperand(2).getReg());
 196     // FALL THROUGH.
 197   case X86::UNPCKLPDrm:
 198     DecodeUNPCKLPMask(MVT::v2f64, ShuffleMask);
 199     Src1Name = getRegName(MI->getOperand(0).getReg());
 200     break;
 201   case X86::VUNPCKLPDrr:
 202     Src2Name = getRegName(MI->getOperand(2).getReg());
 203     // FALL THROUGH.
 204   case X86::VUNPCKLPDrm:
 205     DecodeUNPCKLPMask(MVT::v2f64, ShuffleMask);
 206     Src1Name = getRegName(MI->getOperand(1).getReg());
 207     DestName = getRegName(MI->getOperand(0).getReg());
 208     break;
 209   case X86::VUNPCKLPDYrr:
 210     Src2Name = getRegName(MI->getOperand(2).getReg());
 211     // FALL THROUGH.
 212   case X86::VUNPCKLPDYrm:
 213     DecodeUNPCKLPMask(MVT::v4f64, ShuffleMask);
 214     Src1Name = getRegName(MI->getOperand(1).getReg());
 215     DestName = getRegName(MI->getOperand(0).getReg());
 216     break;
 217   case X86::UNPCKLPSrr:
 218     Src2Name = getRegName(MI->getOperand(2).getReg());
 219     // FALL THROUGH.
 220   case X86::UNPCKLPSrm:
 221     DecodeUNPCKLPMask(MVT::v4f32, ShuffleMask);
 222     Src1Name = getRegName(MI->getOperand(0).getReg());
 223     break;
 224   case X86::VUNPCKLPSrr:
 225     Src2Name = getRegName(MI->getOperand(2).getReg());
 226     // FALL THROUGH.
 227   case X86::VUNPCKLPSrm:
 228     DecodeUNPCKLPMask(MVT::v4f32, ShuffleMask);
 229     Src1Name = getRegName(MI->getOperand(1).getReg());
 230     DestName = getRegName(MI->getOperand(0).getReg());
 231     break;
 232   case X86::VUNPCKLPSYrr:
 233     Src2Name = getRegName(MI->getOperand(2).getReg());
 234     // FALL THROUGH.
 235   case X86::VUNPCKLPSYrm:
 236     DecodeUNPCKLPMask(MVT::v8f32, ShuffleMask);
 237     Src1Name = getRegName(MI->getOperand(1).getReg());
 238     DestName = getRegName(MI->getOperand(0).getReg());
 239     break;
 240   case X86::UNPCKHPDrr:
 241     Src2Name = getRegName(MI->getOperand(2).getReg());
 242     // FALL THROUGH.
 243   case X86::UNPCKHPDrm:
 244     DecodeUNPCKHPMask(MVT::v2f64, ShuffleMask);
 245     Src1Name = getRegName(MI->getOperand(0).getReg());
 246     break;
 247   case X86::VUNPCKHPDrr:
 248     Src2Name = getRegName(MI->getOperand(2).getReg());
 249     // FALL THROUGH.
 250   case X86::VUNPCKHPDrm:
 251     DecodeUNPCKHPMask(MVT::v2f64, ShuffleMask);
 252     Src1Name = getRegName(MI->getOperand(1).getReg());
 253     DestName = getRegName(MI->getOperand(0).getReg());
 254     break;
 255   case X86::VUNPCKHPDYrr:
 256     Src2Name = getRegName(MI->getOperand(2).getReg());
 257     // FALL THROUGH.
 258   case X86::VUNPCKHPDYrm:
 259     DecodeUNPCKLPMask(MVT::v4f64, ShuffleMask);
 260     Src1Name = getRegName(MI->getOperand(1).getReg());
 261     DestName = getRegName(MI->getOperand(0).getReg());
 262     break;
 263   case X86::UNPCKHPSrr:
 264     Src2Name = getRegName(MI->getOperand(2).getReg());
 265     // FALL THROUGH.
 266   case X86::UNPCKHPSrm:
 267     DecodeUNPCKHPMask(MVT::v4f32, ShuffleMask);
 268     Src1Name = getRegName(MI->getOperand(0).getReg());
 269     break;
 270   case X86::VUNPCKHPSrr:
 271     Src2Name = getRegName(MI->getOperand(2).getReg());
 272     // FALL THROUGH.
 273   case X86::VUNPCKHPSrm:
 274     DecodeUNPCKHPMask(MVT::v4f32, ShuffleMask);
 275     Src1Name = getRegName(MI->getOperand(1).getReg());
 276     DestName = getRegName(MI->getOperand(0).getReg());
 277     break;
 278   case X86::VUNPCKHPSYrr:
 279     Src2Name = getRegName(MI->getOperand(2).getReg());
 280     // FALL THROUGH.
 281   case X86::VUNPCKHPSYrm:
 282     DecodeUNPCKHPMask(MVT::v8f32, ShuffleMask);
 283     Src1Name = getRegName(MI->getOperand(1).getReg());
 284     DestName = getRegName(MI->getOperand(0).getReg());
 285     break;
 286   case X86::VPERMILPSri:
 287     DecodeVPERMILPSMask(4, MI->getOperand(2).getImm(),
 288                         ShuffleMask);
 289     Src1Name = getRegName(MI->getOperand(0).getReg());
 290     break;
 291   case X86::VPERMILPSYri:
 292     DecodeVPERMILPSMask(8, MI->getOperand(2).getImm(),
 293                         ShuffleMask);
 294     Src1Name = getRegName(MI->getOperand(0).getReg());
 295     break;
 296   case X86::VPERMILPDri:
 297     DecodeVPERMILPDMask(2, MI->getOperand(2).getImm(),
 298                         ShuffleMask);
 299     Src1Name = getRegName(MI->getOperand(0).getReg());
 300     break;
 301   case X86::VPERMILPDYri:
 302     DecodeVPERMILPDMask(4, MI->getOperand(2).getImm(),
 303                         ShuffleMask);
 304     Src1Name = getRegName(MI->getOperand(0).getReg());
 305     break;
 306   case X86::VPERM2F128rr:
 307     DecodeVPERM2F128Mask(MI->getOperand(3).getImm(), ShuffleMask);
 308     Src1Name = getRegName(MI->getOperand(1).getReg());
 309     Src2Name = getRegName(MI->getOperand(2).getReg());
 310     break;
 311   }
 312
 313
 314   // If this was a shuffle operation, print the shuffle mask.
 315   if (!ShuffleMask.empty()) {
 316     if (DestName == 0) DestName = Src1Name;
 317     OS << (DestName ? DestName : "mem") << " = ";
 318
 319     // If the two sources are the same, canonicalize the input elements to be
 320     // from the first src so that we get larger element spans.
 321     if (Src1Name == Src2Name) {
 322       for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 323         if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 324             ShuffleMask[i] >= e)        // From second mask.
 325           ShuffleMask[i] -= e;
 326       }
 327     }
 328
 329     // The shuffle mask specifies which elements of the src1/src2 fill in the
 330     // destination, with a few sentinel values.  Loop through and print them
 331     // out.
 332     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 333       if (i != 0)
 334         OS << ',';
 335       if (ShuffleMask[i] == SM_SentinelZero) {
 336         OS << "zero";
 337         continue;
 338       }
 339
 340       // Otherwise, it must come from src1 or src2.  Print the span of elements
 341       // that comes from this src.
 342       bool isSrc1 = ShuffleMask[i] < ShuffleMask.size();
 343       const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 344       OS << (SrcName ? SrcName : "mem") << '[';
 345       bool IsFirst = true;
 346       while (i != e &&
 347              (int)ShuffleMask[i] >= 0 &&
 348              (ShuffleMask[i] < ShuffleMask.size()) == isSrc1) {
 349         if (!IsFirst)
 350           OS << ',';
 351         else
 352           IsFirst = false;
 353         OS << ShuffleMask[i] % ShuffleMask.size();
 354         ++i;
 355       }
 356       OS << ']';
 357       --i;  // For loop increments element #.
 358     }
 359     //MI->print(OS, 0);
 360     OS << "\n";
 361   }
 362
 363 }