CbC/CbC_llvm: include/llvm/IR/BasicBlock.h comparison

comparison include/llvm/IR/BasicBlock.h @ 95:afa8332a0e37 LLVM3.8

LLVM 3.8

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Tue, 13 Oct 2015 17:48:58 +0900
parents	60c9769439b8
children	7d135dc70f03

comparison

equal deleted inserted replaced

-:f3e34b893a5f
+:afa8332a0e37
 class CallInst;
 class LandingPadInst;
 class TerminatorInst;
 class LLVMContext;
 class BlockAddress;
+class Function;
-template<> struct ilist_traits<Instruction>
-: public SymbolTableListTraits<Instruction, BasicBlock> {
+template <>
+struct SymbolTableListSentinelTraits<BasicBlock>
-/// \brief Return a node that marks the end of a list.
+: public ilist_half_embedded_sentinel_traits<BasicBlock> {};
-///
-/// 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 their corresponding traits,
-// placing a data member in this class will augment the i(p)list.  But since
-// the NodeTy is expected to be publicly derive from ilist_node<NodeTy>,
-// there is a legal viable downcast from it to NodeTy. We use this trick to
-// superimpose an 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_half_node<Instruction> Sentinel;
-};
 /// \brief LLVM Basic Block Representation
 ///
 /// This represents a single basic block in LLVM. A basic block is simply a
 /// container of instructions that execute sequentially. Basic blocks are Values
 /// are "well formed".
 class BasicBlock : public Value, // Basic blocks are data objects also
 public ilist_node<BasicBlock> {
 friend class BlockAddress;
 public:
-typedef iplist<Instruction> InstListType;
+typedef SymbolTableList<Instruction> InstListType;
 private:
 InstListType InstList;
 Function *Parent;
 void setParent(Function *parent);
-friend class SymbolTableListTraits<BasicBlock, Function>;
+friend class SymbolTableListTraits<BasicBlock>;
 BasicBlock(const BasicBlock &) = delete;
 void operator=(const BasicBlock &) = delete;
 /// \brief Constructor.
 static BasicBlock *Create(LLVMContext &Context, const Twine &Name = "",
 Function *Parent = nullptr,
 BasicBlock *InsertBefore = nullptr) {
 return new BasicBlock(Context, Name, Parent, InsertBefore);
 }
-~BasicBlock();
+~BasicBlock() override;
 /// \brief Return the enclosing method, or null if none.
 const Function *getParent() const { return Parent; }
 Function *getParent()       { return Parent; }
-const DataLayout *getDataLayout() const;
+/// \brief Return the module owning the function this basic block belongs to,
+/// or nullptr it the function does not have a module.
+///
+/// Note: this is undefined behavior if the block does not have a parent.
+const Module *getModule() const;
+Module *getModule();
 /// \brief Returns the terminator instruction if the block is well formed or
 /// null if the block is not well formed.
 TerminatorInst *getTerminator();
 const TerminatorInst *getTerminator() const;
 /// \brief Unlink 'this' from the containing function, but do not delete it.
 void removeFromParent();
 /// \brief Unlink 'this' from the containing function and delete it.
-void eraseFromParent();
+///
+// \returns an iterator pointing to the element after the erased one.
+SymbolTableList<BasicBlock>::iterator eraseFromParent();
 /// \brief Unlink this basic block from its current function and insert it
 /// into the function that \p MovePos lives in, right before \p MovePos.
 void moveBefore(BasicBlock *MovePos);
 BasicBlock *getUniquePredecessor();
 const BasicBlock *getUniquePredecessor() const {
 return const_cast<BasicBlock*>(this)->getUniquePredecessor();
 }
-/// Return the successor of this block if it has a unique successor.
+/// \brief Return the successor of this block if it has a single successor.
-/// Otherwise return a null pointer.  This method is analogous to
+/// Otherwise return a null pointer.
-/// getUniquePredeccessor above.
+///
+/// This method is analogous to getSinglePredecessor above.
+BasicBlock *getSingleSuccessor();
+const BasicBlock *getSingleSuccessor() const {
+return const_cast<BasicBlock*>(this)->getSingleSuccessor();
+}
+/// \brief Return the successor of this block if it has a unique successor.
+/// Otherwise return a null pointer.
+///
+/// This method is analogous to getUniquePredecessor above.
 BasicBlock *getUniqueSuccessor();
 const BasicBlock *getUniqueSuccessor() const {
 return const_cast<BasicBlock*>(this)->getUniqueSuccessor();
 }
 /// directly if you want to modify it.
 const InstListType &getInstList() const { return InstList; }
 InstListType &getInstList()       { return InstList; }
 /// \brief Returns a pointer to a member of the instruction list.
-static iplist<Instruction> BasicBlock::*getSublistAccess(Instruction*) {
+static InstListType BasicBlock::*getSublistAccess(Instruction*) {
 return &BasicBlock::InstList;
 }
 /// \brief Returns a pointer to the symbol table if one exists.
 ValueSymbolTable *getValueSymbolTable();
 /// This is actually not used to update the Predecessor list, but is actually
 /// used to update the PHI nodes that reside in the block.  Note that this
 /// should be called while the predecessor still refers to this block.
 void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs = false);
+bool canSplitPredecessors() const;
 /// \brief Split the basic block into two basic blocks at the specified
 /// instruction.
 ///
 /// Note that all instructions BEFORE the specified iterator stay as part of
 /// the original basic block, an unconditional branch is added to the original
 bool hasAddressTaken() const { return getSubclassDataFromValue() != 0; }
 /// \brief Update all phi nodes in this basic block's successors to refer to
 /// basic block \p New instead of to it.
 void replaceSuccessorsPhiUsesWith(BasicBlock *New);
+/// \brief Return true if this basic block is an exception handling block.
+bool isEHPad() const { return getFirstNonPHI()->isEHPad(); }
 /// \brief Return true if this basic block is a landing pad.
 ///
 /// Being a ``landing pad'' means that the basic block is the destination of
 /// the 'unwind' edge of an invoke instruction.

Mercurial > hg > CbC > CbC_llvm

comparison include/llvm/IR/BasicBlock.h @ 95:afa8332a0e37 LLVM3.8