//
// 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/Constants.h"
#include "llvm/Instructions.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"
/// 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);
}
- 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; }
BasicBlock::BasicBlock(const std::string &Name, Function *NewParent,
BasicBlock *InsertBefore)
: Value(Type::LabelTy, Value::BasicBlockVal), Parent(0) {
- // Initialize the instlist.
- InstList.setItemParent(this);
// Make sure that we get added to a function
LeakDetector::addGarbageObject(this);
return dyn_cast<TerminatorInst>(&InstList.back());
}
-const TerminatorInst *const BasicBlock::getTerminator() const {
+const TerminatorInst *BasicBlock::getTerminator() const {
if (InstList.empty()) return 0;
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 *InsertBefore = next(Function::iterator(this))
+ .getNodePtrUnchecked();
+ BasicBlock *New = BasicBlock::Create(BBName, getParent(), InsertBefore);
// 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