lib/VMCore/AsmWriter.cpp

   1 //===-- Writer.cpp - Library for Printing VM assembly files ------*- C++ -*--=//
   2 //
   3 // This library implements the functionality defined in llvm/Assembly/Writer.h
   4 //
   5 // This library uses the Analysis library to figure out offsets for
   6 // variables in the method tables...
   7 //
   8 // TODO: print out the type name instead of the full type if a particular type
   9 //       is in the symbol table...
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Assembly/Writer.h"
  14 #include "llvm/Analysis/SlotCalculator.h"
  15 #include "llvm/Module.h"
  16 #include "llvm/Method.h"
  17 #include "llvm/GlobalVariable.h"
  18 #include "llvm/BasicBlock.h"
  19 #include "llvm/ConstPoolVals.h"
  20 #include "llvm/iOther.h"
  21 #include "llvm/iMemory.h"
  22 #include "llvm/Support/STLExtras.h"
  23 #include "llvm/SymbolTable.h"
  24 #include <algorithm>
  25
  26 void DebugValue(const Value *V) {
  27   cerr << V << endl;
  28 }
  29
  30 // WriteAsOperand - Write the name of the specified value out to the specified
  31 // ostream.  This can be useful when you just want to print int %reg126, not the
  32 // whole instruction that generated it.
  33 //
  34 ostream &WriteAsOperand(ostream &Out, const Value *V, bool PrintType,
  35                         bool PrintName, SlotCalculator *Table) {
  36   if (PrintType)
  37     Out << " " << V->getType();
  38
  39   if (PrintName && V->hasName()) {
  40     Out << " %" << V->getName();
  41   } else {
  42     if (const ConstPoolVal *CPV = V->castConstant()) {
  43       Out << " " << CPV->getStrValue();
  44     } else {
  45       int Slot;
  46       if (Table) {
  47         Slot = Table->getValSlot(V);
  48       } else {
  49         if (const Type *Ty = V->castType()) {
  50           return Out << " " << Ty;
  51         } else if (const MethodArgument *MA = V->castMethodArgument()) {
  52           Table = new SlotCalculator(MA->getParent(), true);
  53         } else if (const Instruction *I = V->castInstruction()) {
  54           Table = new SlotCalculator(I->getParent()->getParent(), true);
  55         } else if (const BasicBlock *BB = V->castBasicBlock()) {
  56           Table = new SlotCalculator(BB->getParent(), true);
  57         } else if (const Method *Meth = V->castMethod()) {
  58           Table = new SlotCalculator(Meth, true);
  59         } else if (const Module *Mod  = V->castModule()) {
  60           Table = new SlotCalculator(Mod, true);
  61         } else {
  62           return Out << "BAD VALUE TYPE!";
  63         }
  64         Slot = Table->getValSlot(V);
  65         delete Table;
  66       }
  67       if (Slot >= 0)  Out << " %" << Slot;
  68       else if (PrintName)
  69         Out << "<badref>";     // Not embeded into a location?
  70     }
  71   }
  72   return Out;
  73 }
  74
  75
  76
  77 class AssemblyWriter {
  78   ostream &Out;
  79   SlotCalculator &Table;
  80 public:
  81   inline AssemblyWriter(ostream &o, SlotCalculator &Tab) : Out(o), Table(Tab) {
  82   }
  83
  84   inline void write(const Module *M)         { processModule(M);      }
  85   inline void write(const GlobalVariable *G) { processGlobal(G);      }
  86   inline void write(const Method *M)         { processMethod(M);      }
  87   inline void write(const BasicBlock *BB)    { processBasicBlock(BB); }
  88   inline void write(const Instruction *I)    { processInstruction(I); }
  89   inline void write(const ConstPoolVal *CPV) { processConstant(CPV);  }
  90
  91 private :
  92   void processModule(const Module *M);
  93   void processSymbolTable(const SymbolTable &ST);
  94   void processConstant(const ConstPoolVal *CPV);
  95   void processGlobal(const GlobalVariable *GV);
  96   void processMethod(const Method *M);
  97   void processMethodArgument(const MethodArgument *MA);
  98   void processBasicBlock(const BasicBlock *BB);
  99   void processInstruction(const Instruction *I);
 100
 101   void writeOperand(const Value *Op, bool PrintType, bool PrintName = true);
 102 };
 103
 104
 105 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType,
 106                                   bool PrintName) {
 107   WriteAsOperand(Out, Operand, PrintType, PrintName, &Table);
 108 }
 109
 110
 111 void AssemblyWriter::processModule(const Module *M) {
 112   // Loop over the symbol table, emitting all named constants...
 113   if (M->hasSymbolTable())
 114     processSymbolTable(*M->getSymbolTable());
 115
 116   for_each(M->gbegin(), M->gend(),
 117            bind_obj(this, &AssemblyWriter::processGlobal));
 118
 119   Out << "implementation\n";
 120
 121   // Output all of the methods...
 122   for_each(M->begin(), M->end(), bind_obj(this,&AssemblyWriter::processMethod));
 123 }
 124
 125 void AssemblyWriter::processGlobal(const GlobalVariable *GV) {
 126   Out << "global ";
 127   if (GV->hasName()) Out << "%" << GV->getName() << " = ";
 128   Out << GV->getType()->getDescription() << endl;
 129 }
 130
 131
 132 // processSymbolTable - Run through symbol table looking for named constants
 133 // if a named constant is found, emit it's declaration...
 134 //
 135 void AssemblyWriter::processSymbolTable(const SymbolTable &ST) {
 136   for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) {
 137     SymbolTable::type_const_iterator I = ST.type_begin(TI->first);
 138     SymbolTable::type_const_iterator End = ST.type_end(TI->first);
 139
 140     for (; I != End; ++I) {
 141       const Value *V = I->second;
 142       if (const ConstPoolVal *CPV = V->castConstant()) {
 143         processConstant(CPV);
 144       } else if (const Type *Ty = V->castType()) {
 145         Out << "\t%" << I->first << " = type " << Ty->getDescription() << endl;
 146       }
 147     }
 148   }
 149 }
 150
 151
 152 // processConstant - Print out a constant pool entry...
 153 //
 154 void AssemblyWriter::processConstant(const ConstPoolVal *CPV) {
 155   // Don't print out unnamed constants, they will be inlined
 156   if (!CPV->hasName()) return;
 157
 158   // Print out name...
 159   Out << "\t%" << CPV->getName() << " = ";
 160
 161   // Print out the constant type...
 162   Out << CPV->getType();
 163
 164   // Write the value out now...
 165   writeOperand(CPV, false, false);
 166
 167   if (!CPV->hasName() && CPV->getType() != Type::VoidTy) {
 168     int Slot = Table.getValSlot(CPV); // Print out the def slot taken...
 169     Out << "\t\t; <" << CPV->getType() << ">:";
 170     if (Slot >= 0) Out << Slot;
 171     else Out << "<badref>";
 172   }
 173
 174   Out << endl;
 175 }
 176
 177 // processMethod - Process all aspects of a method.
 178 //
 179 void AssemblyWriter::processMethod(const Method *M) {
 180   // Print out the return type and name...
 181   Out << "\n" << (M->isExternal() ? "declare " : "")
 182       << M->getReturnType() << " \"" << M->getName() << "\"(";
 183   Table.incorporateMethod(M);
 184
 185   // Loop over the arguments, processing them...
 186   for_each(M->getArgumentList().begin(), M->getArgumentList().end(),
 187            bind_obj(this, &AssemblyWriter::processMethodArgument));
 188
 189
 190   // Finish printing arguments...
 191   const MethodType *MT = (const MethodType*)M->getType();
 192   if (MT->isVarArg()) {
 193     if (MT->getParamTypes().size()) Out << ", ";
 194     Out << "...";  // Output varargs portion of signature!
 195   }
 196   Out << ")\n";
 197
 198   if (!M->isExternal()) {
 199     // Loop over the symbol table, emitting all named constants...
 200     if (M->hasSymbolTable())
 201       processSymbolTable(*M->getSymbolTable());
 202
 203     Out << "begin";
 204
 205     // Output all of its basic blocks... for the method
 206     for_each(M->begin(), M->end(),
 207              bind_obj(this, &AssemblyWriter::processBasicBlock));
 208
 209     Out << "end\n";
 210   }
 211
 212   Table.purgeMethod();
 213 }
 214
 215 // processMethodArgument - This member is called for every argument that
 216 // is passed into the method.  Simply print it out
 217 //
 218 void AssemblyWriter::processMethodArgument(const MethodArgument *Arg) {
 219   // Insert commas as we go... the first arg doesn't get a comma
 220   if (Arg != Arg->getParent()->getArgumentList().front()) Out << ", ";
 221
 222   // Output type...
 223   Out << Arg->getType();
 224
 225   // Output name, if available...
 226   if (Arg->hasName())
 227     Out << " %" << Arg->getName();
 228   else if (Table.getValSlot(Arg) < 0)
 229     Out << "<badref>";
 230 }
 231
 232 // processBasicBlock - This member is called for each basic block in a methd.
 233 //
 234 void AssemblyWriter::processBasicBlock(const BasicBlock *BB) {
 235   if (BB->hasName()) {              // Print out the label if it exists...
 236     Out << "\n" << BB->getName() << ":";
 237   } else {
 238     int Slot = Table.getValSlot(BB);
 239     Out << "\n; <label>:";
 240     if (Slot >= 0)
 241       Out << Slot;         // Extra newline seperates out label's
 242     else
 243       Out << "<badref>";
 244   }
 245   Out << "\t\t\t\t\t;[#uses=" << BB->use_size() << "]\n";  // Output # uses
 246
 247   // Output all of the instructions in the basic block...
 248   for_each(BB->begin(), BB->end(),
 249            bind_obj(this, &AssemblyWriter::processInstruction));
 250 }
 251
 252 // processInstruction - This member is called for each Instruction in a methd.
 253 //
 254 void AssemblyWriter::processInstruction(const Instruction *I) {
 255   Out << "\t";
 256
 257   // Print out name if it exists...
 258   if (I && I->hasName())
 259     Out << "%" << I->getName() << " = ";
 260
 261   // Print out the opcode...
 262   Out << I->getOpcodeName();
 263
 264   // Print out the type of the operands...
 265   const Value *Operand = I->getNumOperands() ? I->getOperand(0) : 0;
 266
 267   // Special case conditional branches to swizzle the condition out to the front
 268   if (I->getOpcode() == Instruction::Br && I->getNumOperands() > 1) {
 269     writeOperand(I->getOperand(2), true);
 270     Out << ",";
 271     writeOperand(Operand, true);
 272     Out << ",";
 273     writeOperand(I->getOperand(1), true);
 274
 275   } else if (I->getOpcode() == Instruction::Switch) {
 276     // Special case switch statement to get formatting nice and correct...
 277     writeOperand(Operand         , true); Out << ",";
 278     writeOperand(I->getOperand(1), true); Out << " [";
 279
 280     for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; op += 2) {
 281       Out << "\n\t\t";
 282       writeOperand(I->getOperand(op  ), true); Out << ",";
 283       writeOperand(I->getOperand(op+1), true);
 284     }
 285     Out << "\n\t]";
 286   } else if (I->isPHINode()) {
 287     Out << " " << Operand->getType();
 288
 289     Out << " [";  writeOperand(Operand, false); Out << ",";
 290     writeOperand(I->getOperand(1), false); Out << " ]";
 291     for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; op += 2) {
 292       Out << ", [";
 293       writeOperand(I->getOperand(op  ), false); Out << ",";
 294       writeOperand(I->getOperand(op+1), false); Out << " ]";
 295     }
 296   } else if (I->getOpcode() == Instruction::Ret && !Operand) {
 297     Out << " void";
 298   } else if (I->getOpcode() == Instruction::Call) {
 299     writeOperand(Operand, true);
 300     Out << "(";
 301     if (I->getNumOperands() > 1) writeOperand(I->getOperand(1), true);
 302     for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; ++op) {
 303       Out << ",";
 304       writeOperand(I->getOperand(op), true);
 305     }
 306
 307     Out << " )";
 308   } else if (I->getOpcode() == Instruction::Malloc ||
 309              I->getOpcode() == Instruction::Alloca) {
 310     Out << " " << ((const PointerType*)I->getType())->getValueType();
 311     if (I->getNumOperands()) {
 312       Out << ",";
 313       writeOperand(I->getOperand(0), true);
 314     }
 315   } else if (I->getOpcode() == Instruction::Cast) {
 316     writeOperand(Operand, true);
 317     Out << " to " << I->getType();
 318   } else if (Operand) {   // Print the normal way...
 319
 320     // PrintAllTypes - Instructions who have operands of all the same type
 321     // omit the type from all but the first operand.  If the instruction has
 322     // different type operands (for example br), then they are all printed.
 323     bool PrintAllTypes = false;
 324     const Type *TheType = Operand->getType();
 325
 326     for (unsigned i = 1, E = I->getNumOperands(); i != E; ++i) {
 327       Operand = I->getOperand(i);
 328       if (Operand->getType() != TheType) {
 329         PrintAllTypes = true;       // We have differing types!  Print them all!
 330         break;
 331       }
 332     }
 333
 334     if (!PrintAllTypes)
 335       Out << " " << I->getOperand(0)->getType();
 336
 337     for (unsigned i = 0, E = I->getNumOperands(); i != E; ++i) {
 338       if (i) Out << ",";
 339       writeOperand(I->getOperand(i), PrintAllTypes);
 340     }
 341   }
 342
 343   // Print a little comment after the instruction indicating which slot it
 344   // occupies.
 345   //
 346   if (I->getType() != Type::VoidTy) {
 347     Out << "\t\t; <" << I->getType() << ">";
 348
 349     if (!I->hasName()) {
 350       int Slot = Table.getValSlot(I); // Print out the def slot taken...
 351       if (Slot >= 0) Out << ":" << Slot;
 352       else Out << ":<badref>";
 353     }
 354     Out << "\t[#uses=" << I->use_size() << "]";  // Output # uses
 355   }
 356   Out << endl;
 357 }
 358
 359
 360 //===----------------------------------------------------------------------===//
 361 //                       External Interface declarations
 362 //===----------------------------------------------------------------------===//
 363
 364
 365
 366 void WriteToAssembly(const Module *M, ostream &o) {
 367   if (M == 0) { o << "<null> module\n"; return; }
 368   SlotCalculator SlotTable(M, true);
 369   AssemblyWriter W(o, SlotTable);
 370
 371   W.write(M);
 372 }
 373
 374 void WriteToAssembly(const GlobalVariable *G, ostream &o) {
 375   if (G == 0) { o << "<null> global variable\n"; return; }
 376   SlotCalculator SlotTable(G->getParent(), true);
 377   AssemblyWriter W(o, SlotTable);
 378   W.write(G);
 379 }
 380
 381 void WriteToAssembly(const Method *M, ostream &o) {
 382   if (M == 0) { o << "<null> method\n"; return; }
 383   SlotCalculator SlotTable(M->getParent(), true);
 384   AssemblyWriter W(o, SlotTable);
 385
 386   W.write(M);
 387 }
 388
 389
 390 void WriteToAssembly(const BasicBlock *BB, ostream &o) {
 391   if (BB == 0) { o << "<null> basic block\n"; return; }
 392
 393   SlotCalculator SlotTable(BB->getParent(), true);
 394   AssemblyWriter W(o, SlotTable);
 395
 396   W.write(BB);
 397 }
 398
 399 void WriteToAssembly(const ConstPoolVal *CPV, ostream &o) {
 400   if (CPV == 0) { o << "<null> constant pool value\n"; return; }
 401   WriteAsOperand(o, CPV, true, true, 0);
 402 }
 403
 404 void WriteToAssembly(const Instruction *I, ostream &o) {
 405   if (I == 0) { o << "<null> instruction\n"; return; }
 406
 407   SlotCalculator SlotTable(I->getParent() ? I->getParent()->getParent() : 0,
 408                            true);
 409   AssemblyWriter W(o, SlotTable);
 410
 411   W.write(I);
 412 }