X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FBasicBlock.h;h=56b64ed2abf7768b492afa030f3e85ac86907a29;hb=c651e4c51e11feb58e6c12fee8a8f85631269f2f;hp=ce301bd207537a112f1292972c6f106872311f67;hpb=9eb59ec548b861d6ede05b4e6dc22aabf645e665;p=oota-llvm.git diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h index ce301bd2075..56b64ed2abf 100644 --- a/include/llvm/BasicBlock.h +++ b/include/llvm/BasicBlock.h @@ -8,21 +8,7 @@ //===----------------------------------------------------------------------===// // // -// This file contains the declaration of the BasicBlock class, which represents -// a single basic block in the VM. -// -// Note that basic blocks themselves are Value's, because they are referenced -// by instructions like branches and can go in switch tables and stuff... -// -///===---------------------------------------------------------------------===// -// -// Note that well formed basic blocks are formed of a list of instructions -// followed by a single TerminatorInst instruction. TerminatorInst's may not -// occur in the middle of basic blocks, and must terminate the blocks. -// -// This code allows malformed basic blocks to occur, because it may be useful -// in the intermediate stage modification to a program. -// +// This file contains the declaration of the BasicBlock class. //===----------------------------------------------------------------------===// #ifndef LLVM_BASICBLOCK_H @@ -39,24 +25,41 @@ template class SuccIterator; // Successor Iterator template class PredIterator; template<> struct ilist_traits - : public SymbolTableListTraits { + : public SymbolTableListTraits { // 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 &getList(BasicBlock *BB); + static ValueSymbolTable *getSymTab(BasicBlock *ItemParent); + static int getListOffset(); }; +/// This represents a single basic block in LLVM. A basic block is simply a +/// container of instructions that execute sequentially. Basic blocks are Values +/// because they are referenced by instructions such as branches and switch +/// tables. The type of a BasicBlock is "Type::LabelTy" because the basic block +/// represents a label to which a branch can jump. +/// +/// A well formed basic block is formed of a list of non-terminating +/// instructions followed by a single TerminatorInst instruction. +/// TerminatorInst's may not occur in the middle of basic blocks, and must +/// terminate the blocks. The BasicBlock class allows malformed basic blocks to +/// occur because it may be useful in the intermediate stage of constructing or +/// modifying a program. However, the verifier will ensure that basic blocks +/// are "well formed". +/// @brief LLVM Basic Block Representation class BasicBlock : public Value { // Basic blocks are data objects also public: typedef iplist InstListType; private : InstListType InstList; BasicBlock *Prev, *Next; // Next and Prev links for our intrusive linked list + Function *Parent; void setParent(Function *parent); void setNext(BasicBlock *N) { Next = N; } void setPrev(BasicBlock *N) { Prev = N; } - friend class SymbolTableListTraits; + friend class SymbolTableListTraits; BasicBlock(const BasicBlock &); // Do not implement void operator=(const BasicBlock &); // Do not implement @@ -70,28 +73,34 @@ public: /// is automatically inserted at either the end of the function (if /// InsertBefore is null), or before the specified basic block. /// - BasicBlock(const std::string &Name = "", Function *Parent = 0, - BasicBlock *InsertBefore = 0); + explicit BasicBlock(const std::string &Name = "", Function *Parent = 0, + BasicBlock *InsertBefore = 0); ~BasicBlock(); /// getParent - Return the enclosing method, or null if none /// - const Function *getParent() const { return InstList.getParent(); } - Function *getParent() { return InstList.getParent(); } - - // getNext/Prev - Return the next or previous basic block in the list. - BasicBlock *getNext() { return Next; } - const BasicBlock *getNext() const { return Next; } - BasicBlock *getPrev() { return Prev; } - const BasicBlock *getPrev() const { return Prev; } - + 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 and terms). + Instruction *use_back() { return cast(*use_begin());} + const Instruction *use_back() const { return cast(*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. /// TerminatorInst *getTerminator(); const TerminatorInst *const getTerminator() const; - + + /// Returns a pointer to the first instructon in this block that is not a + /// PHINode instruction. When adding instruction to the beginning of the + /// basic block, they should be added before the returned value, not before + /// the first instruction, which might be PHI. + /// Returns 0 is there's no non-PHI instruction. + Instruction* getFirstNonPHI(); + /// removeFromParent - This method unlinks 'this' from the containing /// function, but does not delete it. /// @@ -101,6 +110,15 @@ public: /// and deletes it. /// void eraseFromParent(); + + /// moveBefore - Unlink this basic block from its current function and + /// insert it into the function that MovePos lives in, right before MovePos. + void moveBefore(BasicBlock *MovePos); + + /// moveAfter - Unlink this basic block from its current function and + /// insert it into the function that MovePos lives in, right after MovePos. + void moveAfter(BasicBlock *MovePos); + /// getSinglePredecessor - If this basic block has a single predecessor block, /// return the block, otherwise return a null pointer. @@ -131,12 +149,13 @@ public: 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; /// Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const BasicBlock *BB) { return true; } + static inline bool classof(const BasicBlock *) { return true; } static inline bool classof(const Value *V) { - return V->getValueType() == Value::BasicBlockVal; + return V->getValueID() == Value::BasicBlockVal; } /// dropAllReferences() - This function causes all the subinstructions to "let @@ -170,8 +189,27 @@ public: /// the basic block). /// BasicBlock *splitBasicBlock(iterator I, const std::string &BBName = ""); + + + static unsigned getInstListOffset() { + BasicBlock *Obj = 0; + return unsigned(reinterpret_cast(&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; } }; +inline int +ilist_traits::getListOffset() { + return BasicBlock::getInstListOffset(); +} + } // End llvm namespace #endif