lib/Target/X86/X86AsmPrinter.cpp

   1 //===-- X86/Printer.cpp - Convert X86 code to human readable rep. ---------===//
   2 //
   3 // This file contains a printer that converts from our internal representation
   4 // of LLVM code to a nice human readable form that is suitable for debuggging.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #include "X86.h"
   9 #include "X86InstrInfo.h"
  10 #include "llvm/Pass.h"
  11 #include "llvm/Function.h"
  12 #include "llvm/Target/TargetMachine.h"
  13 #include "llvm/CodeGen/MachineFunction.h"
  14 #include "llvm/CodeGen/MachineInstr.h"
  15 #include "Support/Statistic.h"
  16
  17 namespace {
  18   struct Printer : public FunctionPass {
  19     TargetMachine &TM;
  20     std::ostream &O;
  21
  22     Printer(TargetMachine &tm, std::ostream &o) : TM(tm), O(o) {}
  23
  24     virtual const char *getPassName() const {
  25       return "X86 Assembly Printer";
  26     }
  27
  28     bool runOnFunction(Function &F);
  29   };
  30 }
  31
  32 /// createX86CodePrinterPass - Print out the specified machine code function to
  33 /// the specified stream.  This function should work regardless of whether or
  34 /// not the function is in SSA form or not.
  35 ///
  36 Pass *createX86CodePrinterPass(TargetMachine &TM, std::ostream &O) {
  37   return new Printer(TM, O);
  38 }
  39
  40
  41 /// runOnFunction - This uses the X86InstructionInfo::print method
  42 /// to print assembly for each instruction.
  43 bool Printer::runOnFunction (Function & F)
  44 {
  45   static unsigned bbnumber = 0;
  46   MachineFunction & MF = MachineFunction::get (&F);
  47   const MachineInstrInfo & MII = TM.getInstrInfo ();
  48
  49   // Print out labels for the function.
  50   O << "\t.globl\t" << F.getName () << "\n";
  51   O << "\t.type\t" << F.getName () << ", @function\n";
  52   O << F.getName () << ":\n";
  53
  54   // Print out code for the function.
  55   for (MachineFunction::const_iterator bb_i = MF.begin (), bb_e = MF.end ();
  56        bb_i != bb_e; ++bb_i)
  57     {
  58       // Print a label for the basic block.
  59       O << ".BB" << bbnumber++ << ":\n";
  60       for (MachineBasicBlock::const_iterator i_i = bb_i->begin (), i_e =
  61            bb_i->end (); i_i != i_e; ++i_i)
  62         {
  63           // Print the assembly for the instruction.
  64           O << "\t";
  65           MII.print(*i_i, O, TM);
  66         }
  67     }
  68
  69   // We didn't modify anything.
  70   return false;
  71 }
  72
  73 static bool isScale(const MachineOperand &MO) {
  74   return MO.isImmediate() &&
  75            (MO.getImmedValue() == 1 || MO.getImmedValue() == 2 ||
  76             MO.getImmedValue() == 4 || MO.getImmedValue() == 8);
  77 }
  78
  79 static bool isMem(const MachineInstr *MI, unsigned Op) {
  80   return Op+4 <= MI->getNumOperands() &&
  81          MI->getOperand(Op  ).isRegister() &&isScale(MI->getOperand(Op+1)) &&
  82          MI->getOperand(Op+2).isRegister() &&MI->getOperand(Op+3).isImmediate();
  83 }
  84
  85 static void printOp(std::ostream &O, const MachineOperand &MO,
  86                     const MRegisterInfo &RI) {
  87   switch (MO.getType()) {
  88   case MachineOperand::MO_VirtualRegister:
  89     if (Value *V = MO.getVRegValueOrNull()) {
  90       O << "<" << V->getName() << ">";
  91       return;
  92     }
  93   case MachineOperand::MO_MachineRegister:
  94     if (MO.getReg() < MRegisterInfo::FirstVirtualRegister)
  95       O << RI.get(MO.getReg()).Name;
  96     else
  97       O << "%reg" << MO.getReg();
  98     return;
  99
 100   case MachineOperand::MO_SignExtendedImmed:
 101   case MachineOperand::MO_UnextendedImmed:
 102     O << (int)MO.getImmedValue();
 103     return;
 104   case MachineOperand::MO_PCRelativeDisp:
 105     O << "<" << MO.getVRegValue()->getName() << ">";
 106     return;
 107   default:
 108     O << "<unknown op ty>"; return;
 109   }
 110 }
 111
 112 static const std::string sizePtr (const MachineInstrDescriptor &Desc) {
 113   switch (Desc.TSFlags & X86II::ArgMask) {
 114     case X86II::Arg8:   return "BYTE PTR";
 115     case X86II::Arg16:  return "WORD PTR";
 116     case X86II::Arg32:  return "DWORD PTR";
 117     case X86II::Arg64:  return "QWORD PTR";
 118     case X86II::Arg80:  return "XWORD PTR";
 119     case X86II::Arg128: return "128BIT PTR";  // dunno what the real one is
 120     default: return "<SIZE?> PTR"; // crack being smoked
 121   }
 122 }
 123
 124 static void printMemReference(std::ostream &O, const MachineInstr *MI,
 125                               unsigned Op, const MRegisterInfo &RI) {
 126   assert(isMem(MI, Op) && "Invalid memory reference!");
 127   const MachineOperand &BaseReg  = MI->getOperand(Op);
 128   const MachineOperand &Scale    = MI->getOperand(Op+1);
 129   const MachineOperand &IndexReg = MI->getOperand(Op+2);
 130   const MachineOperand &Disp     = MI->getOperand(Op+3);
 131
 132   O << "[";
 133   bool NeedPlus = false;
 134   if (BaseReg.getReg()) {
 135     printOp(O, BaseReg, RI);
 136     NeedPlus = true;
 137   }
 138
 139   if (IndexReg.getReg()) {
 140     if (NeedPlus) O << " + ";
 141     if (Scale.getImmedValue() != 1)
 142       O << Scale.getImmedValue() << "*";
 143     printOp(O, IndexReg, RI);
 144     NeedPlus = true;
 145   }
 146
 147   if (Disp.getImmedValue()) {
 148     if (NeedPlus) O << " + ";
 149     printOp(O, Disp, RI);
 150   }
 151   O << "]";
 152 }
 153
 154 // print - Print out an x86 instruction in intel syntax
 155 void X86InstrInfo::print(const MachineInstr *MI, std::ostream &O,
 156                          const TargetMachine &TM) const {
 157   unsigned Opcode = MI->getOpcode();
 158   const MachineInstrDescriptor &Desc = get(Opcode);
 159
 160   if (Opcode == X86::PHI) {
 161     printOp(O, MI->getOperand(0), RI);
 162     O << " = phi ";
 163     for (unsigned i = 1, e = MI->getNumOperands(); i != e; i+=2) {
 164       if (i != 1) O << ", ";
 165       O << "[";
 166       printOp(O, MI->getOperand(i), RI);
 167       O << ", ";
 168       printOp(O, MI->getOperand(i+1), RI);
 169       O << "]";
 170     }
 171     O << "\n";
 172     return;
 173   }
 174
 175
 176   switch (Desc.TSFlags & X86II::FormMask) {
 177   case X86II::RawFrm:
 178     // The accepted forms of Raw instructions are:
 179     //   1. nop     - No operand required
 180     //   2. jmp foo - PC relative displacement operand
 181     //
 182     assert(MI->getNumOperands() == 0 ||
 183            (MI->getNumOperands() == 1 && MI->getOperand(0).isPCRelativeDisp())&&
 184            "Illegal raw instruction!");
 185     O << getName(MI->getOpCode()) << " ";
 186
 187     if (MI->getNumOperands() == 1) {
 188       printOp(O, MI->getOperand(0), RI);
 189     }
 190     O << "\n";
 191     return;
 192
 193   case X86II::AddRegFrm: {
 194     // There are currently two forms of acceptable AddRegFrm instructions.
 195     // Either the instruction JUST takes a single register (like inc, dec, etc),
 196     // or it takes a register and an immediate of the same size as the register
 197     // (move immediate f.e.).  Note that this immediate value might be stored as
 198     // an LLVM value, to represent, for example, loading the address of a global
 199     // into a register.  The initial register might be duplicated if this is a
 200     // M_2_ADDR_REG instruction
 201     //
 202     assert(MI->getOperand(0).isRegister() &&
 203            (MI->getNumOperands() == 1 ||
 204             (MI->getNumOperands() == 2 &&
 205              (MI->getOperand(1).getVRegValueOrNull() ||
 206               MI->getOperand(1).isImmediate() ||
 207               MI->getOperand(1).isRegister()))) &&
 208            "Illegal form for AddRegFrm instruction!");
 209
 210     unsigned Reg = MI->getOperand(0).getReg();
 211
 212     O << getName(MI->getOpCode()) << " ";
 213     printOp(O, MI->getOperand(0), RI);
 214     if (MI->getNumOperands() == 2 && !MI->getOperand(1).isRegister()) {
 215       O << ", ";
 216       printOp(O, MI->getOperand(1), RI);
 217     }
 218     O << "\n";
 219     return;
 220   }
 221   case X86II::MRMDestReg: {
 222     // There are two acceptable forms of MRMDestReg instructions, those with 3
 223     // and 2 operands:
 224     //
 225     // 3 Operands: in this form, the first two registers (the destination, and
 226     // the first operand) should be the same, post register allocation.  The 3rd
 227     // operand is an additional input.  This should be for things like add
 228     // instructions.
 229     //
 230     // 2 Operands: this is for things like mov that do not read a second input
 231     //
 232     assert(MI->getOperand(0).isRegister() &&
 233            (MI->getNumOperands() == 2 ||
 234             (MI->getNumOperands() == 3 && MI->getOperand(1).isRegister())) &&
 235            MI->getOperand(MI->getNumOperands()-1).isRegister()
 236            && "Bad format for MRMDestReg!");
 237     if (MI->getNumOperands() == 3 &&
 238         MI->getOperand(0).getReg() != MI->getOperand(1).getReg())
 239       O << "**";
 240
 241     O << getName(MI->getOpCode()) << " ";
 242     printOp(O, MI->getOperand(0), RI);
 243     O << ", ";
 244     printOp(O, MI->getOperand(MI->getNumOperands()-1), RI);
 245     O << "\n";
 246     return;
 247   }
 248
 249   case X86II::MRMDestMem: {
 250     // These instructions are the same as MRMDestReg, but instead of having a
 251     // register reference for the mod/rm field, it's a memory reference.
 252     //
 253     assert(isMem(MI, 0) && MI->getNumOperands() == 4+1 &&
 254            MI->getOperand(4).isRegister() && "Bad format for MRMDestMem!");
 255
 256     O << getName(MI->getOpCode()) << " " << sizePtr (Desc) << " ";
 257     printMemReference(O, MI, 0, RI);
 258     O << ", ";
 259     printOp(O, MI->getOperand(4), RI);
 260     O << "\n";
 261     return;
 262   }
 263
 264   case X86II::MRMSrcReg: {
 265     // There is a two forms that are acceptable for MRMSrcReg instructions,
 266     // those with 3 and 2 operands:
 267     //
 268     // 3 Operands: in this form, the last register (the second input) is the
 269     // ModR/M input.  The first two operands should be the same, post register
 270     // allocation.  This is for things like: add r32, r/m32
 271     //
 272     // 2 Operands: this is for things like mov that do not read a second input
 273     //
 274     assert(MI->getOperand(0).isRegister() &&
 275            MI->getOperand(1).isRegister() &&
 276            (MI->getNumOperands() == 2 ||
 277             (MI->getNumOperands() == 3 && MI->getOperand(2).isRegister()))
 278            && "Bad format for MRMDestReg!");
 279     if (MI->getNumOperands() == 3 &&
 280         MI->getOperand(0).getReg() != MI->getOperand(1).getReg())
 281       O << "**";
 282
 283     O << getName(MI->getOpCode()) << " ";
 284     printOp(O, MI->getOperand(0), RI);
 285     O << ", ";
 286     printOp(O, MI->getOperand(MI->getNumOperands()-1), RI);
 287     O << "\n";
 288     return;
 289   }
 290
 291   case X86II::MRMSrcMem: {
 292     // These instructions are the same as MRMSrcReg, but instead of having a
 293     // register reference for the mod/rm field, it's a memory reference.
 294     //
 295     assert(MI->getOperand(0).isRegister() &&
 296            (MI->getNumOperands() == 1+4 && isMem(MI, 1)) ||
 297            (MI->getNumOperands() == 2+4 && MI->getOperand(1).isRegister() &&
 298             isMem(MI, 2))
 299            && "Bad format for MRMDestReg!");
 300     if (MI->getNumOperands() == 2+4 &&
 301         MI->getOperand(0).getReg() != MI->getOperand(1).getReg())
 302       O << "**";
 303
 304     O << getName(MI->getOpCode()) << " ";
 305     printOp(O, MI->getOperand(0), RI);
 306     O << ", " << sizePtr (Desc) << " ";
 307     printMemReference(O, MI, MI->getNumOperands()-4, RI);
 308     O << "\n";
 309     return;
 310   }
 311
 312   case X86II::MRMS0r: case X86II::MRMS1r:
 313   case X86II::MRMS2r: case X86II::MRMS3r:
 314   case X86II::MRMS4r: case X86II::MRMS5r:
 315   case X86II::MRMS6r: case X86II::MRMS7r: {
 316     // In this form, the following are valid formats:
 317     //  1. sete r
 318     //  2. cmp reg, immediate
 319     //  2. shl rdest, rinput  <implicit CL or 1>
 320     //  3. sbb rdest, rinput, immediate   [rdest = rinput]
 321     //
 322     assert(MI->getNumOperands() > 0 && MI->getNumOperands() < 4 &&
 323            MI->getOperand(0).isRegister() && "Bad MRMSxR format!");
 324     assert((MI->getNumOperands() != 2 ||
 325             MI->getOperand(1).isRegister() || MI->getOperand(1).isImmediate())&&
 326            "Bad MRMSxR format!");
 327     assert((MI->getNumOperands() < 3 ||
 328         (MI->getOperand(1).isRegister() && MI->getOperand(2).isImmediate())) &&
 329            "Bad MRMSxR format!");
 330
 331     if (MI->getNumOperands() > 1 && MI->getOperand(1).isRegister() &&
 332         MI->getOperand(0).getReg() != MI->getOperand(1).getReg())
 333       O << "**";
 334
 335     O << getName(MI->getOpCode()) << " ";
 336     printOp(O, MI->getOperand(0), RI);
 337     if (MI->getOperand(MI->getNumOperands()-1).isImmediate()) {
 338       O << ", ";
 339       printOp(O, MI->getOperand(MI->getNumOperands()-1), RI);
 340     }
 341     O << "\n";
 342
 343     return;
 344   }
 345
 346   default:
 347     O << "\t\t\t-"; MI->print(O, TM); break;
 348   }
 349 }