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     DecodeSHUFPMask(MVT::v2f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
 167                     ShuffleMask);
 168     Src1Name = getRegName(MI->getOperand(0).getReg());
 169     break;
 170   case X86::VSHUFPDrri:
 171     Src2Name = getRegName(MI->getOperand(2).getReg());
 172     // FALL THROUGH.
 173   case X86::VSHUFPDrmi:
 174     DecodeSHUFPMask(MVT::v2f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
 175                     ShuffleMask);
 176     Src1Name = getRegName(MI->getOperand(1).getReg());
 177     DestName = getRegName(MI->getOperand(0).getReg());
 178     break;
 179   case X86::VSHUFPDYrri:
 180     Src2Name = getRegName(MI->getOperand(2).getReg());
 181     // FALL THROUGH.
 182   case X86::VSHUFPDYrmi:
 183     DecodeSHUFPMask(MVT::v4f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
 184                     ShuffleMask);
 185     Src1Name = getRegName(MI->getOperand(1).getReg());
 186     DestName = getRegName(MI->getOperand(0).getReg());
 187     break;
 188
 189   case X86::SHUFPSrri:
 190     Src2Name = getRegName(MI->getOperand(2).getReg());
 191     // FALL THROUGH.
 192   case X86::SHUFPSrmi:
 193     DecodeSHUFPMask(MVT::v4f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
 194                     ShuffleMask);
 195     Src1Name = getRegName(MI->getOperand(0).getReg());
 196     break;
 197   case X86::VSHUFPSrri:
 198     Src2Name = getRegName(MI->getOperand(2).getReg());
 199     // FALL THROUGH.
 200   case X86::VSHUFPSrmi:
 201     DecodeSHUFPMask(MVT::v4f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
 202                     ShuffleMask);
 203     Src1Name = getRegName(MI->getOperand(1).getReg());
 204     DestName = getRegName(MI->getOperand(0).getReg());
 205     break;
 206   case X86::VSHUFPSYrri:
 207     Src2Name = getRegName(MI->getOperand(2).getReg());
 208     // FALL THROUGH.
 209   case X86::VSHUFPSYrmi:
 210     DecodeSHUFPMask(MVT::v8f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
 211                     ShuffleMask);
 212     Src1Name = getRegName(MI->getOperand(1).getReg());
 213     DestName = getRegName(MI->getOperand(0).getReg());
 214     break;
 215
 216   case X86::UNPCKLPDrr:
 217     Src2Name = getRegName(MI->getOperand(2).getReg());
 218     // FALL THROUGH.
 219   case X86::UNPCKLPDrm:
 220     DecodeUNPCKLPMask(MVT::v2f64, ShuffleMask);
 221     Src1Name = getRegName(MI->getOperand(0).getReg());
 222     break;
 223   case X86::VUNPCKLPDrr:
 224     Src2Name = getRegName(MI->getOperand(2).getReg());
 225     // FALL THROUGH.
 226   case X86::VUNPCKLPDrm:
 227     DecodeUNPCKLPMask(MVT::v2f64, ShuffleMask);
 228     Src1Name = getRegName(MI->getOperand(1).getReg());
 229     DestName = getRegName(MI->getOperand(0).getReg());
 230     break;
 231   case X86::VUNPCKLPDYrr:
 232     Src2Name = getRegName(MI->getOperand(2).getReg());
 233     // FALL THROUGH.
 234   case X86::VUNPCKLPDYrm:
 235     DecodeUNPCKLPMask(MVT::v4f64, ShuffleMask);
 236     Src1Name = getRegName(MI->getOperand(1).getReg());
 237     DestName = getRegName(MI->getOperand(0).getReg());
 238     break;
 239   case X86::UNPCKLPSrr:
 240     Src2Name = getRegName(MI->getOperand(2).getReg());
 241     // FALL THROUGH.
 242   case X86::UNPCKLPSrm:
 243     DecodeUNPCKLPMask(MVT::v4f32, ShuffleMask);
 244     Src1Name = getRegName(MI->getOperand(0).getReg());
 245     break;
 246   case X86::VUNPCKLPSrr:
 247     Src2Name = getRegName(MI->getOperand(2).getReg());
 248     // FALL THROUGH.
 249   case X86::VUNPCKLPSrm:
 250     DecodeUNPCKLPMask(MVT::v4f32, ShuffleMask);
 251     Src1Name = getRegName(MI->getOperand(1).getReg());
 252     DestName = getRegName(MI->getOperand(0).getReg());
 253     break;
 254   case X86::VUNPCKLPSYrr:
 255     Src2Name = getRegName(MI->getOperand(2).getReg());
 256     // FALL THROUGH.
 257   case X86::VUNPCKLPSYrm:
 258     DecodeUNPCKLPMask(MVT::v8f32, ShuffleMask);
 259     Src1Name = getRegName(MI->getOperand(1).getReg());
 260     DestName = getRegName(MI->getOperand(0).getReg());
 261     break;
 262   case X86::UNPCKHPDrr:
 263     Src2Name = getRegName(MI->getOperand(2).getReg());
 264     // FALL THROUGH.
 265   case X86::UNPCKHPDrm:
 266     DecodeUNPCKHPMask(MVT::v2f64, ShuffleMask);
 267     Src1Name = getRegName(MI->getOperand(0).getReg());
 268     break;
 269   case X86::VUNPCKHPDrr:
 270     Src2Name = getRegName(MI->getOperand(2).getReg());
 271     // FALL THROUGH.
 272   case X86::VUNPCKHPDrm:
 273     DecodeUNPCKHPMask(MVT::v2f64, ShuffleMask);
 274     Src1Name = getRegName(MI->getOperand(1).getReg());
 275     DestName = getRegName(MI->getOperand(0).getReg());
 276     break;
 277   case X86::VUNPCKHPDYrr:
 278     Src2Name = getRegName(MI->getOperand(2).getReg());
 279     // FALL THROUGH.
 280   case X86::VUNPCKHPDYrm:
 281     DecodeUNPCKLPMask(MVT::v4f64, ShuffleMask);
 282     Src1Name = getRegName(MI->getOperand(1).getReg());
 283     DestName = getRegName(MI->getOperand(0).getReg());
 284     break;
 285   case X86::UNPCKHPSrr:
 286     Src2Name = getRegName(MI->getOperand(2).getReg());
 287     // FALL THROUGH.
 288   case X86::UNPCKHPSrm:
 289     DecodeUNPCKHPMask(MVT::v4f32, ShuffleMask);
 290     Src1Name = getRegName(MI->getOperand(0).getReg());
 291     break;
 292   case X86::VUNPCKHPSrr:
 293     Src2Name = getRegName(MI->getOperand(2).getReg());
 294     // FALL THROUGH.
 295   case X86::VUNPCKHPSrm:
 296     DecodeUNPCKHPMask(MVT::v4f32, ShuffleMask);
 297     Src1Name = getRegName(MI->getOperand(1).getReg());
 298     DestName = getRegName(MI->getOperand(0).getReg());
 299     break;
 300   case X86::VUNPCKHPSYrr:
 301     Src2Name = getRegName(MI->getOperand(2).getReg());
 302     // FALL THROUGH.
 303   case X86::VUNPCKHPSYrm:
 304     DecodeUNPCKHPMask(MVT::v8f32, ShuffleMask);
 305     Src1Name = getRegName(MI->getOperand(1).getReg());
 306     DestName = getRegName(MI->getOperand(0).getReg());
 307     break;
 308   case X86::VPERMILPSri:
 309     Src1Name = getRegName(MI->getOperand(1).getReg());
 310     // FALL THROUGH.
 311   case X86::VPERMILPSmi:
 312     DecodeVPERMILPSMask(4, MI->getOperand(MI->getNumOperands()-1).getImm(),
 313                         ShuffleMask);
 314     DestName = getRegName(MI->getOperand(0).getReg());
 315     break;
 316   case X86::VPERMILPSYri:
 317     Src1Name = getRegName(MI->getOperand(1).getReg());
 318     // FALL THROUGH.
 319   case X86::VPERMILPSYmi:
 320     DecodeVPERMILPSMask(8, MI->getOperand(MI->getNumOperands()-1).getImm(),
 321                         ShuffleMask);
 322     DestName = getRegName(MI->getOperand(0).getReg());
 323     break;
 324   case X86::VPERMILPDri:
 325     Src1Name = getRegName(MI->getOperand(1).getReg());
 326     // FALL THROUGH.
 327   case X86::VPERMILPDmi:
 328     DecodeVPERMILPDMask(2, MI->getOperand(MI->getNumOperands()-1).getImm(),
 329                         ShuffleMask);
 330     DestName = getRegName(MI->getOperand(0).getReg());
 331     break;
 332   case X86::VPERMILPDYri:
 333     Src1Name = getRegName(MI->getOperand(1).getReg());
 334     // FALL THROUGH.
 335   case X86::VPERMILPDYmi:
 336     DecodeVPERMILPDMask(4, MI->getOperand(MI->getNumOperands()-1).getImm(),
 337                         ShuffleMask);
 338     DestName = getRegName(MI->getOperand(0).getReg());
 339     break;
 340   case X86::VPERM2F128rr:
 341   case X86::VPERM2I128rr:
 342     Src2Name = getRegName(MI->getOperand(2).getReg());
 343     // FALL THROUGH.
 344   case X86::VPERM2F128rm:
 345   case X86::VPERM2I128rm:
 346     DecodeVPERM2F128Mask(MI->getOperand(MI->getNumOperands()-1).getImm(),
 347                          ShuffleMask);
 348     Src1Name = getRegName(MI->getOperand(1).getReg());
 349     DestName = getRegName(MI->getOperand(0).getReg());
 350     break;
 351   }
 352
 353
 354   // If this was a shuffle operation, print the shuffle mask.
 355   if (!ShuffleMask.empty()) {
 356     if (DestName == 0) DestName = Src1Name;
 357     OS << (DestName ? DestName : "mem") << " = ";
 358
 359     // If the two sources are the same, canonicalize the input elements to be
 360     // from the first src so that we get larger element spans.
 361     if (Src1Name == Src2Name) {
 362       for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 363         if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
 364             ShuffleMask[i] >= e)        // From second mask.
 365           ShuffleMask[i] -= e;
 366       }
 367     }
 368
 369     // The shuffle mask specifies which elements of the src1/src2 fill in the
 370     // destination, with a few sentinel values.  Loop through and print them
 371     // out.
 372     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
 373       if (i != 0)
 374         OS << ',';
 375       if (ShuffleMask[i] == SM_SentinelZero) {
 376         OS << "zero";
 377         continue;
 378       }
 379
 380       // Otherwise, it must come from src1 or src2.  Print the span of elements
 381       // that comes from this src.
 382       bool isSrc1 = ShuffleMask[i] < ShuffleMask.size();
 383       const char *SrcName = isSrc1 ? Src1Name : Src2Name;
 384       OS << (SrcName ? SrcName : "mem") << '[';
 385       bool IsFirst = true;
 386       while (i != e &&
 387              (int)ShuffleMask[i] >= 0 &&
 388              (ShuffleMask[i] < ShuffleMask.size()) == isSrc1) {
 389         if (!IsFirst)
 390           OS << ',';
 391         else
 392           IsFirst = false;
 393         OS << ShuffleMask[i] % ShuffleMask.size();
 394         ++i;
 395       }
 396       OS << ']';
 397       --i;  // For loop increments element #.
 398     }
 399     //MI->print(OS, 0);
 400     OS << "\n";
 401   }
 402
 403 }