Make DomTree and PostDomTree thin wrappers around DomTreeBase, rather than inheriting...

[oota-llvm.git] / lib / VMCore / BasicBlock.cpp

diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp
index 98d12d8f1381368a497887dec4fe6037a4942545..92734bb2138f61357c5c1878ebe88adc659141a4 100644 (file)
--- a/lib/VMCore/BasicBlock.cpp
+++ b/lib/VMCore/BasicBlock.cpp
@@ -17,24 +17,34 @@
 #include "llvm/Type.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/LeakDetector.h"
+#include "llvm/Support/Compiler.h"
 #include "SymbolTableListTraitsImpl.h"
 #include <algorithm>
 using namespace llvm;
 
+inline ValueSymbolTable *
+ilist_traits<Instruction>::getSymTab(BasicBlock *BB) {
+  if (BB)
+    if (Function *F = BB->getParent())
+      return &F->getValueSymbolTable();
+  return 0;
+}
+
+
 namespace {
   /// DummyInst - An instance of this class is used to mark the end of the
   /// instruction list.  This is not a real instruction.
-  struct DummyInst : public Instruction {
+  struct VISIBILITY_HIDDEN DummyInst : public Instruction {
     DummyInst() : Instruction(Type::VoidTy, OtherOpsEnd, 0, 0) {
       // This should not be garbage monitored.
       LeakDetector::removeGarbageObject(this);
     }
 
-    virtual Instruction *clone() const {
+    Instruction *clone() const {
       assert(0 && "Cannot clone EOL");abort();
       return 0;
     }
-    virtual const char *getOpcodeName() const { return "*end-of-list-inst*"; }
+    const char *getOpcodeName() const { return "*end-of-list-inst*"; }
 
     // Methods for support type inquiry through isa, cast, and dyn_cast...
     static inline bool classof(const DummyInst *) { return true; }
@@ -56,25 +66,25 @@ iplist<Instruction> &ilist_traits<Instruction>::getList(BasicBlock *BB) {
 
 // Explicit instantiation of SymbolTableListTraits since some of the methods
 // are not in the public header file...
-template class SymbolTableListTraits<Instruction, BasicBlock, Function>;
+template class SymbolTableListTraits<Instruction, BasicBlock>;
 
 
-BasicBlock::BasicBlock(const std::string &Name, Function *Parent,
+BasicBlock::BasicBlock(const std::string &Name, Function *NewParent,
                        BasicBlock *InsertBefore)
-  : Value(Type::LabelTy, Value::BasicBlockVal, Name) {
-  // Initialize the instlist...
-  InstList.setItemParent(this);
+  : Value(Type::LabelTy, Value::BasicBlockVal), Parent(0) {
 
   // Make sure that we get added to a function
   LeakDetector::addGarbageObject(this);
 
   if (InsertBefore) {
-    assert(Parent &&
+    assert(NewParent &&
            "Cannot insert block before another block with no function!");
-    Parent->getBasicBlockList().insert(InsertBefore, this);
-  } else if (Parent) {
-    Parent->getBasicBlockList().push_back(this);
+    NewParent->getBasicBlockList().insert(InsertBefore, this);
+  } else if (NewParent) {
+    NewParent->getBasicBlockList().push_back(this);
   }
+  
+  setName(Name);
 }
 
 
@@ -88,7 +98,8 @@ void BasicBlock::setParent(Function *parent) {
   if (getParent())
     LeakDetector::addGarbageObject(this);
 
-  InstList.setParent(parent);
+  // Set Parent=parent, updating instruction symtab entries as appropriate.
+  InstList.setSymTabObject(&Parent, parent);
 
   if (getParent())
     LeakDetector::removeGarbageObject(this);
@@ -102,6 +113,21 @@ void BasicBlock::eraseFromParent() {
   getParent()->getBasicBlockList().erase(this);
 }
 
+/// moveBefore - Unlink this basic block from its current function and
+/// insert it into the function that MovePos lives in, right before MovePos.
+void BasicBlock::moveBefore(BasicBlock *MovePos) {
+  MovePos->getParent()->getBasicBlockList().splice(MovePos,
+                       getParent()->getBasicBlockList(), this);
+}
+
+/// moveAfter - Unlink this basic block from its current function and
+/// insert it into the function that MovePos lives in, right after MovePos.
+void BasicBlock::moveAfter(BasicBlock *MovePos) {
+  Function::iterator I = MovePos;
+  MovePos->getParent()->getBasicBlockList().splice(++I,
+                                       getParent()->getBasicBlockList(), this);
+}
+
 
 TerminatorInst *BasicBlock::getTerminator() {
   if (InstList.empty()) return 0;
@@ -113,6 +139,17 @@ const TerminatorInst *const BasicBlock::getTerminator() const {
   return dyn_cast<TerminatorInst>(&InstList.back());
 }
 
+Instruction* BasicBlock::getFirstNonPHI()
+{
+    BasicBlock::iterator i = begin();
+    // All valid basic blocks should have a terminator,
+    // which is not a PHINode. If we have invalid basic
+    // block we'll get assert when dereferencing past-the-end
+    // iterator.
+    while (isa<PHINode>(i)) ++i;
+    return &*i;
+}
+
 void BasicBlock::dropAllReferences() {
   for(iterator I = begin(), E = end(); I != E; ++I)
     I->dropAllReferences();
@@ -189,8 +226,17 @@ void BasicBlock::removePredecessor(BasicBlock *Pred,
     // Okay, now we know that we need to remove predecessor #pred_idx from all
     // PHI nodes.  Iterate over each PHI node fixing them up
     PHINode *PN;
-    for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ++II)
+    for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ) {
+      ++II;
       PN->removeIncomingValue(Pred, false);
+      // If all incoming values to the Phi are the same, we can replace the Phi
+      // with that value.
+      Value* PNV = 0;
+      if (!DontDeleteUselessPHIs && (PNV = PN->hasConstantValue())) {
+        PN->replaceAllUsesWith(PNV);
+        PN->eraseFromParent();
+      }
+    }
   }
 }