Add explicit keywords.
[oota-llvm.git] / lib / CodeGen / MachineFunction.cpp
index f51176ff2104bcb60796b85a89ff21db0f4fd43c..30896172883e431b5d45ed6305b243900a359d00 100644 (file)
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/DerivedTypes.h"
+#include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
-#include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/CodeGen/SSARegMap.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
-#include "llvm/CodeGen/MachineConstantPool.h"
+#include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/CodeGen/MachineJumpTableInfo.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetFrameInfo.h"
 #include "llvm/Function.h"
 #include "llvm/Instructions.h"
-#include "llvm/Support/LeakDetector.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/GraphWriter.h"
+#include "llvm/Support/LeakDetector.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Config/config.h"
 #include <fstream>
-#include <iostream>
 #include <sstream>
-
 using namespace llvm;
 
 static AnnotationID MF_AID(
   AnnotationManager::getID("CodeGen::MachineCodeForFunction"));
 
+// Out of line virtual function to home classes.
+void MachineFunctionPass::virtfn() {}
 
 namespace {
-  struct Printer : public MachineFunctionPass {
+  struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass {
+    static char ID;
+
     std::ostream *OS;
     const std::string Banner;
 
-    Printer (std::ostream *_OS, const std::string &_Banner) :
-      OS (_OS), Banner (_Banner) { }
+    Printer (std::ostream *_OS, const std::string &_Banner) 
+      : MachineFunctionPass((intptr_t)&ID), OS (_OS), Banner (_Banner) { }
 
     const char *getPassName() const { return "MachineFunction Printer"; }
 
@@ -56,6 +64,7 @@ namespace {
       return false;
     }
   };
+  char Printer::ID = 0;
 }
 
 /// Returns a newly-created MachineFunction Printer pass. The default output
@@ -67,7 +76,10 @@ FunctionPass *llvm::createMachineFunctionPrinterPass(std::ostream *OS,
 }
 
 namespace {
-  struct Deleter : public MachineFunctionPass {
+  struct VISIBILITY_HIDDEN Deleter : public MachineFunctionPass {
+    static char ID;
+    Deleter() : MachineFunctionPass((intptr_t)&ID) {}
+
     const char *getPassName() const { return "Machine Code Deleter"; }
 
     bool runOnMachineFunction(MachineFunction &MF) {
@@ -76,6 +88,7 @@ namespace {
       return true;
     }
   };
+  char Deleter::ID = 0;
 }
 
 /// MachineCodeDeletion Pass - This pass deletes all of the machine code for
@@ -98,61 +111,124 @@ MachineBasicBlock* ilist_traits<MachineBasicBlock>::createSentinel() {
 }
 
 void ilist_traits<MachineBasicBlock>::transferNodesFromList(
-  iplist<MachineBasicBlock, ilist_traits<MachineBasicBlock> >& toList,
-  ilist_iterator<MachineBasicBlock> first,
-  ilist_iterator<MachineBasicBlock> last) {
-  if (Parent != toList.Parent)
-    for (; first != last; ++first)
-      first->Parent = toList.Parent;
+            iplist<MachineBasicBlock, ilist_traits<MachineBasicBlock> >& toList,
+            ilist_iterator<MachineBasicBlock> first,
+            ilist_iterator<MachineBasicBlock> last) {
+  // If splicing withing the same function, no change.
+  if (Parent == toList.Parent) return;
+  
+  for (; first != last; ++first)
+    first->setParent(toList.Parent);
 }
 
 MachineFunction::MachineFunction(const Function *F,
                                  const TargetMachine &TM)
-  : Annotation(MF_AID), Fn(F), Target(TM), UsedPhysRegs(0), DebugInfo() {
-  SSARegMapping = new SSARegMap();
+  : Annotation(MF_AID), Fn(F), Target(TM) {
+  RegInfo = new MachineRegisterInfo(*TM.getRegisterInfo());
   MFInfo = 0;
-  FrameInfo = new MachineFrameInfo();
-  ConstantPool = new MachineConstantPool();
+  FrameInfo = new MachineFrameInfo(*TM.getFrameInfo());
+  ConstantPool = new MachineConstantPool(TM.getTargetData());
+  
+  // Set up jump table.
+  const TargetData &TD = *TM.getTargetData();
+  bool IsPic = TM.getRelocationModel() == Reloc::PIC_;
+  unsigned EntrySize = IsPic ? 4 : TD.getPointerSize();
+  unsigned Alignment = IsPic ? TD.getABITypeAlignment(Type::Int32Ty)
+                             : TD.getPointerABIAlignment();
+  JumpTableInfo = new MachineJumpTableInfo(EntrySize, Alignment);
+  
   BasicBlocks.Parent = this;
 }
 
 MachineFunction::~MachineFunction() {
   BasicBlocks.clear();
-  delete SSARegMapping;
+  delete RegInfo;
   delete MFInfo;
   delete FrameInfo;
   delete ConstantPool;
-  delete[] UsedPhysRegs;
+  delete JumpTableInfo;
 }
 
-void MachineFunction::dump() const { print(std::cerr); }
+
+/// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
+/// recomputes them.  This guarantees that the MBB numbers are sequential,
+/// dense, and match the ordering of the blocks within the function.  If a
+/// specific MachineBasicBlock is specified, only that block and those after
+/// it are renumbered.
+void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) {
+  if (empty()) { MBBNumbering.clear(); return; }
+  MachineFunction::iterator MBBI, E = end();
+  if (MBB == 0)
+    MBBI = begin();
+  else
+    MBBI = MBB;
+  
+  // Figure out the block number this should have.
+  unsigned BlockNo = 0;
+  if (MBBI != begin())
+    BlockNo = prior(MBBI)->getNumber()+1;
+  
+  for (; MBBI != E; ++MBBI, ++BlockNo) {
+    if (MBBI->getNumber() != (int)BlockNo) {
+      // Remove use of the old number.
+      if (MBBI->getNumber() != -1) {
+        assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
+               "MBB number mismatch!");
+        MBBNumbering[MBBI->getNumber()] = 0;
+      }
+      
+      // If BlockNo is already taken, set that block's number to -1.
+      if (MBBNumbering[BlockNo])
+        MBBNumbering[BlockNo]->setNumber(-1);
+
+      MBBNumbering[BlockNo] = MBBI;
+      MBBI->setNumber(BlockNo);
+    }
+  }    
+
+  // Okay, all the blocks are renumbered.  If we have compactified the block
+  // numbering, shrink MBBNumbering now.
+  assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
+  MBBNumbering.resize(BlockNo);
+}
+
+
+void MachineFunction::dump() const { print(*cerr.stream()); }
 
 void MachineFunction::print(std::ostream &OS) const {
   OS << "# Machine code for " << Fn->getName () << "():\n";
 
   // Print Frame Information
   getFrameInfo()->print(*this, OS);
+  
+  // Print JumpTable Information
+  getJumpTableInfo()->print(OS);
 
   // Print Constant Pool
   getConstantPool()->print(OS);
   
-  const MRegisterInfo *MRI = getTarget().getRegisterInfo();
+  const TargetRegisterInfo *TRI = getTarget().getRegisterInfo();
   
-  if (livein_begin() != livein_end()) {
+  if (!RegInfo->livein_empty()) {
     OS << "Live Ins:";
-    for (livein_iterator I = livein_begin(), E = livein_end(); I != E; ++I) {
-      if (MRI)
-        OS << " " << MRI->getName(I->first);
+    for (MachineRegisterInfo::livein_iterator
+         I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
+      if (TRI)
+        OS << " " << TRI->getName(I->first);
       else
         OS << " Reg #" << I->first;
+      
+      if (I->second)
+        OS << " in VR#" << I->second << " ";
     }
     OS << "\n";
   }
-  if (liveout_begin() != liveout_end()) {
+  if (!RegInfo->liveout_empty()) {
     OS << "Live Outs:";
-    for (liveout_iterator I = liveout_begin(), E = liveout_end(); I != E; ++I)
-      if (MRI)
-        OS << " " << MRI->getName(*I);
+    for (MachineRegisterInfo::liveout_iterator
+         I = RegInfo->liveout_begin(), E = RegInfo->liveout_end(); I != E; ++I)
+      if (TRI)
+        OS << " " << TRI->getName(*I);
       else
         OS << " Reg #" << *I;
     OS << "\n";
@@ -208,48 +284,11 @@ namespace llvm {
 void MachineFunction::viewCFG() const
 {
 #ifndef NDEBUG
-  std::string Filename = "/tmp/cfg." + getFunction()->getName() + ".dot";
-  std::cerr << "Writing '" << Filename << "'... ";
-  std::ofstream F(Filename.c_str());
-
-  if (!F) {
-    std::cerr << "  error opening file for writing!\n";
-    return;
-  }
-
-  WriteGraph(F, this);
-  F.close();
-  std::cerr << "\n";
-
-#ifdef HAVE_GRAPHVIZ
-  std::cerr << "Running 'Graphviz' program... " << std::flush;
-  if (system((LLVM_PATH_GRAPHVIZ " " + Filename).c_str())) {
-    std::cerr << "Error viewing graph: 'Graphviz' not in path?\n";
-  } else {
-    system(("rm " + Filename).c_str());
-    return;
-  }
-#endif  // HAVE_GRAPHVIZ
-
-#ifdef HAVE_GV
-  std::cerr << "Running 'dot' program... " << std::flush;
-  if (system(("dot -Tps -Nfontname=Courier -Gsize=7.5,10 " + Filename
-              + " > /tmp/cfg.tempgraph.ps").c_str())) {
-    std::cerr << "Error running dot: 'dot' not in path?\n";
-  } else {
-    std::cerr << "\n";
-    system("gv /tmp/cfg.tempgraph.ps");
-  }
-  system(("rm " + Filename + " /tmp/cfg.tempgraph.ps").c_str());
-  return;
-#endif  // HAVE_GV
-#endif  // NDEBUG
-  std::cerr << "MachineFunction::viewCFG is only available in debug builds on "
-            << "systems with Graphviz or gv!\n";
-
-#ifndef NDEBUG
-  system(("rm " + Filename).c_str());
-#endif
+  ViewGraph(this, "mf" + getFunction()->getName());
+#else
+  cerr << "SelectionDAG::viewGraph is only available in debug builds on "
+       << "systems with Graphviz or gv!\n";
+#endif // NDEBUG
 }
 
 void MachineFunction::viewCFGOnly() const
@@ -288,20 +327,20 @@ MachineFunction& MachineFunction::get(const Function *F)
   return *mc;
 }
 
-void MachineFunction::clearSSARegMap() {
-  delete SSARegMapping;
-  SSARegMapping = 0;
-}
-
 //===----------------------------------------------------------------------===//
 //  MachineFrameInfo implementation
 //===----------------------------------------------------------------------===//
 
-/// CreateStackObject - Create a stack object for a value of the specified type.
+/// CreateFixedObject - Create a new object at a fixed location on the stack.
+/// All fixed objects should be created before other objects are created for
+/// efficiency. By default, fixed objects are immutable. This returns an
+/// index with a negative value.
 ///
-int MachineFrameInfo::CreateStackObject(const Type *Ty, const TargetData &TD) {
-  return CreateStackObject((unsigned)TD.getTypeSize(Ty),
-                           TD.getTypeAlignment(Ty));
+int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
+                                        bool Immutable) {
+  assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
+  Objects.insert(Objects.begin(), StackObject(Size, 1, SPOffset, Immutable));
+  return -++NumFixedObjects;
 }
 
 
@@ -321,7 +360,7 @@ void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{
     if (i < NumFixedObjects)
       OS << " fixed";
     if (i < NumFixedObjects || SO.SPOffset != -1) {
-      int Off = SO.SPOffset - ValOffset;
+      int64_t Off = SO.SPOffset - ValOffset;
       OS << " at location [SP";
       if (Off > 0)
         OS << "+" << Off;
@@ -337,17 +376,119 @@ void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{
 }
 
 void MachineFrameInfo::dump(const MachineFunction &MF) const {
-  print(MF, std::cerr);
+  print(MF, *cerr.stream());
 }
 
 
+//===----------------------------------------------------------------------===//
+//  MachineJumpTableInfo implementation
+//===----------------------------------------------------------------------===//
+
+/// getJumpTableIndex - Create a new jump table entry in the jump table info
+/// or return an existing one.
+///
+unsigned MachineJumpTableInfo::getJumpTableIndex(
+                               const std::vector<MachineBasicBlock*> &DestBBs) {
+  assert(!DestBBs.empty() && "Cannot create an empty jump table!");
+  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i)
+    if (JumpTables[i].MBBs == DestBBs)
+      return i;
+  
+  JumpTables.push_back(MachineJumpTableEntry(DestBBs));
+  return JumpTables.size()-1;
+}
+
+
+void MachineJumpTableInfo::print(std::ostream &OS) const {
+  // FIXME: this is lame, maybe we could print out the MBB numbers or something
+  // like {1, 2, 4, 5, 3, 0}
+  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
+    OS << "  <jt #" << i << "> has " << JumpTables[i].MBBs.size() 
+       << " entries\n";
+  }
+}
+
+void MachineJumpTableInfo::dump() const { print(*cerr.stream()); }
+
+
 //===----------------------------------------------------------------------===//
 //  MachineConstantPool implementation
 //===----------------------------------------------------------------------===//
 
-void MachineConstantPool::print(std::ostream &OS) const {
+const Type *MachineConstantPoolEntry::getType() const {
+  if (isMachineConstantPoolEntry())
+      return Val.MachineCPVal->getType();
+  return Val.ConstVal->getType();
+}
+
+MachineConstantPool::~MachineConstantPool() {
+  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
+    if (Constants[i].isMachineConstantPoolEntry())
+      delete Constants[i].Val.MachineCPVal;
+}
+
+/// getConstantPoolIndex - Create a new entry in the constant pool or return
+/// an existing one.  User must specify an alignment in bytes for the object.
+///
+unsigned MachineConstantPool::getConstantPoolIndex(Constant *C, 
+                                                   unsigned Alignment) {
+  assert(Alignment && "Alignment must be specified!");
+  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
+  
+  // Check to see if we already have this constant.
+  //
+  // FIXME, this could be made much more efficient for large constant pools.
+  unsigned AlignMask = (1 << Alignment)-1;
   for (unsigned i = 0, e = Constants.size(); i != e; ++i)
-    OS << "  <cp #" << i << "> is" << *(Value*)Constants[i] << "\n";
+    if (Constants[i].Val.ConstVal == C && (Constants[i].Offset & AlignMask)== 0)
+      return i;
+  
+  unsigned Offset = 0;
+  if (!Constants.empty()) {
+    Offset = Constants.back().getOffset();
+    Offset += TD->getABITypeSize(Constants.back().getType());
+    Offset = (Offset+AlignMask)&~AlignMask;
+  }
+  
+  Constants.push_back(MachineConstantPoolEntry(C, Offset));
+  return Constants.size()-1;
+}
+
+unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V,
+                                                   unsigned Alignment) {
+  assert(Alignment && "Alignment must be specified!");
+  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
+  
+  // Check to see if we already have this constant.
+  //
+  // FIXME, this could be made much more efficient for large constant pools.
+  unsigned AlignMask = (1 << Alignment)-1;
+  int Idx = V->getExistingMachineCPValue(this, Alignment);
+  if (Idx != -1)
+    return (unsigned)Idx;
+  
+  unsigned Offset = 0;
+  if (!Constants.empty()) {
+    Offset = Constants.back().getOffset();
+    Offset += TD->getABITypeSize(Constants.back().getType());
+    Offset = (Offset+AlignMask)&~AlignMask;
+  }
+  
+  Constants.push_back(MachineConstantPoolEntry(V, Offset));
+  return Constants.size()-1;
+}
+
+
+void MachineConstantPool::print(std::ostream &OS) const {
+  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
+    OS << "  <cp #" << i << "> is";
+    if (Constants[i].isMachineConstantPoolEntry())
+      Constants[i].Val.MachineCPVal->print(OS);
+    else
+      OS << *(Value*)Constants[i].Val.ConstVal;
+    OS << " , offset=" << Constants[i].getOffset();
+    OS << "\n";
+  }
 }
 
-void MachineConstantPool::dump() const { print(std::cerr); }
+void MachineConstantPool::dump() const { print(*cerr.stream()); }