//
//===----------------------------------------------------------------------===//
//
-//
// This file contains the declaration of the BasicBlock class.
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_BASICBLOCK_H
#include "llvm/Instruction.h"
#include "llvm/SymbolTableListTraits.h"
-#include "llvm/ADT/ilist"
+#include "llvm/ADT/ilist.h"
#include "llvm/Support/DataTypes.h"
namespace llvm {
class TerminatorInst;
-template <class Term, class BB> class SuccIterator; // Successor Iterator
-template <class Ptr, class USE_iterator> class PredIterator;
+struct LLVMContext;
template<> struct ilist_traits<Instruction>
: public SymbolTableListTraits<Instruction, BasicBlock> {
- // createSentinel is used to create a node that marks the end of the list...
- static Instruction *createSentinel();
- static void destroySentinel(Instruction *I) { delete I; }
- static iplist<Instruction> &getList(BasicBlock *BB);
- static ValueSymbolTable *getSymTab(BasicBlock *ItemParent);
- static int getListOffset();
+ // createSentinel is used to get hold of a node that marks the end of
+ // the list...
+ // The sentinel is relative to this instance, so we use a non-static
+ // method.
+ Instruction *createSentinel() const {
+ // since i(p)lists always publicly derive from the corresponding
+ // traits, placing a data member in this class will augment i(p)list.
+ // But since the NodeTy is expected to publicly derive from
+ // ilist_node<NodeTy>, there is a legal viable downcast from it
+ // to NodeTy. We use this trick to superpose i(p)list with a "ghostly"
+ // NodeTy, which becomes the sentinel. Dereferencing the sentinel is
+ // forbidden (save the ilist_node<NodeTy>) so no one will ever notice
+ // the superposition.
+ return static_cast<Instruction*>(&Sentinel);
+ }
+ static void destroySentinel(Instruction*) {}
+
+ Instruction *provideInitialHead() const { return createSentinel(); }
+ Instruction *ensureHead(Instruction*) const { return createSentinel(); }
+ static void noteHead(Instruction*, Instruction*) {}
+private:
+ mutable ilist_node<Instruction> Sentinel;
};
/// This represents a single basic block in LLVM. A basic block is simply a
/// modifying a program. However, the verifier will ensure that basic blocks
/// are "well formed".
/// @brief LLVM Basic Block Representation
-class BasicBlock : public User { // Basic blocks are data objects also
+class BasicBlock : public Value, // Basic blocks are data objects also
+ public ilist_node<BasicBlock> {
+
public:
typedef iplist<Instruction> InstListType;
-private :
+private:
InstListType InstList;
- BasicBlock *Prev, *Next; // Next and Prev links for our intrusive linked list
Function *Parent;
- Use unwindDest;
void setParent(Function *parent);
- void setNext(BasicBlock *N) { Next = N; }
- void setPrev(BasicBlock *N) { Prev = N; }
friend class SymbolTableListTraits<BasicBlock, Function>;
BasicBlock(const BasicBlock &); // Do not implement
/// is automatically inserted at either the end of the function (if
/// InsertBefore is null), or before the specified basic block.
///
- explicit BasicBlock(const std::string &Name = "", Function *Parent = 0,
- BasicBlock *InsertBefore = 0, BasicBlock *UnwindDest = 0);
+ explicit BasicBlock(const Twine &Name = "", Function *Parent = 0,
+ BasicBlock *InsertBefore = 0);
public:
+ /// getContext - Get the context in which this basic block lives,
+ /// or null if it is not currently attached to a function.
+ LLVMContext &getContext() const;
+
/// Instruction iterators...
typedef InstListType::iterator iterator;
typedef InstListType::const_iterator const_iterator;
- // allocate space for exactly zero operands
- static BasicBlock *Create(const std::string &Name = "", Function *Parent = 0,
- BasicBlock *InsertBefore = 0, BasicBlock *UnwindDest = 0) {
- return new(!!UnwindDest) BasicBlock(Name, Parent, InsertBefore, UnwindDest);
+ /// Create - Creates a new BasicBlock. If the Parent parameter is specified,
+ /// the basic block is automatically inserted at either the end of the
+ /// function (if InsertBefore is 0), or before the specified basic block.
+ static BasicBlock *Create(const Twine &Name = "", Function *Parent = 0,
+ BasicBlock *InsertBefore = 0) {
+ return new BasicBlock(Name, Parent, InsertBefore);
}
~BasicBlock();
- /// getUnwindDest - Returns the BasicBlock that flow will enter if an unwind
- /// instruction occurs in this block. May be null, in which case unwinding
- /// is undefined in this block.
- const BasicBlock *getUnwindDest() const;
- BasicBlock *getUnwindDest();
-
- /// setUnwindDest - Set which BasicBlock flow will enter if an unwind is
- /// executed within this block. It may be set to null if unwinding is not
- /// permitted in this block.
- void setUnwindDest(BasicBlock *unwindDest);
-
/// getParent - Return the enclosing method, or null if none
///
const Function *getParent() const { return Parent; }
Function *getParent() { return Parent; }
+ /// use_back - Specialize the methods defined in Value, as we know that an
+ /// BasicBlock can only be used by Instructions (specifically PHI nodes and
+ /// terminators).
+ Instruction *use_back() { return cast<Instruction>(*use_begin());}
+ const Instruction *use_back() const { return cast<Instruction>(*use_begin());}
+
/// getTerminator() - If this is a well formed basic block, then this returns
/// a pointer to the terminator instruction. If it is not, then you get a
/// null pointer back.
/// the first instruction, which might be PHI.
/// Returns 0 is there's no non-PHI instruction.
Instruction* getFirstNonPHI();
+ const Instruction* getFirstNonPHI() const {
+ return const_cast<BasicBlock*>(this)->getFirstNonPHI();
+ }
/// removeFromParent - This method unlinks 'this' from the containing
/// function, but does not delete it.
return const_cast<BasicBlock*>(this)->getSinglePredecessor();
}
+ /// 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 *getUniquePredecessor();
+ const BasicBlock *getUniquePredecessor() const {
+ return const_cast<BasicBlock*>(this)->getUniquePredecessor();
+ }
+
//===--------------------------------------------------------------------===//
/// Instruction iterator methods
///
const InstListType &getInstList() const { return InstList; }
InstListType &getInstList() { return InstList; }
- virtual void print(std::ostream &OS) const { print(OS, 0); }
- void print(std::ostream *OS) const { if (OS) print(*OS); }
- void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
+ /// getSublistAccess() - returns pointer to member of instruction list
+ static iplist<Instruction> BasicBlock::*getSublistAccess(Instruction*) {
+ return &BasicBlock::InstList;
+ }
+
+ /// getValueSymbolTable() - returns pointer to symbol table (if any)
+ ValueSymbolTable *getValueSymbolTable();
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const BasicBlock *) { return true; }
/// update the PHI nodes that reside in the block. Note that this should be
/// called while the predecessor still refers to this block.
///
- /// DontDeleteUselessPHIs will keep PHIs that have one value or the same
- /// value for all entries.
- ///
- /// OnlyDeleteOne will only remove one entry from a PHI, in case there were
- /// duplicate entries for the Pred.
- ///
- void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs = false,
- bool OnlyDeleteOne = false);
+ void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs = false);
/// splitBasicBlock - This splits a basic block into two at the specified
/// instruction. Note that all instructions BEFORE the specified iterator
/// cause a degenerate basic block to be formed, having a terminator inside of
/// the basic block).
///
- BasicBlock *splitBasicBlock(iterator I, const std::string &BBName = "");
-
-
- static unsigned getInstListOffset() {
- BasicBlock *Obj = 0;
- return unsigned(reinterpret_cast<uintptr_t>(&Obj->InstList));
- }
-
-private:
- // getNext/Prev - Return the next or previous basic block in the list. Access
- // these with Function::iterator.
- BasicBlock *getNext() { return Next; }
- const BasicBlock *getNext() const { return Next; }
- BasicBlock *getPrev() { return Prev; }
- const BasicBlock *getPrev() const { return Prev; }
+ BasicBlock *splitBasicBlock(iterator I, const Twine &BBName = "");
};
-inline int
-ilist_traits<Instruction>::getListOffset() {
- return BasicBlock::getInstListOffset();
-}
-
} // End llvm namespace
#endif
projects / oota-llvm.git / blobdiff