X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FBasicBlock.cpp;h=955a0285b2602056a68ea8dbee0eaa0b5d0e08a5;hb=691c05bb29d3e2ec9c2ed6b1c082ce5d484b75da;hp=16aa7faa0859f6166f91058989ed24a42e1574b7;hpb=051a950000e21935165db56695e35bade668193b;p=oota-llvm.git diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp index 16aa7faa085..955a0285b26 100644 --- a/lib/VMCore/BasicBlock.cpp +++ b/lib/VMCore/BasicBlock.cpp @@ -14,68 +14,34 @@ #include "llvm/BasicBlock.h" #include "llvm/Constants.h" #include "llvm/Instructions.h" +#include "llvm/IntrinsicInst.h" +#include "llvm/LLVMContext.h" #include "llvm/Type.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/Support/CFG.h" #include "llvm/Support/LeakDetector.h" -#include "llvm/Support/Compiler.h" #include "SymbolTableListTraitsImpl.h" #include using namespace llvm; -inline ValueSymbolTable * -ilist_traits::getSymTab(BasicBlock *BB) { - if (BB) - if (Function *F = BB->getParent()) - return &F->getValueSymbolTable(); +ValueSymbolTable *BasicBlock::getValueSymbolTable() { + if (Function *F = 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 VISIBILITY_HIDDEN DummyInst : public Instruction { - // allocate space for exactly zero operands - void *operator new(size_t s) { - return User::operator new(s, 0); - } - DummyInst() : Instruction(Type::VoidTy, OtherOpsEnd, 0, 0) { - // This should not be garbage monitored. - LeakDetector::removeGarbageObject(this); - } - - Instruction *clone() const { - assert(0 && "Cannot clone EOL");abort(); - return 0; - } - 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; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == OtherOpsEnd; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } - }; -} - -Instruction *ilist_traits::createSentinel() { - return new DummyInst(); -} -iplist &ilist_traits::getList(BasicBlock *BB) { - return BB->getInstList(); +LLVMContext &BasicBlock::getContext() const { + return getType()->getContext(); } // Explicit instantiation of SymbolTableListTraits since some of the methods // are not in the public header file... -template class SymbolTableListTraits; +template class llvm::SymbolTableListTraits; -BasicBlock::BasicBlock(const std::string &Name, Function *NewParent, - BasicBlock *InsertBefore, BasicBlock *Dest) - : User(Type::LabelTy, Value::BasicBlockVal, &unwindDest, 0/*FIXME*/), Parent(0) { +BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent, + BasicBlock *InsertBefore) + : Value(Type::getLabelTy(C), Value::BasicBlockVal), Parent(0) { // Make sure that we get added to a function LeakDetector::addGarbageObject(this); @@ -89,12 +55,28 @@ BasicBlock::BasicBlock(const std::string &Name, Function *NewParent, } setName(Name); - unwindDest.init(NULL, this); - setUnwindDest(Dest); } BasicBlock::~BasicBlock() { + // If the address of the block is taken and it is being deleted (e.g. because + // it is dead), this means that there is either a dangling constant expr + // hanging off the block, or an undefined use of the block (source code + // expecting the address of a label to keep the block alive even though there + // is no indirect branch). Handle these cases by zapping the BlockAddress + // nodes. There are no other possible uses at this point. + if (hasAddressTaken()) { + assert(!use_empty() && "There should be at least one blockaddress!"); + Constant *Replacement = + ConstantInt::get(llvm::Type::getInt32Ty(getContext()), 1); + while (!use_empty()) { + BlockAddress *BA = cast(use_back()); + BA->replaceAllUsesWith(ConstantExpr::getIntToPtr(Replacement, + BA->getType())); + BA->destroyConstant(); + } + } + assert(getParent() == 0 && "BasicBlock still linked into the program!"); dropAllReferences(); InstList.clear(); @@ -119,19 +101,6 @@ void BasicBlock::eraseFromParent() { getParent()->getBasicBlockList().erase(this); } -const BasicBlock *BasicBlock::getUnwindDest() const { - return cast_or_null(unwindDest.get()); -} - -BasicBlock *BasicBlock::getUnwindDest() { - return cast_or_null(unwindDest.get()); -} - -void BasicBlock::setUnwindDest(BasicBlock *dest) { - NumOperands = unwindDest ? 1 : 0; - unwindDest.set(dest); -} - /// 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) { @@ -158,19 +127,27 @@ const TerminatorInst *BasicBlock::getTerminator() const { return dyn_cast(&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(i)) ++i; - return &*i; +Instruction* BasicBlock::getFirstNonPHI() { + BasicBlock::iterator i = begin(); + // All valid basic blocks should have a terminator, + // which is not a PHINode. If we have an invalid basic + // block we'll get an assertion failure when dereferencing + // a past-the-end iterator. + while (isa(i)) ++i; + return &*i; +} + +Instruction* BasicBlock::getFirstNonPHIOrDbg() { + BasicBlock::iterator i = begin(); + // All valid basic blocks should have a terminator, + // which is not a PHINode. If we have an invalid basic + // block we'll get an assertion failure when dereferencing + // a past-the-end iterator. + while (isa(i) || isa(i)) ++i; + return &*i; } void BasicBlock::dropAllReferences() { - setUnwindDest(NULL); for(iterator I = begin(), E = end(); I != E; ++I) I->dropAllReferences(); } @@ -185,6 +162,25 @@ BasicBlock *BasicBlock::getSinglePredecessor() { return (PI == E) ? ThePred : 0 /*multiple preds*/; } +/// getUniquePredecessor - If this basic block has a unique predecessor block, +/// return the block, otherwise return a null pointer. +/// Note that unique predecessor doesn't mean single edge, there can be +/// multiple edges from the unique predecessor to this block (for example +/// a switch statement with multiple cases having the same destination). +BasicBlock *BasicBlock::getUniquePredecessor() { + pred_iterator PI = pred_begin(this), E = pred_end(this); + if (PI == E) return 0; // No preds. + BasicBlock *PredBB = *PI; + ++PI; + for (;PI != E; ++PI) { + if (*PI != PredBB) + return 0; + // The same predecessor appears multiple times in the predecessor list. + // This is OK. + } + return PredBB; +} + /// removePredecessor - This method is used to notify a BasicBlock that the /// specified Predecessor of the block is no longer able to reach it. This is /// actually not used to update the Predecessor list, but is actually used to @@ -192,8 +188,7 @@ BasicBlock *BasicBlock::getSinglePredecessor() { /// called while the predecessor still refers to this block. /// void BasicBlock::removePredecessor(BasicBlock *Pred, - bool DontDeleteUselessPHIs, - bool OnlyDeleteOne) { + bool DontDeleteUselessPHIs) { assert((hasNUsesOrMore(16)||// Reduce cost of this assertion for complex CFGs. find(pred_begin(this), pred_end(this), Pred) != pred_end(this)) && "removePredecessor: BB is not a predecessor!"); @@ -228,11 +223,7 @@ void BasicBlock::removePredecessor(BasicBlock *Pred, // Yup, loop through and nuke the PHI nodes while (PHINode *PN = dyn_cast(&front())) { // Remove the predecessor first. - if (OnlyDeleteOne) { - int idx = PN->getBasicBlockIndex(Pred); - PN->removeIncomingValue(idx, !DontDeleteUselessPHIs); - } else - PN->removeIncomingValue(Pred, !DontDeleteUselessPHIs); + PN->removeIncomingValue(Pred, !DontDeleteUselessPHIs); // If the PHI _HAD_ two uses, replace PHI node with its now *single* value if (max_idx == 2) { @@ -253,19 +244,15 @@ void BasicBlock::removePredecessor(BasicBlock *Pred, PHINode *PN; for (iterator II = begin(); (PN = dyn_cast(II)); ) { ++II; - if (OnlyDeleteOne) { - int idx = PN->getBasicBlockIndex(Pred); - PN->removeIncomingValue(idx, false); - } else - PN->removeIncomingValue(Pred, false); - + 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(); - } + if (!DontDeleteUselessPHIs && (PNV = PN->hasConstantValue())) + if (PNV != PN) { + PN->replaceAllUsesWith(PNV); + PN->eraseFromParent(); + } } } } @@ -282,12 +269,15 @@ void BasicBlock::removePredecessor(BasicBlock *Pred, /// cause a degenerate basic block to be formed, having a terminator inside of /// the basic block). /// -BasicBlock *BasicBlock::splitBasicBlock(iterator I, const std::string &BBName) { +BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName) { assert(getTerminator() && "Can't use splitBasicBlock on degenerate BB!"); assert(I != InstList.end() && "Trying to get me to create degenerate basic block!"); - BasicBlock *New = new(0/*FIXME*/) BasicBlock(BBName, getParent(), getNext()); + BasicBlock *InsertBefore = llvm::next(Function::iterator(this)) + .getNodePtrUnchecked(); + BasicBlock *New = BasicBlock::Create(getContext(), BBName, + getParent(), InsertBefore); // Move all of the specified instructions from the original basic block into // the new basic block. @@ -317,3 +307,4 @@ BasicBlock *BasicBlock::splitBasicBlock(iterator I, const std::string &BBName) { } return New; } +