Index: llvm/trunk/include/llvm/IR/BasicBlock.h =================================================================== --- llvm/trunk/include/llvm/IR/BasicBlock.h +++ llvm/trunk/include/llvm/IR/BasicBlock.h @@ -41,7 +41,7 @@ class TerminatorInst; class ValueSymbolTable; -/// \brief LLVM Basic Block Representation +/// 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 @@ -70,7 +70,7 @@ void setParent(Function *parent); - /// \brief Constructor. + /// Constructor. /// /// If the function parameter is specified, the basic block is automatically /// inserted at either the end of the function (if InsertBefore is null), or @@ -84,7 +84,7 @@ BasicBlock &operator=(const BasicBlock &) = delete; ~BasicBlock(); - /// \brief Get the context in which this basic block lives. + /// Get the context in which this basic block lives. LLVMContext &getContext() const; /// Instruction iterators... @@ -93,7 +93,7 @@ using reverse_iterator = InstListType::reverse_iterator; using const_reverse_iterator = InstListType::const_reverse_iterator; - /// \brief Creates a new BasicBlock. + /// 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 @@ -104,12 +104,12 @@ return new BasicBlock(Context, Name, Parent, InsertBefore); } - /// \brief Return the enclosing method, or null if none. + /// Return the enclosing method, or null if none. const Function *getParent() const { return Parent; } Function *getParent() { return Parent; } - /// \brief Return the module owning the function this basic block belongs to, - /// or nullptr it the function does not have a module. + /// Return the module owning the function this basic block belongs to, or + /// nullptr if the function does not have a module. /// /// Note: this is undefined behavior if the block does not have a parent. const Module *getModule() const; @@ -118,34 +118,34 @@ static_cast(this)->getModule()); } - /// \brief Returns the terminator instruction if the block is well formed or - /// null if the block is not well formed. + /// Returns the terminator instruction if the block is well formed or null + /// if the block is not well formed. const TerminatorInst *getTerminator() const LLVM_READONLY; TerminatorInst *getTerminator() { return const_cast( static_cast(this)->getTerminator()); } - /// \brief Returns the call instruction calling @llvm.experimental.deoptimize - /// prior to the terminating return instruction of this basic block, if such a - /// call is present. Otherwise, returns null. + /// Returns the call instruction calling @llvm.experimental.deoptimize + /// prior to the terminating return instruction of this basic block, if such + /// a call is present. Otherwise, returns null. const CallInst *getTerminatingDeoptimizeCall() const; CallInst *getTerminatingDeoptimizeCall() { return const_cast( static_cast(this)->getTerminatingDeoptimizeCall()); } - /// \brief Returns the call instruction marked 'musttail' prior to the - /// terminating return instruction of this basic block, if such a call is - /// present. Otherwise, returns null. + /// Returns the call instruction marked 'musttail' prior to the terminating + /// return instruction of this basic block, if such a call is present. + /// Otherwise, returns null. const CallInst *getTerminatingMustTailCall() const; CallInst *getTerminatingMustTailCall() { return const_cast( static_cast(this)->getTerminatingMustTailCall()); } - /// \brief Returns a pointer to the first instruction in this block that is - /// not a PHINode instruction. + /// Returns a pointer to the first instruction in this block that is not a + /// PHINode instruction. /// /// When adding instructions to the beginning of the basic block, they should /// be added before the returned value, not before the first instruction, @@ -156,23 +156,23 @@ static_cast(this)->getFirstNonPHI()); } - /// \brief Returns a pointer to the first instruction in this block that is not - /// a PHINode or a debug intrinsic. + /// Returns a pointer to the first instruction in this block that is not a + /// PHINode or a debug intrinsic. const Instruction* getFirstNonPHIOrDbg() const; Instruction* getFirstNonPHIOrDbg() { return const_cast( static_cast(this)->getFirstNonPHIOrDbg()); } - /// \brief Returns a pointer to the first instruction in this block that is not - /// a PHINode, a debug intrinsic, or a lifetime intrinsic. + /// Returns a pointer to the first instruction in this block that is not a + /// PHINode, a debug intrinsic, or a lifetime intrinsic. const Instruction* getFirstNonPHIOrDbgOrLifetime() const; Instruction* getFirstNonPHIOrDbgOrLifetime() { return const_cast( static_cast(this)->getFirstNonPHIOrDbgOrLifetime()); } - /// \brief Returns an iterator to the first instruction in this block that is + /// Returns an iterator to the first instruction in this block that is /// suitable for inserting a non-PHI instruction. /// /// In particular, it skips all PHIs and LandingPad instructions. @@ -182,23 +182,23 @@ ->getFirstInsertionPt().getNonConst(); } - /// \brief Unlink 'this' from the containing function, but do not delete it. + /// Unlink 'this' from the containing function, but do not delete it. void removeFromParent(); - /// \brief Unlink 'this' from the containing function and delete it. + /// Unlink 'this' from the containing function and delete it. /// // \returns an iterator pointing to the element after the erased one. SymbolTableList::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. + /// 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); - /// \brief Unlink this basic block from its current function and insert it + /// Unlink this basic block from its current function and insert it /// right after \p MovePos in the function \p MovePos lives in. void moveAfter(BasicBlock *MovePos); - /// \brief Insert unlinked basic block into a function. + /// Insert unlinked basic block into a function. /// /// Inserts an unlinked basic block into \c Parent. If \c InsertBefore is /// provided, inserts before that basic block, otherwise inserts at the end. @@ -206,7 +206,7 @@ /// \pre \a getParent() is \c nullptr. void insertInto(Function *Parent, BasicBlock *InsertBefore = nullptr); - /// \brief Return the predecessor of this block if it has a single predecessor + /// Return the predecessor of this block if it has a single predecessor /// block. Otherwise return a null pointer. const BasicBlock *getSinglePredecessor() const; BasicBlock *getSinglePredecessor() { @@ -214,7 +214,7 @@ static_cast(this)->getSinglePredecessor()); } - /// \brief Return the predecessor of this block if it has a unique predecessor + /// Return the predecessor of this block if it has a unique predecessor /// block. Otherwise return a null pointer. /// /// Note that unique predecessor doesn't mean single edge, there can be @@ -226,7 +226,7 @@ static_cast(this)->getUniquePredecessor()); } - /// \brief Return the successor of this block if it has a single successor. + /// Return the successor of this block if it has a single successor. /// Otherwise return a null pointer. /// /// This method is analogous to getSinglePredecessor above. @@ -236,7 +236,7 @@ static_cast(this)->getSingleSuccessor()); } - /// \brief Return the successor of this block if it has a unique successor. + /// Return the successor of this block if it has a unique successor. /// Otherwise return a null pointer. /// /// This method is analogous to getUniquePredecessor above. @@ -310,28 +310,28 @@ } iterator_range phis(); - /// \brief Return the underlying instruction list container. + /// Return the underlying instruction list container. /// /// Currently you need to access the underlying instruction list container /// 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. + /// Returns a pointer to a member of the instruction list. static InstListType BasicBlock::*getSublistAccess(Instruction*) { return &BasicBlock::InstList; } - /// \brief Returns a pointer to the symbol table if one exists. + /// Returns a pointer to the symbol table if one exists. ValueSymbolTable *getValueSymbolTable(); - /// \brief Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static bool classof(const Value *V) { return V->getValueID() == Value::BasicBlockVal; } - /// \brief Cause all subinstructions to "let go" of all the references that - /// said subinstructions are maintaining. + /// Cause all subinstructions to "let go" of all the references that said + /// subinstructions are maintaining. /// /// This allows one to 'delete' a whole class at a time, even though there may /// be circular references... first all references are dropped, and all use @@ -340,8 +340,8 @@ /// except operator delete. void dropAllReferences(); - /// \brief Notify the BasicBlock that the predecessor \p Pred is no longer - /// able to reach it. + /// Notify the BasicBlock that the predecessor \p Pred is no longer able to + /// reach it. /// /// 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 @@ -350,8 +350,7 @@ bool canSplitPredecessors() const; - /// \brief Split the basic block into two basic blocks at the specified - /// instruction. + /// 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 @@ -371,37 +370,37 @@ return splitBasicBlock(I->getIterator(), BBName); } - /// \brief Returns true if there are any uses of this basic block other than + /// Returns true if there are any uses of this basic block other than /// direct branches, switches, etc. to it. 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. + /// 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. + /// 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. + /// 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. bool isLandingPad() const; - /// \brief Return the landingpad instruction associated with the landing pad. + /// Return the landingpad instruction associated with the landing pad. const LandingPadInst *getLandingPadInst() const; LandingPadInst *getLandingPadInst() { return const_cast( static_cast(this)->getLandingPadInst()); } - /// \brief Return true if it is legal to hoist instructions into this block. + /// Return true if it is legal to hoist instructions into this block. bool isLegalToHoistInto() const; Optional getIrrLoopHeaderWeight() const; private: - /// \brief Increment the internal refcount of the number of BlockAddresses + /// Increment the internal refcount of the number of BlockAddresses /// referencing this BasicBlock by \p Amt. /// /// This is almost always 0, sometimes one possibly, but almost never 2, and @@ -412,8 +411,8 @@ "Refcount wrap-around"); } - /// \brief Shadow Value::setValueSubclassData with a private forwarding method - /// so that any future subclasses cannot accidentally use it. + /// Shadow Value::setValueSubclassData with a private forwarding method so + /// that any future subclasses cannot accidentally use it. void setValueSubclassData(unsigned short D) { Value::setValueSubclassData(D); }