//
// 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.
//
//===----------------------------------------------------------------------===//
//
return 0;
}
-DummyInst::DummyInst() : Instruction(Type::VoidTy, OtherOpsEnd, 0, 0) {
- // This should not be garbage monitored.
- LeakDetector::removeGarbageObject(this);
+
+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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
+ };
}
Instruction *ilist_traits<Instruction>::createSentinel() {
}
-void BasicBlock::destroyThis(BasicBlock*v)
-{
- assert(v->getParent() == 0 && "BasicBlock still linked into the program!");
- v->dropAllReferences();
- v->InstList.clear();
- Value::destroyThis(v);
+BasicBlock::~BasicBlock() {
+ assert(getParent() == 0 && "BasicBlock still linked into the program!");
+ dropAllReferences();
+ InstList.clear();
}
void BasicBlock::setParent(Function *parent) {
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;
+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<PHINode>(i)) ++i;
+ return &*i;
}
void BasicBlock::dropAllReferences() {
assert(I != InstList.end() &&
"Trying to get me to create degenerate basic block!");
- BasicBlock *New = new BasicBlock(BBName, getParent(), getNext());
+ BasicBlock *New = BasicBlock::Create(BBName, getParent(), getNext());
// Move all of the specified instructions from the original basic block into
// the new basic block.
New->getInstList().splice(New->end(), this->getInstList(), I, end());
// Add a branch instruction to the newly formed basic block.
- new BranchInst(New, this);
+ BranchInst::Create(New, this);
// Now we must loop through all of the successors of the New block (which
// _were_ the successors of the 'this' block), and update any PHI nodes in