lib/CodeGen/MachineFunction.cpp

   1 //===-- MachineFunction.cpp -----------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Collect native machine code information for a function.  This allows
  11 // target-specific information about the generated code to be stored with each
  12 // function.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "llvm/CodeGen/MachineFunctionPass.h"
  17 #include "llvm/CodeGen/MachineInstr.h"
  18 #include "llvm/CodeGen/SSARegMap.h"
  19 #include "llvm/CodeGen/MachineFrameInfo.h"
  20 #include "llvm/CodeGen/MachineConstantPool.h"
  21 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  22 #include "llvm/CodeGen/Passes.h"
  23 #include "llvm/Target/TargetData.h"
  24 #include "llvm/Target/TargetMachine.h"
  25 #include "llvm/Target/TargetFrameInfo.h"
  26 #include "llvm/Function.h"
  27 #include "llvm/Instructions.h"
  28 #include "llvm/Support/LeakDetector.h"
  29 #include "llvm/Support/GraphWriter.h"
  30 #include "llvm/Config/config.h"
  31 #include <fstream>
  32 #include <iostream>
  33 #include <sstream>
  34
  35 using namespace llvm;
  36
  37 static AnnotationID MF_AID(
  38   AnnotationManager::getID("CodeGen::MachineCodeForFunction"));
  39
  40
  41 namespace {
  42   struct Printer : public MachineFunctionPass {
  43     std::ostream *OS;
  44     const std::string Banner;
  45
  46     Printer (std::ostream *_OS, const std::string &_Banner) :
  47       OS (_OS), Banner (_Banner) { }
  48
  49     const char *getPassName() const { return "MachineFunction Printer"; }
  50
  51     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  52       AU.setPreservesAll();
  53     }
  54
  55     bool runOnMachineFunction(MachineFunction &MF) {
  56       (*OS) << Banner;
  57       MF.print (*OS);
  58       return false;
  59     }
  60   };
  61 }
  62
  63 /// Returns a newly-created MachineFunction Printer pass. The default output
  64 /// stream is std::cerr; the default banner is empty.
  65 ///
  66 FunctionPass *llvm::createMachineFunctionPrinterPass(std::ostream *OS,
  67                                                      const std::string &Banner){
  68   return new Printer(OS, Banner);
  69 }
  70
  71 namespace {
  72   struct Deleter : public MachineFunctionPass {
  73     const char *getPassName() const { return "Machine Code Deleter"; }
  74
  75     bool runOnMachineFunction(MachineFunction &MF) {
  76       // Delete the annotation from the function now.
  77       MachineFunction::destruct(MF.getFunction());
  78       return true;
  79     }
  80   };
  81 }
  82
  83 /// MachineCodeDeletion Pass - This pass deletes all of the machine code for
  84 /// the current function, which should happen after the function has been
  85 /// emitted to a .s file or to memory.
  86 FunctionPass *llvm::createMachineCodeDeleter() {
  87   return new Deleter();
  88 }
  89
  90
  91
  92 //===---------------------------------------------------------------------===//
  93 // MachineFunction implementation
  94 //===---------------------------------------------------------------------===//
  95
  96 MachineBasicBlock* ilist_traits<MachineBasicBlock>::createSentinel() {
  97   MachineBasicBlock* dummy = new MachineBasicBlock();
  98   LeakDetector::removeGarbageObject(dummy);
  99   return dummy;
 100 }
 101
 102 void ilist_traits<MachineBasicBlock>::transferNodesFromList(
 103   iplist<MachineBasicBlock, ilist_traits<MachineBasicBlock> >& toList,
 104   ilist_iterator<MachineBasicBlock> first,
 105   ilist_iterator<MachineBasicBlock> last) {
 106   if (Parent != toList.Parent)
 107     for (; first != last; ++first)
 108       first->Parent = toList.Parent;
 109 }
 110
 111 MachineFunction::MachineFunction(const Function *F,
 112                                  const TargetMachine &TM)
 113   : Annotation(MF_AID), Fn(F), Target(TM), UsedPhysRegs(0) {
 114   SSARegMapping = new SSARegMap();
 115   MFInfo = 0;
 116   FrameInfo = new MachineFrameInfo();
 117   ConstantPool = new MachineConstantPool(TM.getTargetData());
 118   JumpTableInfo = new MachineJumpTableInfo(TM.getTargetData());
 119   BasicBlocks.Parent = this;
 120 }
 121
 122 MachineFunction::~MachineFunction() {
 123   BasicBlocks.clear();
 124   delete SSARegMapping;
 125   delete MFInfo;
 126   delete FrameInfo;
 127   delete ConstantPool;
 128   delete JumpTableInfo;
 129   delete[] UsedPhysRegs;
 130 }
 131
 132 void MachineFunction::dump() const { print(std::cerr); }
 133
 134 void MachineFunction::print(std::ostream &OS) const {
 135   OS << "# Machine code for " << Fn->getName () << "():\n";
 136
 137   // Print Frame Information
 138   getFrameInfo()->print(*this, OS);
 139
 140   // Print JumpTable Information
 141   getJumpTableInfo()->print(OS);
 142
 143   // Print Constant Pool
 144   getConstantPool()->print(OS);
 145
 146   const MRegisterInfo *MRI = getTarget().getRegisterInfo();
 147
 148   if (livein_begin() != livein_end()) {
 149     OS << "Live Ins:";
 150     for (livein_iterator I = livein_begin(), E = livein_end(); I != E; ++I) {
 151       if (MRI)
 152         OS << " " << MRI->getName(I->first);
 153       else
 154         OS << " Reg #" << I->first;
 155     }
 156     OS << "\n";
 157   }
 158   if (liveout_begin() != liveout_end()) {
 159     OS << "Live Outs:";
 160     for (liveout_iterator I = liveout_begin(), E = liveout_end(); I != E; ++I)
 161       if (MRI)
 162         OS << " " << MRI->getName(*I);
 163       else
 164         OS << " Reg #" << *I;
 165     OS << "\n";
 166   }
 167
 168   for (const_iterator BB = begin(); BB != end(); ++BB)
 169     BB->print(OS);
 170
 171   OS << "\n# End machine code for " << Fn->getName () << "().\n\n";
 172 }
 173
 174 /// CFGOnly flag - This is used to control whether or not the CFG graph printer
 175 /// prints out the contents of basic blocks or not.  This is acceptable because
 176 /// this code is only really used for debugging purposes.
 177 ///
 178 static bool CFGOnly = false;
 179
 180 namespace llvm {
 181   template<>
 182   struct DOTGraphTraits<const MachineFunction*> : public DefaultDOTGraphTraits {
 183     static std::string getGraphName(const MachineFunction *F) {
 184       return "CFG for '" + F->getFunction()->getName() + "' function";
 185     }
 186
 187     static std::string getNodeLabel(const MachineBasicBlock *Node,
 188                                     const MachineFunction *Graph) {
 189       if (CFGOnly && Node->getBasicBlock() &&
 190           !Node->getBasicBlock()->getName().empty())
 191         return Node->getBasicBlock()->getName() + ":";
 192
 193       std::ostringstream Out;
 194       if (CFGOnly) {
 195         Out << Node->getNumber() << ':';
 196         return Out.str();
 197       }
 198
 199       Node->print(Out);
 200
 201       std::string OutStr = Out.str();
 202       if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
 203
 204       // Process string output to make it nicer...
 205       for (unsigned i = 0; i != OutStr.length(); ++i)
 206         if (OutStr[i] == '\n') {                            // Left justify
 207           OutStr[i] = '\\';
 208           OutStr.insert(OutStr.begin()+i+1, 'l');
 209         }
 210       return OutStr;
 211     }
 212   };
 213 }
 214
 215 void MachineFunction::viewCFG() const
 216 {
 217 #ifndef NDEBUG
 218   std::string Filename = "/tmp/cfg." + getFunction()->getName() + ".dot";
 219   std::cerr << "Writing '" << Filename << "'... ";
 220   std::ofstream F(Filename.c_str());
 221
 222   if (!F) {
 223     std::cerr << "  error opening file for writing!\n";
 224     return;
 225   }
 226
 227   WriteGraph(F, this);
 228   F.close();
 229   std::cerr << "\n";
 230
 231 #ifdef HAVE_GRAPHVIZ
 232   std::cerr << "Running 'Graphviz' program... " << std::flush;
 233   if (system((LLVM_PATH_GRAPHVIZ " " + Filename).c_str())) {
 234     std::cerr << "Error viewing graph: 'Graphviz' not in path?\n";
 235   } else {
 236     system(("rm " + Filename).c_str());
 237     return;
 238   }
 239 #endif  // HAVE_GRAPHVIZ
 240
 241 #ifdef HAVE_GV
 242   std::cerr << "Running 'dot' program... " << std::flush;
 243   if (system(("dot -Tps -Nfontname=Courier -Gsize=7.5,10 " + Filename
 244               + " > /tmp/cfg.tempgraph.ps").c_str())) {
 245     std::cerr << "Error running dot: 'dot' not in path?\n";
 246   } else {
 247     std::cerr << "\n";
 248     system("gv /tmp/cfg.tempgraph.ps");
 249   }
 250   system(("rm " + Filename + " /tmp/cfg.tempgraph.ps").c_str());
 251   return;
 252 #endif  // HAVE_GV
 253 #endif  // NDEBUG
 254   std::cerr << "MachineFunction::viewCFG is only available in debug builds on "
 255             << "systems with Graphviz or gv!\n";
 256
 257 #ifndef NDEBUG
 258   system(("rm " + Filename).c_str());
 259 #endif
 260 }
 261
 262 void MachineFunction::viewCFGOnly() const
 263 {
 264   CFGOnly = true;
 265   viewCFG();
 266   CFGOnly = false;
 267 }
 268
 269 // The next two methods are used to construct and to retrieve
 270 // the MachineCodeForFunction object for the given function.
 271 // construct() -- Allocates and initializes for a given function and target
 272 // get()       -- Returns a handle to the object.
 273 //                This should not be called before "construct()"
 274 //                for a given Function.
 275 //
 276 MachineFunction&
 277 MachineFunction::construct(const Function *Fn, const TargetMachine &Tar)
 278 {
 279   assert(Fn->getAnnotation(MF_AID) == 0 &&
 280          "Object already exists for this function!");
 281   MachineFunction* mcInfo = new MachineFunction(Fn, Tar);
 282   Fn->addAnnotation(mcInfo);
 283   return *mcInfo;
 284 }
 285
 286 void MachineFunction::destruct(const Function *Fn) {
 287   bool Deleted = Fn->deleteAnnotation(MF_AID);
 288   assert(Deleted && "Machine code did not exist for function!");
 289 }
 290
 291 MachineFunction& MachineFunction::get(const Function *F)
 292 {
 293   MachineFunction *mc = (MachineFunction*)F->getAnnotation(MF_AID);
 294   assert(mc && "Call construct() method first to allocate the object");
 295   return *mc;
 296 }
 297
 298 void MachineFunction::clearSSARegMap() {
 299   delete SSARegMapping;
 300   SSARegMapping = 0;
 301 }
 302
 303 //===----------------------------------------------------------------------===//
 304 //  MachineFrameInfo implementation
 305 //===----------------------------------------------------------------------===//
 306
 307 void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{
 308   int ValOffset = MF.getTarget().getFrameInfo()->getOffsetOfLocalArea();
 309
 310   for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
 311     const StackObject &SO = Objects[i];
 312     OS << "  <fi #" << (int)(i-NumFixedObjects) << ">: ";
 313     if (SO.Size == 0)
 314       OS << "variable sized";
 315     else
 316       OS << "size is " << SO.Size << " byte" << (SO.Size != 1 ? "s," : ",");
 317     OS << " alignment is " << SO.Alignment << " byte"
 318        << (SO.Alignment != 1 ? "s," : ",");
 319
 320     if (i < NumFixedObjects)
 321       OS << " fixed";
 322     if (i < NumFixedObjects || SO.SPOffset != -1) {
 323       int Off = SO.SPOffset - ValOffset;
 324       OS << " at location [SP";
 325       if (Off > 0)
 326         OS << "+" << Off;
 327       else if (Off < 0)
 328         OS << Off;
 329       OS << "]";
 330     }
 331     OS << "\n";
 332   }
 333
 334   if (HasVarSizedObjects)
 335     OS << "  Stack frame contains variable sized objects\n";
 336 }
 337
 338 void MachineFrameInfo::dump(const MachineFunction &MF) const {
 339   print(MF, std::cerr);
 340 }
 341
 342
 343 //===----------------------------------------------------------------------===//
 344 //  MachineJumpTableInfo implementation
 345 //===----------------------------------------------------------------------===//
 346
 347 /// getJumpTableIndex - Create a new jump table entry in the jump table info
 348 /// or return an existing one.
 349 ///
 350 unsigned MachineJumpTableInfo::getJumpTableIndex(
 351                                      std::vector<MachineBasicBlock*> &DestBBs) {
 352   for (unsigned i = 0, e = JumpTables.size(); i != e; ++i)
 353     if (JumpTables[i].MBBs == DestBBs)
 354       return i;
 355
 356   JumpTables.push_back(MachineJumpTableEntry(DestBBs));
 357   return JumpTables.size()-1;
 358 }
 359
 360
 361 void MachineJumpTableInfo::print(std::ostream &OS) const {
 362   // FIXME: this is lame, maybe we could print out the MBB numbers or something
 363   // like {1, 2, 4, 5, 3, 0}
 364   for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
 365     OS << "  <jt #" << i << "> has " << JumpTables[i].MBBs.size()
 366        << " entries\n";
 367   }
 368 }
 369
 370 unsigned MachineJumpTableInfo::getEntrySize() const {
 371   return TD->getPointerSize();
 372 }
 373
 374 unsigned MachineJumpTableInfo::getAlignment() const {
 375   return TD->getPointerAlignment();
 376 }
 377
 378 void MachineJumpTableInfo::dump() const { print(std::cerr); }
 379
 380
 381 //===----------------------------------------------------------------------===//
 382 //  MachineConstantPool implementation
 383 //===----------------------------------------------------------------------===//
 384
 385 /// getConstantPoolIndex - Create a new entry in the constant pool or return
 386 /// an existing one.  User must specify an alignment in bytes for the object.
 387 ///
 388 unsigned MachineConstantPool::getConstantPoolIndex(Constant *C,
 389                                                    unsigned Alignment) {
 390   assert(Alignment && "Alignment must be specified!");
 391   if (Alignment > PoolAlignment) PoolAlignment = Alignment;
 392
 393   // Check to see if we already have this constant.
 394   //
 395   // FIXME, this could be made much more efficient for large constant pools.
 396   unsigned AlignMask = (1 << Alignment)-1;
 397   for (unsigned i = 0, e = Constants.size(); i != e; ++i)
 398     if (Constants[i].Val == C && (Constants[i].Offset & AlignMask) == 0)
 399       return i;
 400
 401   unsigned Offset = 0;
 402   if (!Constants.empty()) {
 403     Offset = Constants.back().Offset;
 404     Offset += TD->getTypeSize(Constants.back().Val->getType());
 405     Offset = (Offset+AlignMask)&~AlignMask;
 406   }
 407
 408   Constants.push_back(MachineConstantPoolEntry(C, Offset));
 409   return Constants.size()-1;
 410 }
 411
 412
 413 void MachineConstantPool::print(std::ostream &OS) const {
 414   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
 415     OS << "  <cp #" << i << "> is" << *(Value*)Constants[i].Val;
 416     OS << " , offset=" << Constants[i].Offset;
 417     OS << "\n";
 418   }
 419 }
 420
 421 void MachineConstantPool::dump() const { print(std::cerr); }