diff options
87 files changed, 839 insertions, 839 deletions
diff --git a/llvm/docs/GarbageCollection.rst b/llvm/docs/GarbageCollection.rst index f7a987f4960..e4f5802f887 100644 --- a/llvm/docs/GarbageCollection.rst +++ b/llvm/docs/GarbageCollection.rst @@ -433,7 +433,7 @@ data structure, but there are only 20 lines of meaningful code.) .. code-block:: c++ - /// @brief The map for a single function's stack frame. One of these is + /// The map for a single function's stack frame. One of these is /// compiled as constant data into the executable for each function. /// /// Storage of metadata values is elided if the %metadata parameter to @@ -444,7 +444,7 @@ data structure, but there are only 20 lines of meaningful code.) const void *Meta[0]; //< Metadata for each root. }; - /// @brief A link in the dynamic shadow stack. One of these is embedded in + /// A link in the dynamic shadow stack. One of these is embedded in /// the stack frame of each function on the call stack. struct StackEntry { StackEntry *Next; //< Link to next stack entry (the caller's). @@ -452,13 +452,13 @@ data structure, but there are only 20 lines of meaningful code.) void *Roots[0]; //< Stack roots (in-place array). }; - /// @brief The head of the singly-linked list of StackEntries. Functions push + /// The head of the singly-linked list of StackEntries. Functions push /// and pop onto this in their prologue and epilogue. /// /// Since there is only a global list, this technique is not threadsafe. StackEntry *llvm_gc_root_chain; - /// @brief Calls Visitor(root, meta) for each GC root on the stack. + /// Calls Visitor(root, meta) for each GC root on the stack. /// root and meta are exactly the values passed to /// @llvm.gcroot. /// diff --git a/llvm/include/llvm/ADT/APInt.h b/llvm/include/llvm/ADT/APInt.h index 8377ba6a041..1f3f7f5f592 100644 --- a/llvm/include/llvm/ADT/APInt.h +++ b/llvm/include/llvm/ADT/APInt.h @@ -311,7 +311,7 @@ public: APInt(unsigned numBits, StringRef str, uint8_t radix); /// Simply makes *this a copy of that. - /// @brief Copy Constructor. + /// Copy Constructor. APInt(const APInt &that) : BitWidth(that.BitWidth) { if (isSingleWord()) U.VAL = that.U.VAL; @@ -737,7 +737,7 @@ public: return *this; } - /// @brief Move assignment operator. + /// Move assignment operator. APInt &operator=(APInt &&that) { #ifdef _MSC_VER // The MSVC std::shuffle implementation still does self-assignment. diff --git a/llvm/include/llvm/Analysis/DOTGraphTraitsPass.h b/llvm/include/llvm/Analysis/DOTGraphTraitsPass.h index ea428b16c02..b7447a0547d 100644 --- a/llvm/include/llvm/Analysis/DOTGraphTraitsPass.h +++ b/llvm/include/llvm/Analysis/DOTGraphTraitsPass.h @@ -36,7 +36,7 @@ public: DOTGraphTraitsViewer(StringRef GraphName, char &ID) : FunctionPass(ID), Name(GraphName) {} - /// @brief Return true if this function should be processed. + /// Return true if this function should be processed. /// /// An implementation of this class my override this function to indicate that /// only certain functions should be viewed. @@ -78,7 +78,7 @@ public: DOTGraphTraitsPrinter(StringRef GraphName, char &ID) : FunctionPass(ID), Name(GraphName) {} - /// @brief Return true if this function should be processed. + /// Return true if this function should be processed. /// /// An implementation of this class my override this function to indicate that /// only certain functions should be printed. diff --git a/llvm/include/llvm/Analysis/Lint.h b/llvm/include/llvm/Analysis/Lint.h index 7c88b137ec3..db5919fd91c 100644 --- a/llvm/include/llvm/Analysis/Lint.h +++ b/llvm/include/llvm/Analysis/Lint.h @@ -26,12 +26,12 @@ class FunctionPass; class Module; class Function; -/// @brief Create a lint pass. +/// Create a lint pass. /// /// Check a module or function. FunctionPass *createLintPass(); -/// @brief Check a module. +/// Check a module. /// /// This should only be used for debugging, because it plays games with /// PassManagers and stuff. diff --git a/llvm/include/llvm/Analysis/RegionInfo.h b/llvm/include/llvm/Analysis/RegionInfo.h index 59ca53f2feb..27f6cc19792 100644 --- a/llvm/include/llvm/Analysis/RegionInfo.h +++ b/llvm/include/llvm/Analysis/RegionInfo.h @@ -103,7 +103,7 @@ struct RegionTraits<Function> { } }; -/// @brief Marker class to iterate over the elements of a Region in flat mode. +/// Marker class to iterate over the elements of a Region in flat mode. /// /// The class is used to either iterate in Flat mode or by not using it to not /// iterate in Flat mode. During a Flat mode iteration all Regions are entered @@ -113,7 +113,7 @@ struct RegionTraits<Function> { template <class GraphType> class FlatIt {}; -/// @brief A RegionNode represents a subregion or a BasicBlock that is part of a +/// A RegionNode represents a subregion or a BasicBlock that is part of a /// Region. template <class Tr> class RegionNodeBase { @@ -136,12 +136,12 @@ private: /// RegionNode. PointerIntPair<BlockT *, 1, bool> entry; - /// @brief The parent Region of this RegionNode. + /// The parent Region of this RegionNode. /// @see getParent() RegionT *parent; protected: - /// @brief Create a RegionNode. + /// Create a RegionNode. /// /// @param Parent The parent of this RegionNode. /// @param Entry The entry BasicBlock of the RegionNode. If this @@ -157,7 +157,7 @@ public: RegionNodeBase(const RegionNodeBase &) = delete; RegionNodeBase &operator=(const RegionNodeBase &) = delete; - /// @brief Get the parent Region of this RegionNode. + /// Get the parent Region of this RegionNode. /// /// The parent Region is the Region this RegionNode belongs to. If for /// example a BasicBlock is element of two Regions, there exist two @@ -167,7 +167,7 @@ public: /// @return Get the parent Region of this RegionNode. inline RegionT *getParent() const { return parent; } - /// @brief Get the entry BasicBlock of this RegionNode. + /// Get the entry BasicBlock of this RegionNode. /// /// If this RegionNode represents a BasicBlock this is just the BasicBlock /// itself, otherwise we return the entry BasicBlock of the Subregion @@ -175,7 +175,7 @@ public: /// @return The entry BasicBlock of this RegionNode. inline BlockT *getEntry() const { return entry.getPointer(); } - /// @brief Get the content of this RegionNode. + /// Get the content of this RegionNode. /// /// This can be either a BasicBlock or a subregion. Before calling getNodeAs() /// check the type of the content with the isSubRegion() function call. @@ -183,7 +183,7 @@ public: /// @return The content of this RegionNode. template <class T> inline T *getNodeAs() const; - /// @brief Is this RegionNode a subregion? + /// Is this RegionNode a subregion? /// /// @return True if it contains a subregion. False if it contains a /// BasicBlock. @@ -191,7 +191,7 @@ public: }; //===----------------------------------------------------------------------===// -/// @brief A single entry single exit Region. +/// A single entry single exit Region. /// /// A Region is a connected subgraph of a control flow graph that has exactly /// two connections to the remaining graph. It can be used to analyze or @@ -302,7 +302,7 @@ class RegionBase : public RegionNodeBase<Tr> { void verifyRegionNest() const; public: - /// @brief Create a new region. + /// Create a new region. /// /// @param Entry The entry basic block of the region. /// @param Exit The exit basic block of the region. @@ -319,25 +319,25 @@ public: /// Delete the Region and all its subregions. ~RegionBase(); - /// @brief Get the entry BasicBlock of the Region. + /// Get the entry BasicBlock of the Region. /// @return The entry BasicBlock of the region. BlockT *getEntry() const { return RegionNodeBase<Tr>::getEntry(); } - /// @brief Replace the entry basic block of the region with the new basic + /// Replace the entry basic block of the region with the new basic /// block. /// /// @param BB The new entry basic block of the region. void replaceEntry(BlockT *BB); - /// @brief Replace the exit basic block of the region with the new basic + /// Replace the exit basic block of the region with the new basic /// block. /// /// @param BB The new exit basic block of the region. void replaceExit(BlockT *BB); - /// @brief Recursively replace the entry basic block of the region. + /// Recursively replace the entry basic block of the region. /// /// This function replaces the entry basic block with a new basic block. It /// also updates all child regions that have the same entry basic block as @@ -346,7 +346,7 @@ public: /// @param NewEntry The new entry basic block. void replaceEntryRecursive(BlockT *NewEntry); - /// @brief Recursively replace the exit basic block of the region. + /// Recursively replace the exit basic block of the region. /// /// This function replaces the exit basic block with a new basic block. It /// also updates all child regions that have the same exit basic block as @@ -355,38 +355,38 @@ public: /// @param NewExit The new exit basic block. void replaceExitRecursive(BlockT *NewExit); - /// @brief Get the exit BasicBlock of the Region. + /// Get the exit BasicBlock of the Region. /// @return The exit BasicBlock of the Region, NULL if this is the TopLevel /// Region. BlockT *getExit() const { return exit; } - /// @brief Get the parent of the Region. + /// Get the parent of the Region. /// @return The parent of the Region or NULL if this is a top level /// Region. RegionT *getParent() const { return RegionNodeBase<Tr>::getParent(); } - /// @brief Get the RegionNode representing the current Region. + /// Get the RegionNode representing the current Region. /// @return The RegionNode representing the current Region. RegionNodeT *getNode() const { return const_cast<RegionNodeT *>( reinterpret_cast<const RegionNodeT *>(this)); } - /// @brief Get the nesting level of this Region. + /// Get the nesting level of this Region. /// /// An toplevel Region has depth 0. /// /// @return The depth of the region. unsigned getDepth() const; - /// @brief Check if a Region is the TopLevel region. + /// Check if a Region is the TopLevel region. /// /// The toplevel region represents the whole function. bool isTopLevelRegion() const { return exit == nullptr; } - /// @brief Return a new (non-canonical) region, that is obtained by joining + /// Return a new (non-canonical) region, that is obtained by joining /// this region with its predecessors. /// /// @return A region also starting at getEntry(), but reaching to the next @@ -394,43 +394,43 @@ public: /// NULL if such a basic block does not exist. RegionT *getExpandedRegion() const; - /// @brief Return the first block of this region's single entry edge, + /// Return the first block of this region's single entry edge, /// if existing. /// /// @return The BasicBlock starting this region's single entry edge, /// else NULL. BlockT *getEnteringBlock() const; - /// @brief Return the first block of this region's single exit edge, + /// Return the first block of this region's single exit edge, /// if existing. /// /// @return The BasicBlock starting this region's single exit edge, /// else NULL. BlockT *getExitingBlock() const; - /// @brief Collect all blocks of this region's single exit edge, if existing. + /// Collect all blocks of this region's single exit edge, if existing. /// /// @return True if this region contains all the predecessors of the exit. bool getExitingBlocks(SmallVectorImpl<BlockT *> &Exitings) const; - /// @brief Is this a simple region? + /// Is this a simple region? /// /// A region is simple if it has exactly one exit and one entry edge. /// /// @return True if the Region is simple. bool isSimple() const; - /// @brief Returns the name of the Region. + /// Returns the name of the Region. /// @return The Name of the Region. std::string getNameStr() const; - /// @brief Return the RegionInfo object, that belongs to this Region. + /// Return the RegionInfo object, that belongs to this Region. RegionInfoT *getRegionInfo() const { return RI; } /// PrintStyle - Print region in difference ways. enum PrintStyle { PrintNone, PrintBB, PrintRN }; - /// @brief Print the region. + /// Print the region. /// /// @param OS The output stream the Region is printed to. /// @param printTree Print also the tree of subregions. @@ -439,17 +439,17 @@ public: PrintStyle Style = PrintNone) const; #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) - /// @brief Print the region to stderr. + /// Print the region to stderr. void dump() const; #endif - /// @brief Check if the region contains a BasicBlock. + /// Check if the region contains a BasicBlock. /// /// @param BB The BasicBlock that might be contained in this Region. /// @return True if the block is contained in the region otherwise false. bool contains(const BlockT *BB) const; - /// @brief Check if the region contains another region. + /// Check if the region contains another region. /// /// @param SubRegion The region that might be contained in this Region. /// @return True if SubRegion is contained in the region otherwise false. @@ -463,14 +463,14 @@ public: SubRegion->getExit() == getExit()); } - /// @brief Check if the region contains an Instruction. + /// Check if the region contains an Instruction. /// /// @param Inst The Instruction that might be contained in this region. /// @return True if the Instruction is contained in the region otherwise /// false. bool contains(const InstT *Inst) const { return contains(Inst->getParent()); } - /// @brief Check if the region contains a loop. + /// Check if the region contains a loop. /// /// @param L The loop that might be contained in this region. /// @return True if the loop is contained in the region otherwise false. @@ -479,7 +479,7 @@ public: /// In that case true is returned. bool contains(const LoopT *L) const; - /// @brief Get the outermost loop in the region that contains a loop. + /// Get the outermost loop in the region that contains a loop. /// /// Find for a Loop L the outermost loop OuterL that is a parent loop of L /// and is itself contained in the region. @@ -489,7 +489,7 @@ public: /// exist or if the region describes the whole function. LoopT *outermostLoopInRegion(LoopT *L) const; - /// @brief Get the outermost loop in the region that contains a basic block. + /// Get the outermost loop in the region that contains a basic block. /// /// Find for a basic block BB the outermost loop L that contains BB and is /// itself contained in the region. @@ -500,13 +500,13 @@ public: /// exist or if the region describes the whole function. LoopT *outermostLoopInRegion(LoopInfoT *LI, BlockT *BB) const; - /// @brief Get the subregion that starts at a BasicBlock + /// Get the subregion that starts at a BasicBlock /// /// @param BB The BasicBlock the subregion should start. /// @return The Subregion if available, otherwise NULL. RegionT *getSubRegionNode(BlockT *BB) const; - /// @brief Get the RegionNode for a BasicBlock + /// Get the RegionNode for a BasicBlock /// /// @param BB The BasicBlock at which the RegionNode should start. /// @return If available, the RegionNode that represents the subregion @@ -514,38 +514,38 @@ public: /// representing BB. RegionNodeT *getNode(BlockT *BB) const; - /// @brief Get the BasicBlock RegionNode for a BasicBlock + /// Get the BasicBlock RegionNode for a BasicBlock /// /// @param BB The BasicBlock for which the RegionNode is requested. /// @return The RegionNode representing the BB. RegionNodeT *getBBNode(BlockT *BB) const; - /// @brief Add a new subregion to this Region. + /// Add a new subregion to this Region. /// /// @param SubRegion The new subregion that will be added. /// @param moveChildren Move the children of this region, that are also /// contained in SubRegion into SubRegion. void addSubRegion(RegionT *SubRegion, bool moveChildren = false); - /// @brief Remove a subregion from this Region. + /// Remove a subregion from this Region. /// /// The subregion is not deleted, as it will probably be inserted into another /// region. /// @param SubRegion The SubRegion that will be removed. RegionT *removeSubRegion(RegionT *SubRegion); - /// @brief Move all direct child nodes of this Region to another Region. + /// Move all direct child nodes of this Region to another Region. /// /// @param To The Region the child nodes will be transferred to. void transferChildrenTo(RegionT *To); - /// @brief Verify if the region is a correct region. + /// Verify if the region is a correct region. /// /// Check if this is a correctly build Region. This is an expensive check, as /// the complete CFG of the Region will be walked. void verifyRegion() const; - /// @brief Clear the cache for BB RegionNodes. + /// Clear the cache for BB RegionNodes. /// /// After calling this function the BasicBlock RegionNodes will be stored at /// different memory locations. RegionNodes obtained before this function is @@ -621,12 +621,12 @@ public: using block_range = iterator_range<block_iterator>; using const_block_range = iterator_range<const_block_iterator>; - /// @brief Returns a range view of the basic blocks in the region. + /// Returns a range view of the basic blocks in the region. inline block_range blocks() { return block_range(block_begin(), block_end()); } - /// @brief Returns a range view of the basic blocks in the region. + /// Returns a range view of the basic blocks in the region. /// /// This is the 'const' version of the range view. inline const_block_range blocks() const { @@ -668,7 +668,7 @@ template <class Tr> inline raw_ostream &operator<<(raw_ostream &OS, const RegionNodeBase<Tr> &Node); //===----------------------------------------------------------------------===// -/// @brief Analysis that detects all canonical Regions. +/// Analysis that detects all canonical Regions. /// /// The RegionInfo pass detects all canonical regions in a function. The Regions /// are connected using the parent relation. This builds a Program Structure @@ -812,40 +812,40 @@ public: void releaseMemory(); - /// @brief Get the smallest region that contains a BasicBlock. + /// Get the smallest region that contains a BasicBlock. /// /// @param BB The basic block. /// @return The smallest region, that contains BB or NULL, if there is no /// region containing BB. RegionT *getRegionFor(BlockT *BB) const; - /// @brief Set the smallest region that surrounds a basic block. + /// Set the smallest region that surrounds a basic block. /// /// @param BB The basic block surrounded by a region. /// @param R The smallest region that surrounds BB. void setRegionFor(BlockT *BB, RegionT *R); - /// @brief A shortcut for getRegionFor(). + /// A shortcut for getRegionFor(). /// /// @param BB The basic block. /// @return The smallest region, that contains BB or NULL, if there is no /// region containing BB. RegionT *operator[](BlockT *BB) const; - /// @brief Return the exit of the maximal refined region, that starts at a + /// Return the exit of the maximal refined region, that starts at a /// BasicBlock. /// /// @param BB The BasicBlock the refined region starts. BlockT *getMaxRegionExit(BlockT *BB) const; - /// @brief Find the smallest region that contains two regions. + /// Find the smallest region that contains two regions. /// /// @param A The first region. /// @param B The second region. /// @return The smallest region containing A and B. RegionT *getCommonRegion(RegionT *A, RegionT *B) const; - /// @brief Find the smallest region that contains two basic blocks. + /// Find the smallest region that contains two basic blocks. /// /// @param A The first basic block. /// @param B The second basic block. @@ -854,13 +854,13 @@ public: return getCommonRegion(getRegionFor(A), getRegionFor(B)); } - /// @brief Find the smallest region that contains a set of regions. + /// Find the smallest region that contains a set of regions. /// /// @param Regions A vector of regions. /// @return The smallest region that contains all regions in Regions. RegionT *getCommonRegion(SmallVectorImpl<RegionT *> &Regions) const; - /// @brief Find the smallest region that contains a set of basic blocks. + /// Find the smallest region that contains a set of basic blocks. /// /// @param BBs A vector of basic blocks. /// @return The smallest region that contains all basic blocks in BBS. @@ -868,7 +868,7 @@ public: RegionT *getTopLevelRegion() const { return TopLevelRegion; } - /// @brief Clear the Node Cache for all Regions. + /// Clear the Node Cache for all Regions. /// /// @see Region::clearNodeCache() void clearNodeCache() { @@ -931,12 +931,12 @@ public: DominanceFrontier *DF); #ifndef NDEBUG - /// @brief Opens a viewer to show the GraphViz visualization of the regions. + /// Opens a viewer to show the GraphViz visualization of the regions. /// /// Useful during debugging as an alternative to dump(). void view(); - /// @brief Opens a viewer to show the GraphViz visualization of this region + /// Opens a viewer to show the GraphViz visualization of this region /// without instructions in the BasicBlocks. /// /// Useful during debugging as an alternative to dump(). diff --git a/llvm/include/llvm/Analysis/RegionIterator.h b/llvm/include/llvm/Analysis/RegionIterator.h index 4f823cc8221..4fd92fcde20 100644 --- a/llvm/include/llvm/Analysis/RegionIterator.h +++ b/llvm/include/llvm/Analysis/RegionIterator.h @@ -26,7 +26,7 @@ namespace llvm { class BasicBlock; //===----------------------------------------------------------------------===// -/// @brief Hierarchical RegionNode successor iterator. +/// Hierarchical RegionNode successor iterator. /// /// This iterator iterates over all successors of a RegionNode. /// @@ -102,7 +102,7 @@ public: using Self = RNSuccIterator<NodeRef, BlockT, RegionT>; using value_type = typename super::value_type; - /// @brief Create begin iterator of a RegionNode. + /// Create begin iterator of a RegionNode. inline RNSuccIterator(NodeRef node) : Node(node, node->isSubRegion() ? ItRgBegin : ItBB), BItor(BlockTraits::child_begin(node->getEntry())) { @@ -115,7 +115,7 @@ public: advanceRegionSucc(); } - /// @brief Create an end iterator. + /// Create an end iterator. inline RNSuccIterator(NodeRef node, bool) : Node(node, node->isSubRegion() ? ItRgEnd : ItBB), BItor(BlockTraits::child_end(node->getEntry())) {} @@ -158,7 +158,7 @@ public: }; //===----------------------------------------------------------------------===// -/// @brief Flat RegionNode iterator. +/// Flat RegionNode iterator. /// /// The Flat Region iterator will iterate over all BasicBlock RegionNodes that /// are contained in the Region and its subregions. This is close to a virtual @@ -177,7 +177,7 @@ public: using Self = RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>; using value_type = typename super::value_type; - /// @brief Create the iterator from a RegionNode. + /// Create the iterator from a RegionNode. /// /// Note that the incoming node must be a bb node, otherwise it will trigger /// an assertion when we try to get a BasicBlock. @@ -193,7 +193,7 @@ public: ++Itor; } - /// @brief Create an end iterator + /// Create an end iterator inline RNSuccIterator(NodeRef node, bool) : Node(node), Itor(BlockTraits::child_end(node->getEntry())) { assert(!Node->isSubRegion() && diff --git a/llvm/include/llvm/Analysis/RegionPass.h b/llvm/include/llvm/Analysis/RegionPass.h index 515b362e540..b3da91c89cb 100644 --- a/llvm/include/llvm/Analysis/RegionPass.h +++ b/llvm/include/llvm/Analysis/RegionPass.h @@ -28,7 +28,7 @@ class RGPassManager; class Function; //===----------------------------------------------------------------------===// -/// @brief A pass that runs on each Region in a function. +/// A pass that runs on each Region in a function. /// /// RegionPass is managed by RGPassManager. class RegionPass : public Pass { @@ -39,7 +39,7 @@ public: /// @name To be implemented by every RegionPass /// //@{ - /// @brief Run the pass on a specific Region + /// Run the pass on a specific Region /// /// Accessing regions not contained in the current region is not allowed. /// @@ -49,7 +49,7 @@ public: /// @return True if the pass modifies this Region. virtual bool runOnRegion(Region *R, RGPassManager &RGM) = 0; - /// @brief Get a pass to print the LLVM IR in the region. + /// Get a pass to print the LLVM IR in the region. /// /// @param O The output stream to print the Region. /// @param Banner The banner to separate different printed passes. @@ -85,7 +85,7 @@ protected: bool skipRegion(Region &R) const; }; -/// @brief The pass manager to schedule RegionPasses. +/// The pass manager to schedule RegionPasses. class RGPassManager : public FunctionPass, public PMDataManager { std::deque<Region*> RQ; bool skipThisRegion; @@ -97,7 +97,7 @@ public: static char ID; explicit RGPassManager(); - /// @brief Execute all of the passes scheduled for execution. + /// Execute all of the passes scheduled for execution. /// /// @return True if any of the passes modifies the function. bool runOnFunction(Function &F) override; @@ -111,10 +111,10 @@ public: PMDataManager *getAsPMDataManager() override { return this; } Pass *getAsPass() override { return this; } - /// @brief Print passes managed by this manager. + /// Print passes managed by this manager. void dumpPassStructure(unsigned Offset) override; - /// @brief Get passes contained by this manager. + /// Get passes contained by this manager. Pass *getContainedPass(unsigned N) { assert(N < PassVector.size() && "Pass number out of range!"); Pass *FP = static_cast<Pass *>(PassVector[N]); diff --git a/llvm/include/llvm/Analysis/RegionPrinter.h b/llvm/include/llvm/Analysis/RegionPrinter.h index 8f0035cfd8e..e132eaea567 100644 --- a/llvm/include/llvm/Analysis/RegionPrinter.h +++ b/llvm/include/llvm/Analysis/RegionPrinter.h @@ -26,7 +26,7 @@ namespace llvm { FunctionPass *createRegionOnlyPrinterPass(); #ifndef NDEBUG - /// @brief Open a viewer to display the GraphViz vizualization of the analysis + /// Open a viewer to display the GraphViz vizualization of the analysis /// result. /// /// Practical to call in the debugger. @@ -35,7 +35,7 @@ namespace llvm { /// @param RI The analysis to display. void viewRegion(llvm::RegionInfo *RI); - /// @brief Analyze the regions of a function and open its GraphViz + /// Analyze the regions of a function and open its GraphViz /// visualization in a viewer. /// /// Useful to call in the debugger. @@ -46,7 +46,7 @@ namespace llvm { /// @param F Function to analyze. void viewRegion(const llvm::Function *F); - /// @brief Open a viewer to display the GraphViz vizualization of the analysis + /// Open a viewer to display the GraphViz vizualization of the analysis /// result. /// /// Useful to call in the debugger. @@ -55,7 +55,7 @@ namespace llvm { /// @param RI The analysis to display. void viewRegionOnly(llvm::RegionInfo *RI); - /// @brief Analyze the regions of a function and open its GraphViz + /// Analyze the regions of a function and open its GraphViz /// visualization in a viewer. /// /// Useful to call in the debugger. diff --git a/llvm/include/llvm/BinaryFormat/COFF.h b/llvm/include/llvm/BinaryFormat/COFF.h index 4d726aa5ce9..7b973c03cc8 100644 --- a/llvm/include/llvm/BinaryFormat/COFF.h +++ b/llvm/include/llvm/BinaryFormat/COFF.h @@ -463,7 +463,7 @@ union Auxiliary { AuxiliarySectionDefinition SectionDefinition; }; -/// @brief The Import Directory Table. +/// The Import Directory Table. /// /// There is a single array of these and one entry per imported DLL. struct ImportDirectoryTableEntry { @@ -474,7 +474,7 @@ struct ImportDirectoryTableEntry { uint32_t ImportAddressTableRVA; }; -/// @brief The PE32 Import Lookup Table. +/// The PE32 Import Lookup Table. /// /// There is an array of these for each imported DLL. It represents either /// the ordinal to import from the target DLL, or a name to lookup and import @@ -485,32 +485,32 @@ struct ImportDirectoryTableEntry { struct ImportLookupTableEntry32 { uint32_t data; - /// @brief Is this entry specified by ordinal, or name? + /// Is this entry specified by ordinal, or name? bool isOrdinal() const { return data & 0x80000000; } - /// @brief Get the ordinal value of this entry. isOrdinal must be true. + /// Get the ordinal value of this entry. isOrdinal must be true. uint16_t getOrdinal() const { assert(isOrdinal() && "ILT entry is not an ordinal!"); return data & 0xFFFF; } - /// @brief Set the ordinal value and set isOrdinal to true. + /// Set the ordinal value and set isOrdinal to true. void setOrdinal(uint16_t o) { data = o; data |= 0x80000000; } - /// @brief Get the Hint/Name entry RVA. isOrdinal must be false. + /// Get the Hint/Name entry RVA. isOrdinal must be false. uint32_t getHintNameRVA() const { assert(!isOrdinal() && "ILT entry is not a Hint/Name RVA!"); return data; } - /// @brief Set the Hint/Name entry RVA and set isOrdinal to false. + /// Set the Hint/Name entry RVA and set isOrdinal to false. void setHintNameRVA(uint32_t rva) { data = rva; } }; -/// @brief The DOS compatible header at the front of all PEs. +/// The DOS compatible header at the front of all PEs. struct DOSHeader { uint16_t Magic; uint16_t UsedBytesInTheLastPage; diff --git a/llvm/include/llvm/BinaryFormat/Magic.h b/llvm/include/llvm/BinaryFormat/Magic.h index 4ac826e4c50..04801f810be 100644 --- a/llvm/include/llvm/BinaryFormat/Magic.h +++ b/llvm/include/llvm/BinaryFormat/Magic.h @@ -59,10 +59,10 @@ private: Impl V = unknown; }; -/// @brief Identify the type of a binary file based on how magical it is. +/// Identify the type of a binary file based on how magical it is. file_magic identify_magic(StringRef magic); -/// @brief Get and identify \a path's type based on its content. +/// Get and identify \a path's type based on its content. /// /// @param path Input path. /// @param result Set to the type of file, or file_magic::unknown. diff --git a/llvm/include/llvm/CodeGen/MachineConstantPool.h b/llvm/include/llvm/CodeGen/MachineConstantPool.h index 1705a0f7e59..b0b5420a884 100644 --- a/llvm/include/llvm/CodeGen/MachineConstantPool.h +++ b/llvm/include/llvm/CodeGen/MachineConstantPool.h @@ -63,7 +63,7 @@ inline raw_ostream &operator<<(raw_ostream &OS, /// This class is a data container for one entry in a MachineConstantPool. /// It contains a pointer to the value and an offset from the start of /// the constant pool. -/// @brief An entry in a MachineConstantPool +/// An entry in a MachineConstantPool class MachineConstantPoolEntry { public: /// The constant itself. @@ -117,7 +117,7 @@ public: /// the use of MO_ConstantPoolIndex values. When emitting assembly or machine /// code, these virtual address references are converted to refer to the /// address of the function constant pool values. -/// @brief The machine constant pool. +/// The machine constant pool. class MachineConstantPool { unsigned PoolAlignment; ///< The alignment for the pool. std::vector<MachineConstantPoolEntry> Constants; ///< The pool of constants. @@ -128,7 +128,7 @@ class MachineConstantPool { const DataLayout &getDataLayout() const { return DL; } public: - /// @brief The only constructor. + /// The only constructor. explicit MachineConstantPool(const DataLayout &DL) : PoolAlignment(1), DL(DL) {} ~MachineConstantPool(); diff --git a/llvm/include/llvm/CodeGen/MachineFrameInfo.h b/llvm/include/llvm/CodeGen/MachineFrameInfo.h index f887517217e..91b506c1524 100644 --- a/llvm/include/llvm/CodeGen/MachineFrameInfo.h +++ b/llvm/include/llvm/CodeGen/MachineFrameInfo.h @@ -85,7 +85,7 @@ public: /// stack offsets of the object, eliminating all MO_FrameIndex operands from /// the program. /// -/// @brief Abstract Stack Frame Information +/// Abstract Stack Frame Information class MachineFrameInfo { // Represent a single object allocated on the stack. diff --git a/llvm/include/llvm/CodeGen/PBQP/Graph.h b/llvm/include/llvm/CodeGen/PBQP/Graph.h index e94878ced10..a6d88b057dc 100644 --- a/llvm/include/llvm/CodeGen/PBQP/Graph.h +++ b/llvm/include/llvm/CodeGen/PBQP/Graph.h @@ -29,12 +29,12 @@ namespace PBQP { using NodeId = unsigned; using EdgeId = unsigned; - /// @brief Returns a value representing an invalid (non-existent) node. + /// Returns a value representing an invalid (non-existent) node. static NodeId invalidNodeId() { return std::numeric_limits<NodeId>::max(); } - /// @brief Returns a value representing an invalid (non-existent) edge. + /// Returns a value representing an invalid (non-existent) edge. static EdgeId invalidEdgeId() { return std::numeric_limits<EdgeId>::max(); } @@ -338,19 +338,19 @@ namespace PBQP { const NodeEntry &NE; }; - /// @brief Construct an empty PBQP graph. + /// Construct an empty PBQP graph. Graph() = default; - /// @brief Construct an empty PBQP graph with the given graph metadata. + /// Construct an empty PBQP graph with the given graph metadata. Graph(GraphMetadata Metadata) : Metadata(std::move(Metadata)) {} - /// @brief Get a reference to the graph metadata. + /// Get a reference to the graph metadata. GraphMetadata& getMetadata() { return Metadata; } - /// @brief Get a const-reference to the graph metadata. + /// Get a const-reference to the graph metadata. const GraphMetadata& getMetadata() const { return Metadata; } - /// @brief Lock this graph to the given solver instance in preparation + /// Lock this graph to the given solver instance in preparation /// for running the solver. This method will call solver.handleAddNode for /// each node in the graph, and handleAddEdge for each edge, to give the /// solver an opportunity to set up any requried metadata. @@ -363,13 +363,13 @@ namespace PBQP { Solver->handleAddEdge(EId); } - /// @brief Release from solver instance. + /// Release from solver instance. void unsetSolver() { assert(Solver && "Solver not set."); Solver = nullptr; } - /// @brief Add a node with the given costs. + /// Add a node with the given costs. /// @param Costs Cost vector for the new node. /// @return Node iterator for the added node. template <typename OtherVectorT> @@ -382,7 +382,7 @@ namespace PBQP { return NId; } - /// @brief Add a node bypassing the cost allocator. + /// Add a node bypassing the cost allocator. /// @param Costs Cost vector ptr for the new node (must be convertible to /// VectorPtr). /// @return Node iterator for the added node. @@ -401,7 +401,7 @@ namespace PBQP { return NId; } - /// @brief Add an edge between the given nodes with the given costs. + /// Add an edge between the given nodes with the given costs. /// @param N1Id First node. /// @param N2Id Second node. /// @param Costs Cost matrix for new edge. @@ -419,7 +419,7 @@ namespace PBQP { return EId; } - /// @brief Add an edge bypassing the cost allocator. + /// Add an edge bypassing the cost allocator. /// @param N1Id First node. /// @param N2Id Second node. /// @param Costs Cost matrix for new edge. @@ -444,7 +444,7 @@ namespace PBQP { return EId; } - /// @brief Returns true if the graph is empty. + /// Returns true if the graph is empty. bool empty() const { return NodeIdSet(*this).empty(); } NodeIdSet nodeIds() const { return NodeIdSet(*this); } @@ -452,15 +452,15 @@ namespace PBQP { AdjEdgeIdSet adjEdgeIds(NodeId NId) { return AdjEdgeIdSet(getNode(NId)); } - /// @brief Get the number of nodes in the graph. + /// Get the number of nodes in the graph. /// @return Number of nodes in the graph. unsigned getNumNodes() const { return NodeIdSet(*this).size(); } - /// @brief Get the number of edges in the graph. + /// Get the number of edges in the graph. /// @return Number of edges in the graph. unsigned getNumEdges() const { return EdgeIdSet(*this).size(); } - /// @brief Set a node's cost vector. + /// Set a node's cost vector. /// @param NId Node to update. /// @param Costs New costs to set. template <typename OtherVectorT> @@ -471,7 +471,7 @@ namespace PBQP { getNode(NId).Costs = AllocatedCosts; } - /// @brief Get a VectorPtr to a node's cost vector. Rarely useful - use + /// Get a VectorPtr to a node's cost vector. Rarely useful - use /// getNodeCosts where possible. /// @param NId Node id. /// @return VectorPtr to node cost vector. @@ -483,7 +483,7 @@ namespace PBQP { return getNode(NId).Costs; } - /// @brief Get a node's cost vector. + /// Get a node's cost vector. /// @param NId Node id. /// @return Node cost vector. const Vector& getNodeCosts(NodeId NId) const { @@ -502,7 +502,7 @@ namespace PBQP { return getNode(NId).getAdjEdgeIds().size(); } - /// @brief Update an edge's cost matrix. + /// Update an edge's cost matrix. /// @param EId Edge id. /// @param Costs New cost matrix. template <typename OtherMatrixT> @@ -513,7 +513,7 @@ namespace PBQP { getEdge(EId).Costs = AllocatedCosts; } - /// @brief Get a MatrixPtr to a node's cost matrix. Rarely useful - use + /// Get a MatrixPtr to a node's cost matrix. Rarely useful - use /// getEdgeCosts where possible. /// @param EId Edge id. /// @return MatrixPtr to edge cost matrix. @@ -525,7 +525,7 @@ namespace PBQP { return getEdge(EId).Costs; } - /// @brief Get an edge's cost matrix. + /// Get an edge's cost matrix. /// @param EId Edge id. /// @return Edge cost matrix. const Matrix& getEdgeCosts(EdgeId EId) const { @@ -540,21 +540,21 @@ namespace PBQP { return getEdge(EId).Metadata; } - /// @brief Get the first node connected to this edge. + /// Get the first node connected to this edge. /// @param EId Edge id. /// @return The first node connected to the given edge. NodeId getEdgeNode1Id(EdgeId EId) const { return getEdge(EId).getN1Id(); } - /// @brief Get the second node connected to this edge. + /// Get the second node connected to this edge. /// @param EId Edge id. /// @return The second node connected to the given edge. NodeId getEdgeNode2Id(EdgeId EId) const { return getEdge(EId).getN2Id(); } - /// @brief Get the "other" node connected to this edge. + /// Get the "other" node connected to this edge. /// @param EId Edge id. /// @param NId Node id for the "given" node. /// @return The iterator for the "other" node connected to this edge. @@ -566,7 +566,7 @@ namespace PBQP { return E.getN1Id(); } - /// @brief Get the edge connecting two nodes. + /// Get the edge connecting two nodes. /// @param N1Id First node id. /// @param N2Id Second node id. /// @return An id for edge (N1Id, N2Id) if such an edge exists, @@ -581,7 +581,7 @@ namespace PBQP { return invalidEdgeId(); } - /// @brief Remove a node from the graph. + /// Remove a node from the graph. /// @param NId Node id. void removeNode(NodeId NId) { if (Solver) @@ -598,7 +598,7 @@ namespace PBQP { FreeNodeIds.push_back(NId); } - /// @brief Disconnect an edge from the given node. + /// Disconnect an edge from the given node. /// /// Removes the given edge from the adjacency list of the given node. /// This operation leaves the edge in an 'asymmetric' state: It will no @@ -631,14 +631,14 @@ namespace PBQP { E.disconnectFrom(*this, NId); } - /// @brief Convenience method to disconnect all neighbours from the given + /// Convenience method to disconnect all neighbours from the given /// node. void disconnectAllNeighborsFromNode(NodeId NId) { for (auto AEId : adjEdgeIds(NId)) disconnectEdge(AEId, getEdgeOtherNodeId(AEId, NId)); } - /// @brief Re-attach an edge to its nodes. + /// Re-attach an edge to its nodes. /// /// Adds an edge that had been previously disconnected back into the /// adjacency set of the nodes that the edge connects. @@ -649,7 +649,7 @@ namespace PBQP { Solver->handleReconnectEdge(EId, NId); } - /// @brief Remove an edge from the graph. + /// Remove an edge from the graph. /// @param EId Edge id. void removeEdge(EdgeId EId) { if (Solver) @@ -660,7 +660,7 @@ namespace PBQP { Edges[EId].invalidate(); } - /// @brief Remove all nodes and edges from the graph. + /// Remove all nodes and edges from the graph. void clear() { Nodes.clear(); FreeNodeIds.clear(); diff --git a/llvm/include/llvm/CodeGen/PBQPRAConstraint.h b/llvm/include/llvm/CodeGen/PBQPRAConstraint.h index 269b7a7b3a3..995467dc56d 100644 --- a/llvm/include/llvm/CodeGen/PBQPRAConstraint.h +++ b/llvm/include/llvm/CodeGen/PBQPRAConstraint.h @@ -33,7 +33,7 @@ class PBQPRAGraph; using PBQPRAGraph = PBQP::RegAlloc::PBQPRAGraph; -/// @brief Abstract base for classes implementing PBQP register allocation +/// Abstract base for classes implementing PBQP register allocation /// constraints (e.g. Spill-costs, interference, coalescing). class PBQPRAConstraint { public: @@ -44,7 +44,7 @@ private: virtual void anchor(); }; -/// @brief PBQP register allocation constraint composer. +/// PBQP register allocation constraint composer. /// /// Constraints added to this list will be applied, in the order that they are /// added, to the PBQP graph. diff --git a/llvm/include/llvm/CodeGen/RegAllocPBQP.h b/llvm/include/llvm/CodeGen/RegAllocPBQP.h index 668d9cba27e..ba9763077d0 100644 --- a/llvm/include/llvm/CodeGen/RegAllocPBQP.h +++ b/llvm/include/llvm/CodeGen/RegAllocPBQP.h @@ -43,7 +43,7 @@ class raw_ostream; namespace PBQP { namespace RegAlloc { -/// @brief Spill option index. +/// Spill option index. inline unsigned getSpillOptionIdx() { return 0; } /// Metadata to speed allocatability test. @@ -505,14 +505,14 @@ private: public: PBQPRAGraph(GraphMetadata Metadata) : BaseT(std::move(Metadata)) {} - /// @brief Dump this graph to dbgs(). + /// Dump this graph to dbgs(). void dump() const; - /// @brief Dump this graph to an output stream. + /// Dump this graph to an output stream. /// @param OS Output stream to print on. void dump(raw_ostream &OS) const; - /// @brief Print a representation of this graph in DOT format. + /// Print a representation of this graph in DOT format. /// @param OS Output stream to print on. void printDot(raw_ostream &OS) const; }; @@ -527,7 +527,7 @@ inline Solution solve(PBQPRAGraph& G) { } // end namespace RegAlloc } // end namespace PBQP -/// @brief Create a PBQP register allocator instance. +/// Create a PBQP register allocator instance. FunctionPass * createPBQPRegisterAllocator(char *customPassID = nullptr); diff --git a/llvm/include/llvm/CodeGen/VirtRegMap.h b/llvm/include/llvm/CodeGen/VirtRegMap.h index 3b06f039311..f409814c4f4 100644 --- a/llvm/include/llvm/CodeGen/VirtRegMap.h +++ b/llvm/include/llvm/CodeGen/VirtRegMap.h @@ -90,24 +90,24 @@ class TargetInstrInfo; void grow(); - /// @brief returns true if the specified virtual register is + /// returns true if the specified virtual register is /// mapped to a physical register bool hasPhys(unsigned virtReg) const { return getPhys(virtReg) != NO_PHYS_REG; } - /// @brief returns the physical register mapped to the specified + /// returns the physical register mapped to the specified /// virtual register unsigned getPhys(unsigned virtReg) const { assert(TargetRegisterInfo::isVirtualRegister(virtReg)); return Virt2PhysMap[virtReg]; } - /// @brief creates a mapping for the specified virtual register to + /// creates a mapping for the specified virtual register to /// the specified physical register void assignVirt2Phys(unsigned virtReg, MCPhysReg physReg); - /// @brief clears the specified virtual register's, physical + /// clears the specified virtual register's, physical /// register mapping void clearVirt(unsigned virtReg) { assert(TargetRegisterInfo::isVirtualRegister(virtReg)); @@ -116,26 +116,26 @@ class TargetInstrInfo; Virt2PhysMap[virtReg] = NO_PHYS_REG; } - /// @brief clears all virtual to physical register mappings + /// clears all virtual to physical register mappings void clearAllVirt() { Virt2PhysMap.clear(); grow(); } - /// @brief returns true if VirtReg is assigned to its preferred physreg. + /// returns true if VirtReg is assigned to its preferred physreg. bool hasPreferredPhys(unsigned VirtReg); - /// @brief returns true if VirtReg has a known preferred register. + /// returns true if VirtReg has a known preferred register. /// This returns false if VirtReg has a preference that is a virtual /// register that hasn't been assigned yet. bool hasKnownPreference(unsigned VirtReg); - /// @brief records virtReg is a split live interval from SReg. + /// records virtReg is a split live interval from SReg. void setIsSplitFromReg(unsigned virtReg, unsigned SReg) { Virt2SplitMap[virtReg] = SReg; } - /// @brief returns the live interval virtReg is split from. + /// returns the live interval virtReg is split from. unsigned getPreSplitReg(unsigned virtReg) const { return Virt2SplitMap[virtReg]; } @@ -149,7 +149,7 @@ class TargetInstrInfo; return Orig ? Orig : VirtReg; } - /// @brief returns true if the specified virtual register is not + /// returns true if the specified virtual register is not /// mapped to a stack slot or rematerialized. bool isAssignedReg(unsigned virtReg) const { if (getStackSlot(virtReg) == NO_STACK_SLOT) @@ -159,18 +159,18 @@ class TargetInstrInfo; return (Virt2SplitMap[virtReg] && Virt2PhysMap[virtReg] != NO_PHYS_REG); } - /// @brief returns the stack slot mapped to the specified virtual + /// returns the stack slot mapped to the specified virtual /// register int getStackSlot(unsigned virtReg) const { assert(TargetRegisterInfo::isVirtualRegister(virtReg)); return Virt2StackSlotMap[virtReg]; } - /// @brief create a mapping for the specifed virtual register to + /// create a mapping for the specifed virtual register to /// the next available stack slot int assignVirt2StackSlot(unsigned virtReg); - /// @brief create a mapping for the specified virtual register to + /// create a mapping for the specified virtual register to /// the specified stack slot void assignVirt2StackSlot(unsigned virtReg, int frameIndex); diff --git a/llvm/include/llvm/ExecutionEngine/JITSymbol.h b/llvm/include/llvm/ExecutionEngine/JITSymbol.h index 211c2c5e41a..e2e7f72444a 100644 --- a/llvm/include/llvm/ExecutionEngine/JITSymbol.h +++ b/llvm/include/llvm/ExecutionEngine/JITSymbol.h @@ -36,10 +36,10 @@ class BasicSymbolRef; } // end namespace object -/// @brief Represents an address in the target process's address space. +/// Represents an address in the target process's address space. using JITTargetAddress = uint64_t; -/// @brief Flags for symbols in the JIT. +/// Flags for symbols in the JIT. class JITSymbolFlags { public: using UnderlyingType = uint8_t; @@ -60,65 +60,65 @@ public: return static_cast<FlagNames>(Orig.Flags & ~Lazy & ~Materializing); } - /// @brief Default-construct a JITSymbolFlags instance. + /// Default-construct a JITSymbolFlags instance. JITSymbolFlags() = default; - /// @brief Construct a JITSymbolFlags instance from the given flags. + /// Construct a JITSymbolFlags instance from the given flags. JITSymbolFlags(FlagNames Flags) : Flags(Flags) {} - /// @brief Construct a JITSymbolFlags instance from the given flags and target + /// Construct a JITSymbolFlags instance from the given flags and target /// flags. JITSymbolFlags(FlagNames Flags, TargetFlagsType TargetFlags) : Flags(Flags), TargetFlags(TargetFlags) {} - /// @brief Return true if there was an error retrieving this symbol. + /// Return true if there was an error retrieving this symbol. bool hasError() const { return (Flags & HasError) == HasError; } - /// @brief Returns true if this is a lazy symbol. + /// Returns true if this is a lazy symbol. /// This flag is used internally by the JIT APIs to track /// materialization states. bool isLazy() const { return Flags & Lazy; } - /// @brief Returns true if this symbol is in the process of being + /// Returns true if this symbol is in the process of being /// materialized. bool isMaterializing() const { return Flags & Materializing; } - /// @brief Returns true if this symbol is fully materialized. + /// Returns true if this symbol is fully materialized. /// (i.e. neither lazy, nor materializing). bool isMaterialized() const { return !(Flags & (Lazy | Materializing)); } - /// @brief Returns true if the Weak flag is set. + /// Returns true if the Weak flag is set. bool isWeak() const { return (Flags & Weak) == Weak; } - /// @brief Returns true if the Common flag is set. + /// Returns true if the Common flag is set. bool isCommon() const { return (Flags & Common) == Common; } - /// @brief Returns true if the symbol isn't weak or common. + /// Returns true if the symbol isn't weak or common. bool isStrong() const { return !isWeak() && !isCommon(); } - /// @brief Returns true if the Exported flag is set. + /// Returns true if the Exported flag is set. bool isExported() const { return (Flags & Exported) == Exported; } - /// @brief Implicitly convert to the underlying flags type. + /// Implicitly convert to the underlying flags type. operator UnderlyingType&() { return Flags; } - /// @brief Implicitly convert to the underlying flags type. + /// Implicitly convert to the underlying flags type. operator const UnderlyingType&() const { return Flags; } - /// @brief Return a reference to the target-specific flags. + /// Return a reference to the target-specific flags. TargetFlagsType& getTargetFlags() { return TargetFlags; } - /// @brief Return a reference to the target-specific flags. + /// Return a reference to the target-specific flags. const TargetFlagsType& getTargetFlags() const { return TargetFlags; } /// Construct a JITSymbolFlags value based on the flags of the given global @@ -134,7 +134,7 @@ private: TargetFlagsType TargetFlags = 0; }; -/// @brief ARM-specific JIT symbol flags. +/// ARM-specific JIT symbol flags. /// FIXME: This should be moved into a target-specific header. class ARMJITSymbolFlags { public: @@ -153,25 +153,25 @@ private: JITSymbolFlags::TargetFlagsType Flags = 0; }; -/// @brief Represents a symbol that has been evaluated to an address already. +/// Represents a symbol that has been evaluated to an address already. class JITEvaluatedSymbol { public: JITEvaluatedSymbol() = default; - /// @brief Create a 'null' symbol. + /// Create a 'null' symbol. JITEvaluatedSymbol(std::nullptr_t) {} - /// @brief Create a symbol for the given address and flags. + /// Create a symbol for the given address and flags. JITEvaluatedSymbol(JITTargetAddress Address, JITSymbolFlags Flags) : Address(Address), Flags(Flags) {} - /// @brief An evaluated symbol converts to 'true' if its address is non-zero. + /// An evaluated symbol converts to 'true' if its address is non-zero. explicit operator bool() const { return Address != 0; } - /// @brief Return the address of this symbol. + /// Return the address of this symbol. JITTargetAddress getAddress() const { return Address; } - /// @brief Return the flags for this symbol. + /// Return the flags for this symbol. JITSymbolFlags getFlags() const { return Flags; } private: @@ -179,30 +179,30 @@ private: JITSymbolFlags Flags; }; -/// @brief Represents a symbol in the JIT. +/// Represents a symbol in the JIT. class JITSymbol { public: using GetAddressFtor = std::function<Expected<JITTargetAddress>()>; - /// @brief Create a 'null' symbol, used to represent a "symbol not found" + /// Create a 'null' symbol, used to represent a "symbol not found" /// result from a successful (non-erroneous) lookup. JITSymbol(std::nullptr_t) : CachedAddr(0) {} - /// @brief Create a JITSymbol representing an error in the symbol lookup + /// Create a JITSymbol representing an error in the symbol lookup /// process (e.g. a network failure during a remote lookup). JITSymbol(Error Err) : Err(std::move(Err)), Flags(JITSymbolFlags::HasError) {} - /// @brief Create a symbol for a definition with a known address. + /// Create a symbol for a definition with a known address. JITSymbol(JITTargetAddress Addr, JITSymbolFlags Flags) : CachedAddr(Addr), Flags(Flags) {} - /// @brief Construct a JITSymbol from a JITEvaluatedSymbol. + /// Construct a JITSymbol from a JITEvaluatedSymbol. JITSymbol(JITEvaluatedSymbol Sym) : CachedAddr(Sym.getAddress()), Flags(Sym.getFlags()) {} - /// @brief Create a symbol for a definition that doesn't have a known address + /// Create a symbol for a definition that doesn't have a known address /// yet. /// @param GetAddress A functor to materialize a definition (fixing the /// address) on demand. @@ -242,19 +242,19 @@ public: CachedAddr.~JITTargetAddress(); } - /// @brief Returns true if the symbol exists, false otherwise. + /// Returns true if the symbol exists, false otherwise. explicit operator bool() const { return !Flags.hasError() && (CachedAddr || GetAddress); } - /// @brief Move the error field value out of this JITSymbol. + /// Move the error field value out of this JITSymbol. Error takeError() { if (Flags.hasError()) return std::move(Err); return Error::success(); } - /// @brief Get the address of the symbol in the target address space. Returns + /// Get the address of the symbol in the target address space. Returns /// '0' if the symbol does not exist. Expected<JITTargetAddress> getAddress() { assert(!Flags.hasError() && "getAddress called on error value"); @@ -280,7 +280,7 @@ private: JITSymbolFlags Flags; }; -/// @brief Symbol resolution interface. +/// Symbol resolution interface. /// /// Allows symbol flags and addresses to be looked up by name. /// Symbol queries are done in bulk (i.e. you request resolution of a set of @@ -294,14 +294,14 @@ public: virtual ~JITSymbolResolver() = default; - /// @brief Returns the fully resolved address and flags for each of the given + /// Returns the fully resolved address and flags for each of the given /// symbols. /// /// This method will return an error if any of the given symbols can not be /// resolved, or if the resolution process itself triggers an error. virtual Expected<LookupResult> lookup(const LookupSet &Symbols) = 0; - /// @brief Returns the symbol flags for each of the given symbols. + /// Returns the symbol flags for each of the given symbols. /// /// This method does NOT return an error if any of the given symbols is /// missing. Instead, that symbol will be left out of the result map. @@ -314,12 +314,12 @@ private: /// Legacy symbol resolution interface. class LegacyJITSymbolResolver : public JITSymbolResolver { public: - /// @brief Performs lookup by, for each symbol, first calling + /// Performs lookup by, for each symbol, first calling /// findSymbolInLogicalDylib and if that fails calling /// findSymbol. Expected<LookupResult> lookup(const LookupSet &Symbols) final; - /// @brief Performs flags lookup by calling findSymbolInLogicalDylib and + /// Performs flags lookup by calling findSymbolInLogicalDylib and /// returning the flags value for that symbol. Expected<LookupFlagsResult> lookupFlags(const LookupSet &Symbols) final; diff --git a/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h index a64a6dd86a2..1239f7e0c2e 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h @@ -57,7 +57,7 @@ class Value; namespace orc { -/// @brief Compile-on-demand layer. +/// Compile-on-demand layer. /// /// When a module is added to this layer a stub is created for each of its /// function definitions. The stubs and other global values are immediately @@ -196,10 +196,10 @@ private: public: - /// @brief Module partitioning functor. + /// Module partitioning functor. using PartitioningFtor = std::function<std::set<Function*>(Function&)>; - /// @brief Builder for IndirectStubsManagers. + /// Builder for IndirectStubsManagers. using IndirectStubsManagerBuilderT = std::function<std::unique_ptr<IndirectStubsMgrT>()>; @@ -209,7 +209,7 @@ public: using SymbolResolverSetter = std::function<void(VModuleKey K, std::shared_ptr<SymbolResolver> R)>; - /// @brief Construct a compile-on-demand layer instance. + /// Construct a compile-on-demand layer instance. CompileOnDemandLayer(ExecutionSession &ES, BaseLayerT &BaseLayer, SymbolResolverGetter GetSymbolResolver, SymbolResolverSetter SetSymbolResolver, @@ -230,7 +230,7 @@ public: consumeError(removeModule(LogicalDylibs.begin()->first)); } - /// @brief Add a module to the compile-on-demand layer. + /// Add a module to the compile-on-demand layer. Error addModule(VModuleKey K, std::unique_ptr<Module> M) { assert(!LogicalDylibs.count(K) && "VModuleKey K already in use"); @@ -242,12 +242,12 @@ public: return addLogicalModule(I->second, std::move(M)); } - /// @brief Add extra modules to an existing logical module. + /// Add extra modules to an existing logical module. Error addExtraModule(VModuleKey K, std::unique_ptr<Module> M) { return addLogicalModule(LogicalDylibs[K], std::move(M)); } - /// @brief Remove the module represented by the given key. + /// Remove the module represented by the given key. /// /// This will remove all modules in the layers below that were derived from /// the module represented by K. @@ -259,7 +259,7 @@ public: return Err; } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. /// @param Name The name of the symbol to search for. /// @param ExportedSymbolsOnly If true, search only for exported symbols. /// @return A handle for the given named symbol, if it exists. @@ -275,7 +275,7 @@ public: return BaseLayer.findSymbol(Name, ExportedSymbolsOnly); } - /// @brief Get the address of a symbol provided by this layer, or some layer + /// Get the address of a symbol provided by this layer, or some layer /// below this one. JITSymbol findSymbolIn(VModuleKey K, const std::string &Name, bool ExportedSymbolsOnly) { @@ -283,7 +283,7 @@ public: return LogicalDylibs[K].findSymbol(BaseLayer, Name, ExportedSymbolsOnly); } - /// @brief Update the stub for the given function to point at FnBodyAddr. + /// Update the stub for the given function to point at FnBodyAddr. /// This can be used to support re-optimization. /// @return true if the function exists and the stub is updated, false /// otherwise. diff --git a/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h index d4d9a324c6e..2e4486440ac 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h @@ -35,7 +35,7 @@ class Module; namespace orc { -/// @brief Simple compile functor: Takes a single IR module and returns an +/// Simple compile functor: Takes a single IR module and returns an /// ObjectFile. class SimpleCompiler { private: @@ -56,14 +56,14 @@ private: public: using CompileResult = std::unique_ptr<MemoryBuffer>; - /// @brief Construct a simple compile functor with the given target. + /// Construct a simple compile functor with the given target. SimpleCompiler(TargetMachine &TM, ObjectCache *ObjCache = nullptr) : TM(TM), ObjCache(ObjCache) {} - /// @brief Set an ObjectCache to query before compiling. + /// Set an ObjectCache to query before compiling. void setObjectCache(ObjectCache *NewCache) { ObjCache = NewCache; } - /// @brief Compile a Module to an ObjectFile. + /// Compile a Module to an ObjectFile. CompileResult operator()(Module &M) { CompileResult CachedObject = tryToLoadFromObjectCache(M); if (CachedObject) diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Core.h b/llvm/include/llvm/ExecutionEngine/Orc/Core.h index 67a45fa3c6b..518de3fc6f9 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Core.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Core.h @@ -33,27 +33,27 @@ class VSO; /// ExecutionSessions) for a module added to the JIT. using VModuleKey = uint64_t; -/// @brief A set of symbol names (represented by SymbolStringPtrs for +/// A set of symbol names (represented by SymbolStringPtrs for // efficiency). using SymbolNameSet = std::set<SymbolStringPtr>; -/// @brief Render a SymbolNameSet to an ostream. +/// Render a SymbolNameSet to an ostream. raw_ostream &operator<<(raw_ostream &OS, const SymbolNameSet &Symbols); -/// @brief A map from symbol names (as SymbolStringPtrs) to JITSymbols +/// A map from symbol names (as SymbolStringPtrs) to JITSymbols /// (address/flags pairs). using SymbolMap = std::map<SymbolStringPtr, JITEvaluatedSymbol>; -/// @brief Render a SymbolMap to an ostream. +/// Render a SymbolMap to an ostream. raw_ostream &operator<<(raw_ostream &OS, const SymbolMap &Symbols); -/// @brief A map from symbol names (as SymbolStringPtrs) to JITSymbolFlags. +/// A map from symbol names (as SymbolStringPtrs) to JITSymbolFlags. using SymbolFlagsMap = std::map<SymbolStringPtr, JITSymbolFlags>; -/// @brief Render a SymbolMap to an ostream. +/// Render a SymbolMap to an ostream. raw_ostream &operator<<(raw_ostream &OS, const SymbolFlagsMap &Symbols); -/// @brief A base class for materialization failures that allows the failing +/// A base class for materialization failures that allows the failing /// symbols to be obtained for logging. class FailedToMaterialize : public ErrorInfo<FailedToMaterialize> { public: @@ -61,7 +61,7 @@ public: virtual const SymbolNameSet &getSymbols() const = 0; }; -/// @brief Used to notify a VSO that the given set of symbols failed to resolve. +/// Used to notify a VSO that the given set of symbols failed to resolve. class FailedToResolve : public ErrorInfo<FailedToResolve, FailedToMaterialize> { public: static char ID; @@ -75,7 +75,7 @@ private: SymbolNameSet Symbols; }; -/// @brief Used to notify a VSO that the given set of symbols failed to +/// Used to notify a VSO that the given set of symbols failed to /// finalize. class FailedToFinalize : public ErrorInfo<FailedToFinalize, FailedToMaterialize> { @@ -91,25 +91,25 @@ private: SymbolNameSet Symbols; }; -/// @brief A symbol query that returns results via a callback when results are +/// A symbol query that returns results via a callback when results are /// ready. /// /// makes a callback when all symbols are available. class AsynchronousSymbolQuery { public: - /// @brief Callback to notify client that symbols have been resolved. + /// Callback to notify client that symbols have been resolved. using SymbolsResolvedCallback = std::function<void(Expected<SymbolMap>)>; - /// @brief Callback to notify client that symbols are ready for execution. + /// Callback to notify client that symbols are ready for execution. using SymbolsReadyCallback = std::function<void(Error)>; - /// @brief Create a query for the given symbols, notify-resolved and + /// Create a query for the given symbols, notify-resolved and /// notify-ready callbacks. AsynchronousSymbolQuery(const SymbolNameSet &Symbols, SymbolsResolvedCallback NotifySymbolsResolved, SymbolsReadyCallback NotifySymbolsReady); - /// @brief Notify client that the query failed. + /// Notify client that the query failed. /// /// If the notify-resolved callback has not been made yet, then it is called /// with the given error, and the notify-finalized callback is never made. @@ -120,13 +120,13 @@ public: /// It is illegal to call setFailed after both callbacks have been made. void notifyMaterializationFailed(Error Err); - /// @brief Set the resolved symbol information for the given symbol name. + /// Set the resolved symbol information for the given symbol name. /// /// If this symbol was the last one not resolved, this will trigger a call to /// the notify-finalized callback passing the completed sybol map. void resolve(SymbolStringPtr Name, JITEvaluatedSymbol Sym); - /// @brief Notify the query that a requested symbol is ready for execution. + /// Notify the query that a requested symbol is ready for execution. /// /// This decrements the query's internal count of not-yet-ready symbols. If /// this call to notifySymbolFinalized sets the counter to zero, it will call @@ -141,7 +141,7 @@ private: SymbolsReadyCallback NotifySymbolsReady; }; -/// @brief SymbolResolver is a composable interface for looking up symbol flags +/// SymbolResolver is a composable interface for looking up symbol flags /// and addresses using the AsynchronousSymbolQuery type. It will /// eventually replace the LegacyJITSymbolResolver interface as the /// stardard ORC symbol resolver type. @@ -149,12 +149,12 @@ class SymbolResolver { public: virtual ~SymbolResolver() = default; - /// @brief Returns the flags for each symbol in Symbols that can be found, + /// Returns the flags for each symbol in Symbols that can be found, /// along with the set of symbol that could not be found. virtual SymbolNameSet lookupFlags(SymbolFlagsMap &Flags, const SymbolNameSet &Symbols) = 0; - /// @brief For each symbol in Symbols that can be found, assigns that symbols + /// For each symbol in Symbols that can be found, assigns that symbols /// value in Query. Returns the set of symbols that could not be found. virtual SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query, SymbolNameSet Symbols) = 0; @@ -163,7 +163,7 @@ private: virtual void anchor(); }; -/// @brief Implements SymbolResolver with a pair of supplied function objects +/// Implements SymbolResolver with a pair of supplied function objects /// for convenience. See createSymbolResolver. template <typename LookupFlagsFn, typename LookupFn> class LambdaSymbolResolver final : public SymbolResolver { @@ -188,7 +188,7 @@ private: LookupFn Lookup; }; -/// @brief Creates a SymbolResolver implementation from the pair of supplied +/// Creates a SymbolResolver implementation from the pair of supplied /// function objects. template <typename LookupFlagsFn, typename LookupFn> std::unique_ptr<LambdaSymbolResolver< @@ -206,7 +206,7 @@ createSymbolResolver(LookupFlagsFn &&LookupFlags, LookupFn &&Lookup) { std::forward<LookupFlagsFn>(LookupFlags), std::forward<LookupFn>(Lookup)); } -/// @brief Tracks responsibility for materialization. +/// Tracks responsibility for materialization. /// /// An instance of this class is passed to MaterializationUnits when their /// materialize method is called. It allows MaterializationUnits to resolve and @@ -214,7 +214,7 @@ createSymbolResolver(LookupFlagsFn &&LookupFlags, LookupFn &&Lookup) { /// symbols of an error. class MaterializationResponsibility { public: - /// @brief Create a MaterializationResponsibility for the given VSO and + /// Create a MaterializationResponsibility for the given VSO and /// initial symbols. MaterializationResponsibility(VSO &V, SymbolFlagsMap SymbolFlags); @@ -222,29 +222,29 @@ public: MaterializationResponsibility & operator=(MaterializationResponsibility &&) = default; - /// @brief Destruct a MaterializationResponsibility instance. In debug mode + /// Destruct a MaterializationResponsibility instance. In debug mode /// this asserts that all symbols being tracked have been either /// finalized or notified of an error. ~MaterializationResponsibility(); - /// @brief Returns the target VSO that these symbols are being materialized + /// Returns the target VSO that these symbols are being materialized /// into. const VSO &getTargetVSO() const { return V; } - /// @brief Resolves the given symbols. Individual calls to this method may + /// Resolves the given symbols. Individual calls to this method may /// resolve a subset of the symbols, but all symbols must have been /// resolved prior to calling finalize. void resolve(const SymbolMap &Symbols); - /// @brief Finalizes all symbols tracked by this instance. + /// Finalizes all symbols tracked by this instance. void finalize(); - /// @brief Notify all unfinalized symbols that an error has occurred. + /// Notify all unfinalized symbols that an error has occurred. /// This method should be called if materialization of any symbol is /// abandoned. void notifyMaterializationFailed(); - /// @brief Transfers responsibility for the given symbols to a new + /// Transfers responsibility for the given symbols to a new /// MaterializationResponsibility class. This is useful if a /// MaterializationUnit wants to transfer responsibility for a subset /// of symbols to another MaterializationUnit or utility. @@ -255,7 +255,7 @@ private: SymbolFlagsMap SymbolFlags; }; -/// @brief A MaterializationUnit represents a set of symbol definitions that can +/// A MaterializationUnit represents a set of symbol definitions that can /// be materialized as a group, or individually discarded (when /// overriding definitions are encountered). /// @@ -267,15 +267,15 @@ class MaterializationUnit { public: virtual ~MaterializationUnit() {} - /// @brief Return the set of symbols that this source provides. + /// Return the set of symbols that this source provides. virtual SymbolFlagsMap getSymbols() = 0; - /// @brief Implementations of this method should materialize all symbols + /// Implementations of this method should materialize all symbols /// in the materialzation unit, except for those that have been /// previously discarded. virtual void materialize(MaterializationResponsibility R) = 0; - /// @brief Implementations of this method should discard the given symbol + /// Implementations of this method should discard the given symbol /// from the source (e.g. if the source is an LLVM IR Module and the /// symbol is a function, delete the function body or mark it available /// externally). @@ -285,7 +285,7 @@ private: virtual void anchor(); }; -/// @brief Represents a dynamic linkage unit in a JIT process. +/// Represents a dynamic linkage unit in a JIT process. /// /// VSO acts as a symbol table (symbol definitions can be set and the dylib /// queried to find symbol addresses) and as a key for tracking resources @@ -329,31 +329,31 @@ public: VSO(VSO &&) = delete; VSO &operator=(VSO &&) = delete; - /// @brief Compare new linkage with existing linkage. + /// Compare new linkage with existing linkage. static RelativeLinkageStrength compareLinkage(Optional<JITSymbolFlags> OldFlags, JITSymbolFlags NewFlags); - /// @brief Compare new linkage with an existing symbol's linkage. + /// Compare new linkage with an existing symbol's linkage. RelativeLinkageStrength compareLinkage(SymbolStringPtr Name, JITSymbolFlags NewFlags) const; - /// @brief Adds the given symbols to the mapping as resolved, finalized + /// Adds the given symbols to the mapping as resolved, finalized /// symbols. /// /// FIXME: We can take this by const-ref once symbol-based laziness is /// removed. Error define(SymbolMap NewSymbols); - /// @brief Adds the given symbols to the mapping as lazy symbols. + /// Adds the given symbols to the mapping as lazy symbols. Error defineLazy(std::unique_ptr<MaterializationUnit> Source); - /// @brief Look up the flags for the given symbols. + /// Look up the flags for the given symbols. /// /// Returns the flags for the give symbols, together with the set of symbols /// not found. SymbolNameSet lookupFlags(SymbolFlagsMap &Flags, SymbolNameSet Symbols); - /// @brief Apply the given query to the given symbols in this VSO. + /// Apply the given query to the given symbols in this VSO. /// /// For symbols in this VSO that have already been materialized, their address /// will be set in the query immediately. @@ -369,14 +369,14 @@ public: SymbolNameSet Symbols); private: - /// @brief Add the given symbol/address mappings to the dylib, but do not + /// Add the given symbol/address mappings to the dylib, but do not /// mark the symbols as finalized yet. void resolve(const SymbolMap &SymbolValues); - /// @brief Finalize the given symbols. + /// Finalize the given symbols. void finalize(const SymbolNameSet &SymbolsToFinalize); - /// @brief Notify the VSO that the given symbols failed to materialized. + /// Notify the VSO that the given symbols failed to materialized. void notifyMaterializationFailed(const SymbolNameSet &Names); class UnmaterializedInfo { @@ -451,34 +451,34 @@ private: MaterializingInfoMap MaterializingInfos; }; -/// @brief An ExecutionSession represents a running JIT program. +/// An ExecutionSession represents a running JIT program. class ExecutionSession { public: using ErrorReporter = std::function<void(Error)>; - /// @brief Construct an ExecutionEngine. + /// Construct an ExecutionEngine. /// /// SymbolStringPools may be shared between ExecutionSessions. ExecutionSession(std::shared_ptr<SymbolStringPool> SSP = nullptr) : SSP(SSP ? std::move(SSP) : std::make_shared<SymbolStringPool>()) {} - /// @brief Returns the SymbolStringPool for this ExecutionSession. + /// Returns the SymbolStringPool for this ExecutionSession. SymbolStringPool &getSymbolStringPool() const { return *SSP; } - /// @brief Set the error reporter function. + /// Set the error reporter function. void setErrorReporter(ErrorReporter ReportError) { this->ReportError = std::move(ReportError); } - /// @brief Report a error for this execution session. + /// Report a error for this execution session. /// /// Unhandled errors can be sent here to log them. void reportError(Error Err) { ReportError(std::move(Err)); } - /// @brief Allocate a module key for a new module to add to the JIT. + /// Allocate a module key for a new module to add to the JIT. VModuleKey allocateVModule() { return ++LastKey; } - /// @brief Return a module key to the ExecutionSession so that it can be + /// Return a module key to the ExecutionSession so that it can be /// re-used. This should only be done once all resources associated //// with the original key have been released. void releaseVModule(VModuleKey Key) { /* FIXME: Recycle keys */ } @@ -501,13 +501,13 @@ public: /// Materialization function object wrapper for the lookup method. using MaterializationDispatcher = std::function<void(VSO::Materializer M)>; -/// @brief Look up a set of symbols by searching a list of VSOs. +/// Look up a set of symbols by searching a list of VSOs. /// /// All VSOs in the list should be non-null. Expected<SymbolMap> lookup(const std::vector<VSO *> &VSOs, SymbolNameSet Names, MaterializationDispatcher DispatchMaterialization); -/// @brief Look up a symbol by searching a list of VSOs. +/// Look up a symbol by searching a list of VSOs. Expected<JITEvaluatedSymbol> lookup(const std::vector<VSO *> VSOs, SymbolStringPtr Name, MaterializationDispatcher DispatchMaterialization); diff --git a/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h index d466df8b0d5..0268177f38d 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h @@ -36,14 +36,14 @@ class Value; namespace orc { -/// @brief This iterator provides a convenient way to iterate over the elements +/// This iterator provides a convenient way to iterate over the elements /// of an llvm.global_ctors/llvm.global_dtors instance. /// /// The easiest way to get hold of instances of this class is to use the /// getConstructors/getDestructors functions. class CtorDtorIterator { public: - /// @brief Accessor for an element of the global_ctors/global_dtors array. + /// Accessor for an element of the global_ctors/global_dtors array. /// /// This class provides a read-only view of the element with any casts on /// the function stripped away. @@ -56,23 +56,23 @@ public: Value *Data; }; - /// @brief Construct an iterator instance. If End is true then this iterator + /// Construct an iterator instance. If End is true then this iterator /// acts as the end of the range, otherwise it is the beginning. CtorDtorIterator(const GlobalVariable *GV, bool End); - /// @brief Test iterators for equality. + /// Test iterators for equality. bool operator==(const CtorDtorIterator &Other) const; - /// @brief Test iterators for inequality. + /// Test iterators for inequality. bool operator!=(const CtorDtorIterator &Other) const; - /// @brief Pre-increment iterator. + /// Pre-increment iterator. CtorDtorIterator& operator++(); - /// @brief Post-increment iterator. + /// Post-increment iterator. CtorDtorIterator operator++(int); - /// @brief Dereference iterator. The resulting value provides a read-only view + /// Dereference iterator. The resulting value provides a read-only view /// of this element of the global_ctors/global_dtors list. Element operator*() const; @@ -81,25 +81,25 @@ private: unsigned I; }; -/// @brief Create an iterator range over the entries of the llvm.global_ctors +/// Create an iterator range over the entries of the llvm.global_ctors /// array. iterator_range<CtorDtorIterator> getConstructors(const Module &M); -/// @brief Create an iterator range over the entries of the llvm.global_ctors +/// Create an iterator range over the entries of the llvm.global_ctors /// array. iterator_range<CtorDtorIterator> getDestructors(const Module &M); -/// @brief Convenience class for recording constructor/destructor names for +/// Convenience class for recording constructor/destructor names for /// later execution. template <typename JITLayerT> class CtorDtorRunner { public: - /// @brief Construct a CtorDtorRunner for the given range using the given + /// Construct a CtorDtorRunner for the given range using the given /// name mangling function. CtorDtorRunner(std::vector<std::string> CtorDtorNames, VModuleKey K) : CtorDtorNames(std::move(CtorDtorNames)), K(K) {} - /// @brief Run the recorded constructors/destructors through the given JIT + /// Run the recorded constructors/destructors through the given JIT /// layer. Error runViaLayer(JITLayerT &JITLayer) const { using CtorDtorTy = void (*)(); @@ -127,7 +127,7 @@ private: orc::VModuleKey K; }; -/// @brief Support class for static dtor execution. For hosted (in-process) JITs +/// Support class for static dtor execution. For hosted (in-process) JITs /// only! /// /// If a __cxa_atexit function isn't found C++ programs that use static diff --git a/llvm/include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h index 8a48c36f414..a8a88d7cb2d 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h @@ -27,7 +27,7 @@ class JITSymbolResolver; namespace orc { -/// @brief Global mapping layer. +/// Global mapping layer. /// /// This layer overrides the findSymbol method to first search a local symbol /// table that the client can define. It can be used to inject new symbol @@ -38,13 +38,13 @@ template <typename BaseLayerT> class GlobalMappingLayer { public: - /// @brief Handle to an added module. + /// Handle to an added module. using ModuleHandleT = typename BaseLayerT::ModuleHandleT; - /// @brief Construct an GlobalMappingLayer with the given BaseLayer + /// Construct an GlobalMappingLayer with the given BaseLayer GlobalMappingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {} - /// @brief Add the given module to the JIT. + /// Add the given module to the JIT. /// @return A handle for the added modules. Expected<ModuleHandleT> addModule(std::shared_ptr<Module> M, @@ -52,20 +52,20 @@ public: return BaseLayer.addModule(std::move(M), std::move(Resolver)); } - /// @brief Remove the module set associated with the handle H. + /// Remove the module set associated with the handle H. Error removeModule(ModuleHandleT H) { return BaseLayer.removeModule(H); } - /// @brief Manually set the address to return for the given symbol. + /// Manually set the address to return for the given symbol. void setGlobalMapping(const std::string &Name, JITTargetAddress Addr) { SymbolTable[Name] = Addr; } - /// @brief Remove the given symbol from the global mapping. + /// Remove the given symbol from the global mapping. void eraseGlobalMapping(const std::string &Name) { SymbolTable.erase(Name); } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. /// /// This method will first search the local symbol table, returning /// any symbol found there. If the symbol is not found in the local @@ -81,7 +81,7 @@ public: return BaseLayer.findSymbol(Name, ExportedSymbolsOnly); } - /// @brief Get the address of the given symbol in the context of the of the + /// Get the address of the given symbol in the context of the of the /// module represented by the handle H. This call is forwarded to the /// base layer's implementation. /// @param H The handle for the module to search in. @@ -94,7 +94,7 @@ public: return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly); } - /// @brief Immediately emit and finalize the module set represented by the + /// Immediately emit and finalize the module set represented by the /// given handle. /// @param H Handle for module set to emit/finalize. Error emitAndFinalize(ModuleHandleT H) { diff --git a/llvm/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h index a7f94164758..cbdc06fb375 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h @@ -27,7 +27,7 @@ class Module; namespace orc { -/// @brief Eager IR compiling layer. +/// Eager IR compiling layer. /// /// This layer immediately compiles each IR module added via addModule to an /// object file and adds this module file to the layer below, which must @@ -35,11 +35,11 @@ namespace orc { template <typename BaseLayerT, typename CompileFtor> class IRCompileLayer { public: - /// @brief Callback type for notifications when modules are compiled. + /// Callback type for notifications when modules are compiled. using NotifyCompiledCallback = std::function<void(VModuleKey K, std::unique_ptr<Module>)>; - /// @brief Construct an IRCompileLayer with the given BaseLayer, which must + /// Construct an IRCompileLayer with the given BaseLayer, which must /// implement the ObjectLayer concept. IRCompileLayer( BaseLayerT &BaseLayer, CompileFtor Compile, @@ -47,15 +47,15 @@ public: : BaseLayer(BaseLayer), Compile(std::move(Compile)), NotifyCompiled(std::move(NotifyCompiled)) {} - /// @brief Get a reference to the compiler functor. + /// Get a reference to the compiler functor. CompileFtor& getCompiler() { return Compile; } - /// @brief (Re)set the NotifyCompiled callback. + /// (Re)set the NotifyCompiled callback. void setNotifyCompiled(NotifyCompiledCallback NotifyCompiled) { this->NotifyCompiled = std::move(NotifyCompiled); } - /// @brief Compile the module, and add the resulting object to the base layer + /// Compile the module, and add the resulting object to the base layer /// along with the given memory manager and symbol resolver. Error addModule(VModuleKey K, std::unique_ptr<Module> M) { if (auto Err = BaseLayer.addObject(std::move(K), Compile(*M))) @@ -65,10 +65,10 @@ public: return Error::success(); } - /// @brief Remove the module associated with the VModuleKey K. + /// Remove the module associated with the VModuleKey K. Error removeModule(VModuleKey K) { return BaseLayer.removeObject(K); } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. /// @param Name The name of the symbol to search for. /// @param ExportedSymbolsOnly If true, search only for exported symbols. /// @return A handle for the given named symbol, if it exists. @@ -76,7 +76,7 @@ public: return BaseLayer.findSymbol(Name, ExportedSymbolsOnly); } - /// @brief Get the address of the given symbol in compiled module represented + /// Get the address of the given symbol in compiled module represented /// by the handle H. This call is forwarded to the base layer's /// implementation. /// @param K The VModuleKey for the module to search in. @@ -89,7 +89,7 @@ public: return BaseLayer.findSymbolIn(K, Name, ExportedSymbolsOnly); } - /// @brief Immediately emit and finalize the module represented by the given + /// Immediately emit and finalize the module represented by the given /// handle. /// @param K The VModuleKey for the module to emit/finalize. Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); } diff --git a/llvm/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h index 4f1fe7ba0f5..5539b415ec2 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h @@ -23,7 +23,7 @@ namespace llvm { class Module; namespace orc { -/// @brief IR mutating layer. +/// IR mutating layer. /// /// This layer applies a user supplied transform to each module that is added, /// then adds the transformed module to the layer below. @@ -31,12 +31,12 @@ template <typename BaseLayerT, typename TransformFtor> class IRTransformLayer { public: - /// @brief Construct an IRTransformLayer with the given BaseLayer + /// Construct an IRTransformLayer with the given BaseLayer IRTransformLayer(BaseLayerT &BaseLayer, TransformFtor Transform = TransformFtor()) : BaseLayer(BaseLayer), Transform(std::move(Transform)) {} - /// @brief Apply the transform functor to the module, then add the module to + /// Apply the transform functor to the module, then add the module to /// the layer below, along with the memory manager and symbol resolver. /// /// @return A handle for the added modules. @@ -44,10 +44,10 @@ public: return BaseLayer.addModule(std::move(K), Transform(std::move(M))); } - /// @brief Remove the module associated with the VModuleKey K. + /// Remove the module associated with the VModuleKey K. Error removeModule(VModuleKey K) { return BaseLayer.removeModule(K); } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. /// @param Name The name of the symbol to search for. /// @param ExportedSymbolsOnly If true, search only for exported symbols. /// @return A handle for the given named symbol, if it exists. @@ -55,7 +55,7 @@ public: return BaseLayer.findSymbol(Name, ExportedSymbolsOnly); } - /// @brief Get the address of the given symbol in the context of the module + /// Get the address of the given symbol in the context of the module /// represented by the VModuleKey K. This call is forwarded to the base /// layer's implementation. /// @param K The VModuleKey for the module to search in. @@ -68,15 +68,15 @@ public: return BaseLayer.findSymbolIn(K, Name, ExportedSymbolsOnly); } - /// @brief Immediately emit and finalize the module represented by the given + /// Immediately emit and finalize the module represented by the given /// VModuleKey. /// @param K The VModuleKey for the module to emit/finalize. Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); } - /// @brief Access the transform functor directly. + /// Access the transform functor directly. TransformFtor& getTransform() { return Transform; } - /// @brief Access the mumate functor directly. + /// Access the mumate functor directly. const TransformFtor& getTransform() const { return Transform; } private: diff --git a/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h index 029b86a6d2c..8b4ed9092ae 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h @@ -46,12 +46,12 @@ class Value; namespace orc { -/// @brief Target-independent base class for compile callback management. +/// Target-independent base class for compile callback management. class JITCompileCallbackManager { public: using CompileFtor = std::function<JITTargetAddress()>; - /// @brief Handle to a newly created compile callback. Can be used to get an + /// Handle to a newly created compile callback. Can be used to get an /// IR constant representing the address of the trampoline, and to set /// the compile action for the callback. class CompileCallbackInfo { @@ -69,7 +69,7 @@ public: CompileFtor &Compile; }; - /// @brief Construct a JITCompileCallbackManager. + /// Construct a JITCompileCallbackManager. /// @param ErrorHandlerAddress The address of an error handler in the target /// process to be used if a compile callback fails. JITCompileCallbackManager(JITTargetAddress ErrorHandlerAddress) @@ -77,7 +77,7 @@ public: virtual ~JITCompileCallbackManager() = default; - /// @brief Execute the callback for the given trampoline id. Called by the JIT + /// Execute the callback for the given trampoline id. Called by the JIT /// to compile functions on demand. JITTargetAddress executeCompileCallback(JITTargetAddress TrampolineAddr) { auto I = ActiveTrampolines.find(TrampolineAddr); @@ -104,7 +104,7 @@ public: return ErrorHandlerAddress; } - /// @brief Reserve a compile callback. + /// Reserve a compile callback. Expected<CompileCallbackInfo> getCompileCallback() { if (auto TrampolineAddrOrErr = getAvailableTrampolineAddr()) { const auto &TrampolineAddr = *TrampolineAddrOrErr; @@ -114,14 +114,14 @@ public: return TrampolineAddrOrErr.takeError(); } - /// @brief Get a CompileCallbackInfo for an existing callback. + /// Get a CompileCallbackInfo for an existing callback. CompileCallbackInfo getCompileCallbackInfo(JITTargetAddress TrampolineAddr) { auto I = ActiveTrampolines.find(TrampolineAddr); assert(I != ActiveTrampolines.end() && "Not an active trampoline."); return CompileCallbackInfo(I->first, I->second); } - /// @brief Release a compile callback. + /// Release a compile callback. /// /// Note: Callbacks are auto-released after they execute. This method should /// only be called to manually release a callback that is not going to @@ -158,11 +158,11 @@ private: virtual void anchor(); }; -/// @brief Manage compile callbacks for in-process JITs. +/// Manage compile callbacks for in-process JITs. template <typename TargetT> class LocalJITCompileCallbackManager : public JITCompileCallbackManager { public: - /// @brief Construct a InProcessJITCompileCallbackManager. + /// Construct a InProcessJITCompileCallbackManager. /// @param ErrorHandlerAddress The address of an error handler in the target /// process to be used if a compile callback fails. LocalJITCompileCallbackManager(JITTargetAddress ErrorHandlerAddress) @@ -229,38 +229,38 @@ private: std::vector<sys::OwningMemoryBlock> TrampolineBlocks; }; -/// @brief Base class for managing collections of named indirect stubs. +/// Base class for managing collections of named indirect stubs. class IndirectStubsManager { public: - /// @brief Map type for initializing the manager. See init. + /// Map type for initializing the manager. See init. using StubInitsMap = StringMap<std::pair<JITTargetAddress, JITSymbolFlags>>; virtual ~IndirectStubsManager() = default; - /// @brief Create a single stub with the given name, target address and flags. + /// Create a single stub with the given name, target address and flags. virtual Error createStub(StringRef StubName, JITTargetAddress StubAddr, JITSymbolFlags StubFlags) = 0; - /// @brief Create StubInits.size() stubs with the given names, target + /// Create StubInits.size() stubs with the given names, target /// addresses, and flags. virtual Error createStubs(const StubInitsMap &StubInits) = 0; - /// @brief Find the stub with the given name. If ExportedStubsOnly is true, + /// Find the stub with the given name. If ExportedStubsOnly is true, /// this will only return a result if the stub's flags indicate that it /// is exported. virtual JITSymbol findStub(StringRef Name, bool ExportedStubsOnly) = 0; - /// @brief Find the implementation-pointer for the stub. + /// Find the implementation-pointer for the stub. virtual JITSymbol findPointer(StringRef Name) = 0; - /// @brief Change the value of the implementation pointer for the stub. + /// Change the value of the implementation pointer for the stub. virtual Error updatePointer(StringRef Name, JITTargetAddress NewAddr) = 0; private: virtual void anchor(); }; -/// @brief IndirectStubsManager implementation for the host architecture, e.g. +/// IndirectStubsManager implementation for the host architecture, e.g. /// OrcX86_64. (See OrcArchitectureSupport.h). template <typename TargetT> class LocalIndirectStubsManager : public IndirectStubsManager { @@ -354,7 +354,7 @@ private: StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes; }; -/// @brief Create a local compile callback manager. +/// Create a local compile callback manager. /// /// The given target triple will determine the ABI, and the given /// ErrorHandlerAddress will be used by the resulting compile callback @@ -363,36 +363,36 @@ std::unique_ptr<JITCompileCallbackManager> createLocalCompileCallbackManager(const Triple &T, JITTargetAddress ErrorHandlerAddress); -/// @brief Create a local indriect stubs manager builder. +/// Create a local indriect stubs manager builder. /// /// The given target triple will determine the ABI. std::function<std::unique_ptr<IndirectStubsManager>()> createLocalIndirectStubsManagerBuilder(const Triple &T); -/// @brief Build a function pointer of FunctionType with the given constant +/// Build a function pointer of FunctionType with the given constant /// address. /// /// Usage example: Turn a trampoline address into a function pointer constant /// for use in a stub. Constant *createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr); -/// @brief Create a function pointer with the given type, name, and initializer +/// Create a function pointer with the given type, name, and initializer /// in the given Module. GlobalVariable *createImplPointer(PointerType &PT, Module &M, const Twine &Name, Constant *Initializer); -/// @brief Turn a function declaration into a stub function that makes an +/// Turn a function declaration into a stub function that makes an /// indirect call using the given function pointer. void makeStub(Function &F, Value &ImplPointer); -/// @brief Raise linkage types and rename as necessary to ensure that all +/// Raise linkage types and rename as necessary to ensure that all /// symbols are accessible for other modules. /// /// This should be called before partitioning a module to ensure that the /// partitions retain access to each other's symbols. void makeAllSymbolsExternallyAccessible(Module &M); -/// @brief Clone a function declaration into a new module. +/// Clone a function declaration into a new module. /// /// This function can be used as the first step towards creating a callback /// stub (see makeStub), or moving a function body (see moveFunctionBody). @@ -407,7 +407,7 @@ void makeAllSymbolsExternallyAccessible(Module &M); Function *cloneFunctionDecl(Module &Dst, const Function &F, ValueToValueMapTy *VMap = nullptr); -/// @brief Move the body of function 'F' to a cloned function declaration in a +/// Move the body of function 'F' to a cloned function declaration in a /// different module (See related cloneFunctionDecl). /// /// If the target function declaration is not supplied via the NewF parameter @@ -419,11 +419,11 @@ void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap, ValueMaterializer *Materializer = nullptr, Function *NewF = nullptr); -/// @brief Clone a global variable declaration into a new module. +/// Clone a global variable declaration into a new module. GlobalVariable *cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV, ValueToValueMapTy *VMap = nullptr); -/// @brief Move global variable GV from its parent module to cloned global +/// Move global variable GV from its parent module to cloned global /// declaration in a different module. /// /// If the target global declaration is not supplied via the NewGV parameter @@ -436,11 +436,11 @@ void moveGlobalVariableInitializer(GlobalVariable &OrigGV, ValueMaterializer *Materializer = nullptr, GlobalVariable *NewGV = nullptr); -/// @brief Clone a global alias declaration into a new module. +/// Clone a global alias declaration into a new module. GlobalAlias *cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA, ValueToValueMapTy &VMap); -/// @brief Clone module flags metadata into the destination module. +/// Clone module flags metadata into the destination module. void cloneModuleFlagsMetadata(Module &Dst, const Module &Src, ValueToValueMapTy &VMap); diff --git a/llvm/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h index 4117a9226ee..46761b0ca7e 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h @@ -33,7 +33,7 @@ namespace llvm { namespace orc { -/// @brief Lazy-emitting IR layer. +/// Lazy-emitting IR layer. /// /// This layer accepts LLVM IR Modules (via addModule), but does not /// immediately emit them the layer below. Instead, emissing to the base layer @@ -196,10 +196,10 @@ private: public: - /// @brief Construct a lazy emitting layer. + /// Construct a lazy emitting layer. LazyEmittingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {} - /// @brief Add the given module to the lazy emitting layer. + /// Add the given module to the lazy emitting layer. Error addModule(VModuleKey K, std::unique_ptr<Module> M) { assert(!ModuleMap.count(K) && "VModuleKey K already in use"); ModuleMap[K] = @@ -207,7 +207,7 @@ public: return Error::success(); } - /// @brief Remove the module represented by the given handle. + /// Remove the module represented by the given handle. /// /// This method will free the memory associated with the given module, both /// in this layer, and the base layer. @@ -219,7 +219,7 @@ public: return EDM->removeModuleFromBaseLayer(BaseLayer); } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. /// @param Name The name of the symbol to search for. /// @param ExportedSymbolsOnly If true, search only for exported symbols. /// @return A handle for the given named symbol, if it exists. @@ -239,7 +239,7 @@ public: return nullptr; } - /// @brief Get the address of the given symbol in the context of the of + /// Get the address of the given symbol in the context of the of /// compiled modules represented by the key K. JITSymbol findSymbolIn(VModuleKey K, const std::string &Name, bool ExportedSymbolsOnly) { @@ -247,7 +247,7 @@ public: return ModuleMap[K]->find(Name, ExportedSymbolsOnly, BaseLayer); } - /// @brief Immediately emit and finalize the module represented by the given + /// Immediately emit and finalize the module represented by the given /// key. Error emitAndFinalize(VModuleKey K) { assert(ModuleMap.count(K) && "VModuleKey K not valid here"); diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Legacy.h b/llvm/include/llvm/ExecutionEngine/Orc/Legacy.h index 8ea3f7b7662..4115f49a9cb 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Legacy.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Legacy.h @@ -32,7 +32,7 @@ private: SymbolResolver &R; }; -/// @brief Use the given legacy-style FindSymbol function (i.e. a function that +/// Use the given legacy-style FindSymbol function (i.e. a function that /// takes a const std::string& or StringRef and returns a JITSymbol) to /// find the flags for each symbol in Symbols and store their flags in /// SymbolFlags. If any JITSymbol returned by FindSymbol is in an error @@ -58,7 +58,7 @@ Expected<SymbolNameSet> lookupFlagsWithLegacyFn(SymbolFlagsMap &SymbolFlags, return SymbolsNotFound; } -/// @brief Use the given legacy-style FindSymbol function (i.e. a function that +/// Use the given legacy-style FindSymbol function (i.e. a function that /// takes a const std::string& or StringRef and returns a JITSymbol) to /// find the address and flags for each symbol in Symbols and store the /// result in Query. If any JITSymbol returned by FindSymbol is in an @@ -92,7 +92,7 @@ SymbolNameSet lookupWithLegacyFn(AsynchronousSymbolQuery &Query, return SymbolsNotFound; } -/// @brief An ORC SymbolResolver implementation that uses a legacy +/// An ORC SymbolResolver implementation that uses a legacy /// findSymbol-like function to perform lookup; template <typename LegacyLookupFn> class LegacyLookupFnResolver final : public SymbolResolver { diff --git a/llvm/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h index cfc3922ebb5..2829e32f2c8 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h @@ -23,7 +23,7 @@ namespace llvm { namespace orc { -/// @brief Object mutating layer. +/// Object mutating layer. /// /// This layer accepts sets of ObjectFiles (via addObject). It /// immediately applies the user supplied functor to each object, then adds @@ -31,12 +31,12 @@ namespace orc { template <typename BaseLayerT, typename TransformFtor> class ObjectTransformLayer { public: - /// @brief Construct an ObjectTransformLayer with the given BaseLayer + /// Construct an ObjectTransformLayer with the given BaseLayer ObjectTransformLayer(BaseLayerT &BaseLayer, TransformFtor Transform = TransformFtor()) : BaseLayer(BaseLayer), Transform(std::move(Transform)) {} - /// @brief Apply the transform functor to each object in the object set, then + /// Apply the transform functor to each object in the object set, then /// add the resulting set of objects to the base layer, along with the /// memory manager and symbol resolver. /// @@ -45,10 +45,10 @@ public: return BaseLayer.addObject(std::move(K), Transform(std::move(Obj))); } - /// @brief Remove the object set associated with the VModuleKey K. + /// Remove the object set associated with the VModuleKey K. Error removeObject(VModuleKey K) { return BaseLayer.removeObject(K); } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. /// @param Name The name of the symbol to search for. /// @param ExportedSymbolsOnly If true, search only for exported symbols. /// @return A handle for the given named symbol, if it exists. @@ -56,7 +56,7 @@ public: return BaseLayer.findSymbol(Name, ExportedSymbolsOnly); } - /// @brief Get the address of the given symbol in the context of the set of + /// Get the address of the given symbol in the context of the set of /// objects represented by the VModuleKey K. This call is forwarded to /// the base layer's implementation. /// @param K The VModuleKey associated with the object set to search in. @@ -69,21 +69,21 @@ public: return BaseLayer.findSymbolIn(K, Name, ExportedSymbolsOnly); } - /// @brief Immediately emit and finalize the object set represented by the + /// Immediately emit and finalize the object set represented by the /// given VModuleKey K. Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); } - /// @brief Map section addresses for the objects associated with the + /// Map section addresses for the objects associated with the /// VModuleKey K. void mapSectionAddress(VModuleKey K, const void *LocalAddress, JITTargetAddress TargetAddr) { BaseLayer.mapSectionAddress(K, LocalAddress, TargetAddr); } - /// @brief Access the transform functor directly. + /// Access the transform functor directly. TransformFtor &getTransform() { return Transform; } - /// @brief Access the mumate functor directly. + /// Access the mumate functor directly. const TransformFtor &getTransform() const { return Transform; } private: diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h index e1b55649b9f..581c598aff6 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h @@ -71,7 +71,7 @@ public: } }; -/// @brief Provide information about stub blocks generated by the +/// Provide information about stub blocks generated by the /// makeIndirectStubsBlock function. template <unsigned StubSizeVal> class GenericIndirectStubsInfo { public: @@ -92,16 +92,16 @@ public: return *this; } - /// @brief Number of stubs in this block. + /// Number of stubs in this block. unsigned getNumStubs() const { return NumStubs; } - /// @brief Get a pointer to the stub at the given index, which must be in + /// Get a pointer to the stub at the given index, which must be in /// the range 0 .. getNumStubs() - 1. void *getStub(unsigned Idx) const { return static_cast<char *>(StubsMem.base()) + Idx * StubSize; } - /// @brief Get a pointer to the implementation-pointer at the given index, + /// Get a pointer to the implementation-pointer at the given index, /// which must be in the range 0 .. getNumStubs() - 1. void **getPtr(unsigned Idx) const { char *PtrsBase = static_cast<char *>(StubsMem.base()) + NumStubs * StubSize; @@ -124,18 +124,18 @@ public: using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr, void *TrampolineId); - /// @brief Write the resolver code into the given memory. The user is be + /// Write the resolver code into the given memory. The user is be /// responsible for allocating the memory and setting permissions. static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry, void *CallbackMgr); - /// @brief Write the requsted number of trampolines into the given memory, + /// Write the requsted number of trampolines into the given memory, /// which must be big enough to hold 1 pointer, plus NumTrampolines /// trampolines. static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr, unsigned NumTrampolines); - /// @brief Emit at least MinStubs worth of indirect call stubs, rounded out to + /// Emit at least MinStubs worth of indirect call stubs, rounded out to /// the nearest page size. /// /// E.g. Asking for 4 stubs on x86-64, where stubs are 8-bytes, with 4k @@ -145,7 +145,7 @@ public: unsigned MinStubs, void *InitialPtrVal); }; -/// @brief X86_64 code that's common to all ABIs. +/// X86_64 code that's common to all ABIs. /// /// X86_64 supports lazy JITing. class OrcX86_64_Base { @@ -155,13 +155,13 @@ public: using IndirectStubsInfo = GenericIndirectStubsInfo<8>; - /// @brief Write the requsted number of trampolines into the given memory, + /// Write the requsted number of trampolines into the given memory, /// which must be big enough to hold 1 pointer, plus NumTrampolines /// trampolines. static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr, unsigned NumTrampolines); - /// @brief Emit at least MinStubs worth of indirect call stubs, rounded out to + /// Emit at least MinStubs worth of indirect call stubs, rounded out to /// the nearest page size. /// /// E.g. Asking for 4 stubs on x86-64, where stubs are 8-bytes, with 4k @@ -171,7 +171,7 @@ public: unsigned MinStubs, void *InitialPtrVal); }; -/// @brief X86_64 support for SysV ABI (Linux, MacOSX). +/// X86_64 support for SysV ABI (Linux, MacOSX). /// /// X86_64_SysV supports lazy JITing. class OrcX86_64_SysV : public OrcX86_64_Base { @@ -181,13 +181,13 @@ public: using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr, void *TrampolineId); - /// @brief Write the resolver code into the given memory. The user is be + /// Write the resolver code into the given memory. The user is be /// responsible for allocating the memory and setting permissions. static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry, void *CallbackMgr); }; -/// @brief X86_64 support for Win32. +/// X86_64 support for Win32. /// /// X86_64_Win32 supports lazy JITing. class OrcX86_64_Win32 : public OrcX86_64_Base { @@ -197,13 +197,13 @@ public: using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr, void *TrampolineId); - /// @brief Write the resolver code into the given memory. The user is be + /// Write the resolver code into the given memory. The user is be /// responsible for allocating the memory and setting permissions. static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry, void *CallbackMgr); }; -/// @brief I386 support. +/// I386 support. /// /// I386 supports lazy JITing. class OrcI386 { @@ -217,18 +217,18 @@ public: using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr, void *TrampolineId); - /// @brief Write the resolver code into the given memory. The user is be + /// Write the resolver code into the given memory. The user is be /// responsible for allocating the memory and setting permissions. static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry, void *CallbackMgr); - /// @brief Write the requsted number of trampolines into the given memory, + /// Write the requsted number of trampolines into the given memory, /// which must be big enough to hold 1 pointer, plus NumTrampolines /// trampolines. static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr, unsigned NumTrampolines); - /// @brief Emit at least MinStubs worth of indirect call stubs, rounded out to + /// Emit at least MinStubs worth of indirect call stubs, rounded out to /// the nearest page size. /// /// E.g. Asking for 4 stubs on i386, where stubs are 8-bytes, with 4k diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h index 038261caa22..47bd90bb1ba 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h @@ -1683,21 +1683,21 @@ private: uint32_t NumOutstandingCalls = 0; }; -/// @brief Convenience class for grouping RPC Functions into APIs that can be +/// Convenience class for grouping RPC Functions into APIs that can be /// negotiated as a block. /// template <typename... Funcs> class APICalls { public: - /// @brief Test whether this API contains Function F. + /// Test whether this API contains Function F. template <typename F> class Contains { public: static const bool value = false; }; - /// @brief Negotiate all functions in this API. + /// Negotiate all functions in this API. template <typename RPCEndpoint> static Error negotiate(RPCEndpoint &R) { return Error::success(); diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h index 8f0d9fa6eb6..59f2a07d31e 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h @@ -41,7 +41,7 @@ public: protected: - /// @brief Holds an object to be allocated/linked as a unit in the JIT. + /// Holds an object to be allocated/linked as a unit in the JIT. /// /// An instance of this class will be created for each object added /// via JITObjectLayer::addObject. Deleting the instance (via @@ -81,7 +81,7 @@ protected: }; }; -/// @brief Bare bones object linking layer. +/// Bare bones object linking layer. /// /// This class is intended to be used as the base layer for a JIT. It allows /// object files to be loaded into memory, linked, and the addresses of their @@ -92,12 +92,12 @@ public: using RTDyldObjectLinkingLayerBase::ObjectPtr; - /// @brief Functor for receiving object-loaded notifications. + /// Functor for receiving object-loaded notifications. using NotifyLoadedFtor = std::function<void(VModuleKey, const object::ObjectFile &Obj, const RuntimeDyld::LoadedObjectInfo &)>; - /// @brief Functor for receiving finalization notifications. + /// Functor for receiving finalization notifications. using NotifyFinalizedFtor = std::function<void(VModuleKey)>; private: @@ -235,7 +235,7 @@ public: using ResourcesGetter = std::function<Resources(VModuleKey)>; - /// @brief Construct an ObjectLinkingLayer with the given NotifyLoaded, + /// Construct an ObjectLinkingLayer with the given NotifyLoaded, /// and NotifyFinalized functors. RTDyldObjectLinkingLayer( ExecutionSession &ES, ResourcesGetter GetResources, @@ -246,7 +246,7 @@ public: NotifyFinalized(std::move(NotifyFinalized)), ProcessAllSections(false) { } - /// @brief Set the 'ProcessAllSections' flag. + /// Set the 'ProcessAllSections' flag. /// /// If set to true, all sections in each object file will be allocated using /// the memory manager, rather than just the sections required for execution. @@ -256,7 +256,7 @@ public: this->ProcessAllSections = ProcessAllSections; } - /// @brief Add an object to the JIT. + /// Add an object to the JIT. Error addObject(VModuleKey K, ObjectPtr ObjBuffer) { auto Obj = @@ -275,7 +275,7 @@ public: return Error::success(); } - /// @brief Remove the object associated with VModuleKey K. + /// Remove the object associated with VModuleKey K. /// /// All memory allocated for the object will be freed, and the sections and /// symbols it provided will no longer be available. No attempt is made to @@ -290,7 +290,7 @@ public: return Error::success(); } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. /// @param Name The name of the symbol to search for. /// @param ExportedSymbolsOnly If true, search only for exported symbols. /// @return A handle for the given named symbol, if it exists. @@ -304,7 +304,7 @@ public: return nullptr; } - /// @brief Search for the given named symbol in the context of the loaded + /// Search for the given named symbol in the context of the loaded /// object represented by the VModuleKey K. /// @param K The VModuleKey for the object to search in. /// @param Name The name of the symbol to search for. @@ -317,7 +317,7 @@ public: return LinkedObjects[K]->getSymbol(Name, ExportedSymbolsOnly); } - /// @brief Map section addresses for the object associated with the + /// Map section addresses for the object associated with the /// VModuleKey K. void mapSectionAddress(VModuleKey K, const void *LocalAddress, JITTargetAddress TargetAddr) { @@ -325,7 +325,7 @@ public: LinkedObjects[K]->mapSectionAddress(LocalAddress, TargetAddr); } - /// @brief Immediately emit and finalize the object represented by the given + /// Immediately emit and finalize the object represented by the given /// VModuleKey. /// @param K VModuleKey for object to emit/finalize. Error emitAndFinalize(VModuleKey K) { diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h b/llvm/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h index b95faaa5d8d..955e77607a1 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h @@ -322,7 +322,7 @@ public: *this, &ThisT::lookupInLogicalDylib); } - /// @brief Add an object to the JIT. + /// Add an object to the JIT. /// /// @return A handle that can be used to refer to the loaded object (for /// symbol searching, finalization, freeing memory, etc.). @@ -340,26 +340,26 @@ public: return HandleOrErr.takeError(); } - /// @brief Remove the given object from the JIT. + /// Remove the given object from the JIT. Error removeObject(ObjHandleT H) { return this->Remote.template callB<RemoveObject>(H); } - /// @brief Search for the given named symbol. + /// Search for the given named symbol. JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) { return remoteToJITSymbol( this->Remote.template callB<FindSymbol>(Name, ExportedSymbolsOnly)); } - /// @brief Search for the given named symbol within the given context. + /// Search for the given named symbol within the given context. JITSymbol findSymbolIn(ObjHandleT H, StringRef Name, bool ExportedSymbolsOnly) { return remoteToJITSymbol( this->Remote.template callB<FindSymbolIn>(H, Name, ExportedSymbolsOnly)); } - /// @brief Immediately emit and finalize the object with the given handle. + /// Immediately emit and finalize the object with the given handle. Error emitAndFinalize(ObjHandleT H) { return this->Remote.template callB<EmitAndFinalize>(H); } diff --git a/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h b/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h index de09c627a0b..4c45cfd199d 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h @@ -23,20 +23,20 @@ namespace orc { class SymbolStringPtr; -/// @brief String pool for symbol names used by the JIT. +/// String pool for symbol names used by the JIT. class SymbolStringPool { friend class SymbolStringPtr; public: - /// @brief Destroy a SymbolStringPool. + /// Destroy a SymbolStringPool. ~SymbolStringPool(); - /// @brief Create a symbol string pointer from the given string. + /// Create a symbol string pointer from the given string. SymbolStringPtr intern(StringRef S); - /// @brief Remove from the pool any entries that are no longer referenced. + /// Remove from the pool any entries that are no longer referenced. void clearDeadEntries(); - /// @brief Returns true if the pool is empty. + /// Returns true if the pool is empty. bool empty() const; private: using RefCountType = std::atomic<size_t>; @@ -46,7 +46,7 @@ private: PoolMap Pool; }; -/// @brief Pointer to a pooled string representing a symbol name. +/// Pointer to a pooled string representing a symbol name. class SymbolStringPtr { friend class SymbolStringPool; friend bool operator==(const SymbolStringPtr &LHS, diff --git a/llvm/include/llvm/IR/CallingConv.h b/llvm/include/llvm/IR/CallingConv.h index e509b9e96ab..b9c02d7ed42 100644 --- a/llvm/include/llvm/IR/CallingConv.h +++ b/llvm/include/llvm/IR/CallingConv.h @@ -26,7 +26,7 @@ namespace CallingConv { /// A set of enums which specify the assigned numeric values for known llvm /// calling conventions. - /// @brief LLVM Calling Convention Representation + /// LLVM Calling Convention Representation enum { /// C - The default llvm calling convention, compatible with C. This /// convention is the only calling convention that supports varargs calls. diff --git a/llvm/include/llvm/IR/Constant.h b/llvm/include/llvm/IR/Constant.h index 6048160d8e6..af5d5481e1f 100644 --- a/llvm/include/llvm/IR/Constant.h +++ b/llvm/include/llvm/IR/Constant.h @@ -38,7 +38,7 @@ class APInt; /// structurally equivalent constants will always have the same address. /// Constants are created on demand as needed and never deleted: thus clients /// don't have to worry about the lifetime of the objects. -/// @brief LLVM Constant Representation +/// LLVM Constant Representation class Constant : public User { protected: Constant(Type *ty, ValueTy vty, Use *Ops, unsigned NumOps) @@ -153,7 +153,7 @@ public: /// @returns the value for an integer or vector of integer constant of the /// given type that has all its bits set to true. - /// @brief Get the all ones value + /// Get the all ones value static Constant *getAllOnesValue(Type* Ty); /// Return the value for an integer or pointer constant, or a vector thereof, diff --git a/llvm/include/llvm/IR/ConstantRange.h b/llvm/include/llvm/IR/ConstantRange.h index 6889e265824..1adda3269ab 100644 --- a/llvm/include/llvm/IR/ConstantRange.h +++ b/llvm/include/llvm/IR/ConstantRange.h @@ -54,7 +54,7 @@ public: /// Initialize a range to hold the single specified value. ConstantRange(APInt Value); - /// @brief Initialize a range of values explicitly. This will assert out if + /// Initialize a range of values explicitly. This will assert out if /// Lower==Upper and Lower != Min or Max value for its type. It will also /// assert out if the two APInt's are not the same bit width. ConstantRange(APInt Lower, APInt Upper); diff --git a/llvm/include/llvm/IR/Constants.h b/llvm/include/llvm/IR/Constants.h index a4af1804138..d2e5f2acc24 100644 --- a/llvm/include/llvm/IR/Constants.h +++ b/llvm/include/llvm/IR/Constants.h @@ -80,7 +80,7 @@ public: //===----------------------------------------------------------------------===// /// This is the shared class of boolean and integer constants. This class /// represents both boolean and integral constants. -/// @brief Class for constant integers. +/// Class for constant integers. class ConstantInt final : public ConstantData { friend class Constant; @@ -107,7 +107,7 @@ public: /// to fit the type, unless isSigned is true, in which case the value will /// be interpreted as a 64-bit signed integer and sign-extended to fit /// the type. - /// @brief Get a ConstantInt for a specific value. + /// Get a ConstantInt for a specific value. static ConstantInt *get(IntegerType *Ty, uint64_t V, bool isSigned = false); @@ -115,7 +115,7 @@ public: /// value V will be canonicalized to a an unsigned APInt. Accessing it with /// either getSExtValue() or getZExtValue() will yield a correctly sized and /// signed value for the type Ty. - /// @brief Get a ConstantInt for a specific signed value. + /// Get a ConstantInt for a specific signed value. static ConstantInt *getSigned(IntegerType *Ty, int64_t V); static Constant *getSigned(Type *Ty, int64_t V); @@ -134,7 +134,7 @@ public: /// Return the constant as an APInt value reference. This allows clients to /// obtain a full-precision copy of the value. - /// @brief Return the constant's value. + /// Return the constant's value. inline const APInt &getValue() const { return Val; } @@ -145,7 +145,7 @@ public: /// Return the constant as a 64-bit unsigned integer value after it /// has been zero extended as appropriate for the type of this constant. Note /// that this method can assert if the value does not fit in 64 bits. - /// @brief Return the zero extended value. + /// Return the zero extended value. inline uint64_t getZExtValue() const { return Val.getZExtValue(); } @@ -153,7 +153,7 @@ public: /// Return the constant as a 64-bit integer value after it has been sign /// extended as appropriate for the type of this constant. Note that /// this method can assert if the value does not fit in 64 bits. - /// @brief Return the sign extended value. + /// Return the sign extended value. inline int64_t getSExtValue() const { return Val.getSExtValue(); } @@ -161,7 +161,7 @@ public: /// A helper method that can be used to determine if the constant contained /// within is equal to a constant. This only works for very small values, /// because this is all that can be represented with all types. - /// @brief Determine if this constant's value is same as an unsigned char. + /// Determine if this constant's value is same as an unsigned char. bool equalsInt(uint64_t V) const { return Val == V; } @@ -181,7 +181,7 @@ public: /// the signed version avoids callers having to convert a signed quantity /// to the appropriate unsigned type before calling the method. /// @returns true if V is a valid value for type Ty - /// @brief Determine if the value is in range for the given type. + /// Determine if the value is in range for the given type. static bool isValueValidForType(Type *Ty, uint64_t V); static bool isValueValidForType(Type *Ty, int64_t V); @@ -197,7 +197,7 @@ public: /// This is just a convenience method to make client code smaller for a /// common case. It also correctly performs the comparison without the /// potential for an assertion from getZExtValue(). - /// @brief Determine if the value is one. + /// Determine if the value is one. bool isOne() const { return Val.isOneValue(); } @@ -205,7 +205,7 @@ public: /// This function will return true iff every bit in this constant is set /// to true. /// @returns true iff this constant's bits are all set to true. - /// @brief Determine if the value is all ones. + /// Determine if the value is all ones. bool isMinusOne() const { return Val.isAllOnesValue(); } @@ -214,7 +214,7 @@ public: /// value that may be represented by the constant's type. /// @returns true iff this is the largest value that may be represented /// by this type. - /// @brief Determine if the value is maximal. + /// Determine if the value is maximal. bool isMaxValue(bool isSigned) const { if (isSigned) return Val.isMaxSignedValue(); @@ -226,7 +226,7 @@ public: /// value that may be represented by this constant's type. /// @returns true if this is the smallest value that may be represented by /// this type. - /// @brief Determine if the value is minimal. + /// Determine if the value is minimal. bool isMinValue(bool isSigned) const { if (isSigned) return Val.isMinSignedValue(); @@ -238,7 +238,7 @@ public: /// active bits bigger than 64 bits or a value greater than the given uint64_t /// value. /// @returns true iff this constant is greater or equal to the given number. - /// @brief Determine if the value is greater or equal to the given number. + /// Determine if the value is greater or equal to the given number. bool uge(uint64_t Num) const { return Val.uge(Num); } @@ -247,12 +247,12 @@ public: /// return it, otherwise return the limit value. This causes the value /// to saturate to the limit. /// @returns the min of the value of the constant and the specified value - /// @brief Get the constant's value with a saturation limit + /// Get the constant's value with a saturation limit uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const { return Val.getLimitedValue(Limit); } - /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. + /// Methods to support type inquiry through isa, cast, and dyn_cast. static bool classof(const Value *V) { return V->getValueID() == ConstantIntVal; } @@ -815,7 +815,7 @@ public: /// Return the ConstantTokenNone. static ConstantTokenNone *get(LLVMContext &Context); - /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. + /// Methods to support type inquiry through isa, cast, and dyn_cast. static bool classof(const Value *V) { return V->getValueID() == ConstantTokenNoneVal; } @@ -1031,62 +1031,62 @@ public: static Constant *getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced = false); - // @brief Create a ZExt or BitCast cast constant expression + // Create a ZExt or BitCast cast constant expression static Constant *getZExtOrBitCast( Constant *C, ///< The constant to zext or bitcast Type *Ty ///< The type to zext or bitcast C to ); - // @brief Create a SExt or BitCast cast constant expression + // Create a SExt or BitCast cast constant expression static Constant *getSExtOrBitCast( Constant *C, ///< The constant to sext or bitcast Type *Ty ///< The type to sext or bitcast C to ); - // @brief Create a Trunc or BitCast cast constant expression + // Create a Trunc or BitCast cast constant expression static Constant *getTruncOrBitCast( Constant *C, ///< The constant to trunc or bitcast Type *Ty ///< The type to trunc or bitcast C to ); - /// @brief Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant + /// Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant /// expression. static Constant *getPointerCast( Constant *C, ///< The pointer value to be casted (operand 0) Type *Ty ///< The type to which cast should be made ); - /// @brief Create a BitCast or AddrSpaceCast for a pointer type depending on + /// Create a BitCast or AddrSpaceCast for a pointer type depending on /// the address space. static Constant *getPointerBitCastOrAddrSpaceCast( Constant *C, ///< The constant to addrspacecast or bitcast Type *Ty ///< The type to bitcast or addrspacecast C to ); - /// @brief Create a ZExt, Bitcast or Trunc for integer -> integer casts + /// Create a ZExt, Bitcast or Trunc for integer -> integer casts static Constant *getIntegerCast( Constant *C, ///< The integer constant to be casted Type *Ty, ///< The integer type to cast to bool isSigned ///< Whether C should be treated as signed or not ); - /// @brief Create a FPExt, Bitcast or FPTrunc for fp -> fp casts + /// Create a FPExt, Bitcast or FPTrunc for fp -> fp casts static Constant *getFPCast( Constant *C, ///< The integer constant to be casted Type *Ty ///< The integer type to cast to ); - /// @brief Return true if this is a convert constant expression + /// Return true if this is a convert constant expression bool isCast() const; - /// @brief Return true if this is a compare constant expression + /// Return true if this is a compare constant expression bool isCompare() const; - /// @brief Return true if this is an insertvalue or extractvalue expression, + /// Return true if this is an insertvalue or extractvalue expression, /// and the getIndices() method may be used. bool hasIndices() const; - /// @brief Return true if this is a getelementptr expression and all + /// Return true if this is a getelementptr expression and all /// the index operands are compile-time known integers within the /// corresponding notional static array extents. Note that this is /// not equivalant to, a subset of, or a superset of the "inbounds" diff --git a/llvm/include/llvm/IR/DerivedTypes.h b/llvm/include/llvm/IR/DerivedTypes.h index 6e5e085873a..fc7d436423e 100644 --- a/llvm/include/llvm/IR/DerivedTypes.h +++ b/llvm/include/llvm/IR/DerivedTypes.h @@ -36,7 +36,7 @@ class LLVMContext; /// Class to represent integer types. Note that this class is also used to /// represent the built-in integer types: Int1Ty, Int8Ty, Int16Ty, Int32Ty and /// Int64Ty. -/// @brief Integer representation type +/// Integer representation type class IntegerType : public Type { friend class LLVMContextImpl; @@ -59,10 +59,10 @@ public: /// If an IntegerType with the same NumBits value was previously instantiated, /// that instance will be returned. Otherwise a new one will be created. Only /// one instance with a given NumBits value is ever created. - /// @brief Get or create an IntegerType instance. + /// Get or create an IntegerType instance. static IntegerType *get(LLVMContext &C, unsigned NumBits); - /// @brief Get the number of bits in this IntegerType + /// Get the number of bits in this IntegerType unsigned getBitWidth() const { return getSubclassData(); } /// Return a bitmask with ones set for all of the bits that can be set by an @@ -79,13 +79,13 @@ public: /// For example, this is 0xFF for an 8 bit integer, 0xFFFF for i16, etc. /// @returns a bit mask with ones set for all the bits of this type. - /// @brief Get a bit mask for this type. + /// Get a bit mask for this type. APInt getMask() const; /// This method determines if the width of this IntegerType is a power-of-2 /// in terms of 8 bit bytes. /// @returns true if this is a power-of-2 byte width. - /// @brief Is this a power-of-2 byte-width IntegerType ? + /// Is this a power-of-2 byte-width IntegerType ? bool isPowerOf2ByteWidth() const; /// Methods for support type inquiry through isa, cast, and dyn_cast. diff --git a/llvm/include/llvm/IR/Function.h b/llvm/include/llvm/IR/Function.h index 06309ce5364..3fa96df2c86 100644 --- a/llvm/include/llvm/IR/Function.h +++ b/llvm/include/llvm/IR/Function.h @@ -201,34 +201,34 @@ public: setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4)); } - /// @brief Return the attribute list for this Function. + /// Return the attribute list for this Function. AttributeList getAttributes() const { return AttributeSets; } - /// @brief Set the attribute list for this Function. + /// Set the attribute list for this Function. void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; } - /// @brief Add function attributes to this function. + /// Add function attributes to this function. void addFnAttr(Attribute::AttrKind Kind) { addAttribute(AttributeList::FunctionIndex, Kind); } - /// @brief Add function attributes to this function. + /// Add function attributes to this function. void addFnAttr(StringRef Kind, StringRef Val = StringRef()) { addAttribute(AttributeList::FunctionIndex, Attribute::get(getContext(), Kind, Val)); } - /// @brief Add function attributes to this function. + /// Add function attributes to this function. void addFnAttr(Attribute Attr) { addAttribute(AttributeList::FunctionIndex, Attr); } - /// @brief Remove function attributes from this function. + /// Remove function attributes from this function. void removeFnAttr(Attribute::AttrKind Kind) { removeAttribute(AttributeList::FunctionIndex, Kind); } - /// @brief Remove function attribute from this function. + /// Remove function attribute from this function. void removeFnAttr(StringRef Kind) { setAttributes(getAttributes().removeAttribute( getContext(), AttributeList::FunctionIndex, Kind)); @@ -298,22 +298,22 @@ public: /// Get the section prefix for this function. Optional<StringRef> getSectionPrefix() const; - /// @brief Return true if the function has the attribute. + /// Return true if the function has the attribute. bool hasFnAttribute(Attribute::AttrKind Kind) const { return AttributeSets.hasFnAttribute(Kind); } - /// @brief Return true if the function has the attribute. + /// Return true if the function has the attribute. bool hasFnAttribute(StringRef Kind) const { return AttributeSets.hasFnAttribute(Kind); } - /// @brief Return the attribute for the given attribute kind. + /// Return the attribute for the given attribute kind. Attribute getFnAttribute(Attribute::AttrKind Kind) const { return getAttribute(AttributeList::FunctionIndex, Kind); } - /// @brief Return the attribute for the given attribute kind. + /// Return the attribute for the given attribute kind. Attribute getFnAttribute(StringRef Kind) const { return getAttribute(AttributeList::FunctionIndex, Kind); } @@ -334,110 +334,110 @@ public: void setGC(std::string Str); void clearGC(); - /// @brief adds the attribute to the list of attributes. + /// adds the attribute to the list of attributes. void addAttribute(unsigned i, Attribute::AttrKind Kind); - /// @brief adds the attribute to the list of attributes. + /// adds the attribute to the list of attributes. void addAttribute(unsigned i, Attribute Attr); - /// @brief adds the attributes to the list of attributes. + /// adds the attributes to the list of attributes. void addAttributes(unsigned i, const AttrBuilder &Attrs); - /// @brief adds the attribute to the list of attributes for the given arg. + /// adds the attribute to the list of attributes for the given arg. void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind); - /// @brief adds the attribute to the list of attributes for the given arg. + /// adds the attribute to the list of attributes for the given arg. void addParamAttr(unsigned ArgNo, Attribute Attr); - /// @brief adds the attributes to the list of attributes for the given arg. + /// adds the attributes to the list of attributes for the given arg. void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs); - /// @brief removes the attribute from the list of attributes. + /// removes the attribute from the list of attributes. void removeAttribute(unsigned i, Attribute::AttrKind Kind); - /// @brief removes the attribute from the list of attributes. + /// removes the attribute from the list of attributes. void removeAttribute(unsigned i, StringRef Kind); - /// @brief removes the attributes from the list of attributes. + /// removes the attributes from the list of attributes. void removeAttributes(unsigned i, const AttrBuilder &Attrs); - /// @brief removes the attribute from the list of attributes. + /// removes the attribute from the list of attributes. void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind); - /// @brief removes the attribute from the list of attributes. + /// removes the attribute from the list of attributes. void removeParamAttr(unsigned ArgNo, StringRef Kind); - /// @brief removes the attribute from the list of attributes. + /// removes the attribute from the list of attributes. void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs); - /// @brief check if an attributes is in the list of attributes. + /// check if an attributes is in the list of attributes. bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const { return getAttributes().hasAttribute(i, Kind); } - /// @brief check if an attributes is in the list of attributes. + /// check if an attributes is in the list of attributes. bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const { return getAttributes().hasParamAttribute(ArgNo, Kind); } - /// @brief gets the attribute from the list of attributes. + /// gets the attribute from the list of attributes. Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const { return AttributeSets.getAttribute(i, Kind); } - /// @brief gets the attribute from the list of attributes. + /// gets the attribute from the list of attributes. Attribute getAttribute(unsigned i, StringRef Kind) const { return AttributeSets.getAttribute(i, Kind); } - /// @brief adds the dereferenceable attribute to the list of attributes. + /// adds the dereferenceable attribute to the list of attributes. void addDereferenceableAttr(unsigned i, uint64_t Bytes); - /// @brief adds the dereferenceable attribute to the list of attributes for + /// adds the dereferenceable attribute to the list of attributes for /// the given arg. void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes); - /// @brief adds the dereferenceable_or_null attribute to the list of + /// adds the dereferenceable_or_null attribute to the list of /// attributes. void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes); - /// @brief adds the dereferenceable_or_null attribute to the list of + /// adds the dereferenceable_or_null attribute to the list of /// attributes for the given arg. void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes); - /// @brief Extract the alignment for a call or parameter (0=unknown). + /// Extract the alignment for a call or parameter (0=unknown). unsigned getParamAlignment(unsigned ArgNo) const { return AttributeSets.getParamAlignment(ArgNo); } - /// @brief Extract the number of dereferenceable bytes for a call or + /// Extract the number of dereferenceable bytes for a call or /// parameter (0=unknown). /// @param i AttributeList index, referring to a return value or argument. uint64_t getDereferenceableBytes(unsigned i) const { return AttributeSets.getDereferenceableBytes(i); } - /// @brief Extract the number of dereferenceable bytes for a parameter. + /// Extract the number of dereferenceable bytes for a parameter. /// @param ArgNo Index of an argument, with 0 being the first function arg. uint64_t getParamDereferenceableBytes(unsigned ArgNo) const { return AttributeSets.getParamDereferenceableBytes(ArgNo); } - /// @brief Extract the number of dereferenceable_or_null bytes for a call or + /// Extract the number of dereferenceable_or_null bytes for a call or /// parameter (0=unknown). /// @param i AttributeList index, referring to a return value or argument. uint64_t getDereferenceableOrNullBytes(unsigned i) const { return AttributeSets.getDereferenceableOrNullBytes(i); } - /// @brief Extract the number of dereferenceable_or_null bytes for a + /// Extract the number of dereferenceable_or_null bytes for a /// parameter. /// @param ArgNo AttributeList ArgNo, referring to an argument. uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const { return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo); } - /// @brief Determine if the function does not access memory. + /// Determine if the function does not access memory. bool doesNotAccessMemory() const { return hasFnAttribute(Attribute::ReadNone); } @@ -445,7 +445,7 @@ public: addFnAttr(Attribute::ReadNone); } - /// @brief Determine if the function does not access or only reads memory. + /// Determine if the function does not access or only reads memory. bool onlyReadsMemory() const { return doesNotAccessMemory() || hasFnAttribute(Attribute::ReadOnly); } @@ -453,7 +453,7 @@ public: addFnAttr(Attribute::ReadOnly); } - /// @brief Determine if the function does not access or only writes memory. + /// Determine if the function does not access or only writes memory. bool doesNotReadMemory() const { return doesNotAccessMemory() || hasFnAttribute(Attribute::WriteOnly); } @@ -461,14 +461,14 @@ public: addFnAttr(Attribute::WriteOnly); } - /// @brief Determine if the call can access memmory only using pointers based + /// Determine if the call can access memmory only using pointers based /// on its arguments. bool onlyAccessesArgMemory() const { return hasFnAttribute(Attribute::ArgMemOnly); } void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); } - /// @brief Determine if the function may only access memory that is + /// Determine if the function may only access memory that is /// inaccessible from the IR. bool onlyAccessesInaccessibleMemory() const { return hasFnAttribute(Attribute::InaccessibleMemOnly); @@ -477,7 +477,7 @@ public: addFnAttr(Attribute::InaccessibleMemOnly); } - /// @brief Determine if the function may only access memory that is + /// Determine if the function may only access memory that is /// either inaccessible from the IR or pointed to by its arguments. bool onlyAccessesInaccessibleMemOrArgMem() const { return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly); @@ -486,7 +486,7 @@ public: addFnAttr(Attribute::InaccessibleMemOrArgMemOnly); } - /// @brief Determine if the function cannot return. + /// Determine if the function cannot return. bool doesNotReturn() const { return hasFnAttribute(Attribute::NoReturn); } @@ -497,7 +497,7 @@ public: /// Determine if the function should not perform indirect branch tracking. bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); } - /// @brief Determine if the function cannot unwind. + /// Determine if the function cannot unwind. bool doesNotThrow() const { return hasFnAttribute(Attribute::NoUnwind); } @@ -505,7 +505,7 @@ public: addFnAttr(Attribute::NoUnwind); } - /// @brief Determine if the call cannot be duplicated. + /// Determine if the call cannot be duplicated. bool cannotDuplicate() const { return hasFnAttribute(Attribute::NoDuplicate); } @@ -513,7 +513,7 @@ public: addFnAttr(Attribute::NoDuplicate); } - /// @brief Determine if the call is convergent. + /// Determine if the call is convergent. bool isConvergent() const { return hasFnAttribute(Attribute::Convergent); } @@ -524,7 +524,7 @@ public: removeFnAttr(Attribute::Convergent); } - /// @brief Determine if the call has sideeffects. + /// Determine if the call has sideeffects. bool isSpeculatable() const { return hasFnAttribute(Attribute::Speculatable); } @@ -541,7 +541,7 @@ public: addFnAttr(Attribute::NoRecurse); } - /// @brief True if the ABI mandates (or the user requested) that this + /// True if the ABI mandates (or the user requested) that this /// function be in a unwind table. bool hasUWTable() const { return hasFnAttribute(Attribute::UWTable); @@ -550,19 +550,19 @@ public: addFnAttr(Attribute::UWTable); } - /// @brief True if this function needs an unwind table. + /// True if this function needs an unwind table. bool needsUnwindTableEntry() const { return hasUWTable() || !doesNotThrow(); } - /// @brief Determine if the function returns a structure through first + /// Determine if the function returns a structure through first /// or second pointer argument. bool hasStructRetAttr() const { return AttributeSets.hasParamAttribute(0, Attribute::StructRet) || AttributeSets.hasParamAttribute(1, Attribute::StructRet); } - /// @brief Determine if the parameter or return value is marked with NoAlias + /// Determine if the parameter or return value is marked with NoAlias /// attribute. bool returnDoesNotAlias() const { return AttributeSets.hasAttribute(AttributeList::ReturnIndex, diff --git a/llvm/include/llvm/IR/GlobalValue.h b/llvm/include/llvm/IR/GlobalValue.h index fceb3a67e45..3e42bd60a6d 100644 --- a/llvm/include/llvm/IR/GlobalValue.h +++ b/llvm/include/llvm/IR/GlobalValue.h @@ -44,7 +44,7 @@ namespace Intrinsic { class GlobalValue : public Constant { public: - /// @brief An enumeration for the kinds of linkage for global values. + /// An enumeration for the kinds of linkage for global values. enum LinkageTypes { ExternalLinkage = 0,///< Externally visible function AvailableExternallyLinkage, ///< Available for inspection, not emission. @@ -59,14 +59,14 @@ public: CommonLinkage ///< Tentative definitions. }; - /// @brief An enumeration for the kinds of visibility of global values. + /// An enumeration for the kinds of visibility of global values. enum VisibilityTypes { DefaultVisibility = 0, ///< The GV is visible HiddenVisibility, ///< The GV is hidden ProtectedVisibility ///< The GV is protected }; - /// @brief Storage classes of global values for PE targets. + /// Storage classes of global values for PE targets. enum DLLStorageClassTypes { DefaultStorageClass = 0, DLLImportStorageClass = 1, ///< Function to be imported from DLL diff --git a/llvm/include/llvm/IR/InstVisitor.h b/llvm/include/llvm/IR/InstVisitor.h index 55579819fd3..4361ce7e981 100644 --- a/llvm/include/llvm/IR/InstVisitor.h +++ b/llvm/include/llvm/IR/InstVisitor.h @@ -32,7 +32,7 @@ namespace llvm { visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I)) -/// @brief Base class for instruction visitors +/// Base class for instruction visitors /// /// Instruction visitors are used when you want to perform different actions /// for different kinds of instructions without having to use lots of casts diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h index be724d07443..ad0012048ac 100644 --- a/llvm/include/llvm/IR/InstrTypes.h +++ b/llvm/include/llvm/IR/InstrTypes.h @@ -588,16 +588,16 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value) /// can be performed with code like: /// /// if (isa<CastInst>(Instr)) { ... } -/// @brief Base class of casting instructions. +/// Base class of casting instructions. class CastInst : public UnaryInstruction { protected: - /// @brief Constructor with insert-before-instruction semantics for subclasses + /// Constructor with insert-before-instruction semantics for subclasses CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr = "", Instruction *InsertBefore = nullptr) : UnaryInstruction(Ty, iType, S, InsertBefore) { setName(NameStr); } - /// @brief Constructor with insert-at-end-of-block semantics for subclasses + /// Constructor with insert-at-end-of-block semantics for subclasses CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd) : UnaryInstruction(Ty, iType, S, InsertAtEnd) { @@ -610,7 +610,7 @@ public: /// CastOps category (Instruction::isCast(opcode) returns true). This /// constructor has insert-before-instruction semantics to automatically /// insert the new CastInst before InsertBefore (if it is non-null). - /// @brief Construct any of the CastInst subclasses + /// Construct any of the CastInst subclasses static CastInst *Create( Instruction::CastOps, ///< The opcode of the cast instruction Value *S, ///< The value to be casted (operand 0) @@ -623,7 +623,7 @@ public: /// CastOps category. This constructor has insert-at-end-of-block semantics /// to automatically insert the new CastInst at the end of InsertAtEnd (if /// its non-null). - /// @brief Construct any of the CastInst subclasses + /// Construct any of the CastInst subclasses static CastInst *Create( Instruction::CastOps, ///< The opcode for the cast instruction Value *S, ///< The value to be casted (operand 0) @@ -632,7 +632,7 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Create a ZExt or BitCast cast instruction + /// Create a ZExt or BitCast cast instruction static CastInst *CreateZExtOrBitCast( Value *S, ///< The value to be casted (operand 0) Type *Ty, ///< The type to which cast should be made @@ -640,7 +640,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create a ZExt or BitCast cast instruction + /// Create a ZExt or BitCast cast instruction static CastInst *CreateZExtOrBitCast( Value *S, ///< The value to be casted (operand 0) Type *Ty, ///< The type to which operand is casted @@ -648,7 +648,7 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Create a SExt or BitCast cast instruction + /// Create a SExt or BitCast cast instruction static CastInst *CreateSExtOrBitCast( Value *S, ///< The value to be casted (operand 0) Type *Ty, ///< The type to which cast should be made @@ -656,7 +656,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create a SExt or BitCast cast instruction + /// Create a SExt or BitCast cast instruction static CastInst *CreateSExtOrBitCast( Value *S, ///< The value to be casted (operand 0) Type *Ty, ///< The type to which operand is casted @@ -664,7 +664,7 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction. + /// Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction. static CastInst *CreatePointerCast( Value *S, ///< The pointer value to be casted (operand 0) Type *Ty, ///< The type to which operand is casted @@ -672,7 +672,7 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction. + /// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction. static CastInst *CreatePointerCast( Value *S, ///< The pointer value to be casted (operand 0) Type *Ty, ///< The type to which cast should be made @@ -680,7 +680,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create a BitCast or an AddrSpaceCast cast instruction. + /// Create a BitCast or an AddrSpaceCast cast instruction. static CastInst *CreatePointerBitCastOrAddrSpaceCast( Value *S, ///< The pointer value to be casted (operand 0) Type *Ty, ///< The type to which operand is casted @@ -688,7 +688,7 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Create a BitCast or an AddrSpaceCast cast instruction. + /// Create a BitCast or an AddrSpaceCast cast instruction. static CastInst *CreatePointerBitCastOrAddrSpaceCast( Value *S, ///< The pointer value to be casted (operand 0) Type *Ty, ///< The type to which cast should be made @@ -696,7 +696,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create a BitCast, a PtrToInt, or an IntToPTr cast instruction. + /// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction. /// /// If the value is a pointer type and the destination an integer type, /// creates a PtrToInt cast. If the value is an integer type and the @@ -709,7 +709,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts. + /// Create a ZExt, BitCast, or Trunc for int -> int casts. static CastInst *CreateIntegerCast( Value *S, ///< The pointer value to be casted (operand 0) Type *Ty, ///< The type to which cast should be made @@ -718,7 +718,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts. + /// Create a ZExt, BitCast, or Trunc for int -> int casts. static CastInst *CreateIntegerCast( Value *S, ///< The integer value to be casted (operand 0) Type *Ty, ///< The integer type to which operand is casted @@ -727,7 +727,7 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts + /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts static CastInst *CreateFPCast( Value *S, ///< The floating point value to be casted Type *Ty, ///< The floating point type to cast to @@ -735,7 +735,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts + /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts static CastInst *CreateFPCast( Value *S, ///< The floating point value to be casted Type *Ty, ///< The floating point type to cast to @@ -743,7 +743,7 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Create a Trunc or BitCast cast instruction + /// Create a Trunc or BitCast cast instruction static CastInst *CreateTruncOrBitCast( Value *S, ///< The value to be casted (operand 0) Type *Ty, ///< The type to which cast should be made @@ -751,7 +751,7 @@ public: Instruction *InsertBefore = nullptr ///< Place to insert the instruction ); - /// @brief Create a Trunc or BitCast cast instruction + /// Create a Trunc or BitCast cast instruction static CastInst *CreateTruncOrBitCast( Value *S, ///< The value to be casted (operand 0) Type *Ty, ///< The type to which operand is casted @@ -759,19 +759,19 @@ public: BasicBlock *InsertAtEnd ///< The block to insert the instruction into ); - /// @brief Check whether it is valid to call getCastOpcode for these types. + /// Check whether it is valid to call getCastOpcode for these types. static bool isCastable( Type *SrcTy, ///< The Type from which the value should be cast. Type *DestTy ///< The Type to which the value should be cast. ); - /// @brief Check whether a bitcast between these types is valid + /// Check whether a bitcast between these types is valid static bool isBitCastable( Type *SrcTy, ///< The Type from which the value should be cast. Type *DestTy ///< The Type to which the value should be cast. ); - /// @brief Check whether a bitcast, inttoptr, or ptrtoint cast between these + /// Check whether a bitcast, inttoptr, or ptrtoint cast between these /// types is valid and a no-op. /// /// This ensures that any pointer<->integer cast has enough bits in the @@ -783,7 +783,7 @@ public: /// Returns the opcode necessary to cast Val into Ty using usual casting /// rules. - /// @brief Infer the opcode for cast operand and type + /// Infer the opcode for cast operand and type static Instruction::CastOps getCastOpcode( const Value *Val, ///< The value to cast bool SrcIsSigned, ///< Whether to treat the source as signed @@ -795,14 +795,14 @@ public: /// only deals with integer source and destination types. To simplify that /// logic, this method is provided. /// @returns true iff the cast has only integral typed operand and dest type. - /// @brief Determine if this is an integer-only cast. + /// Determine if this is an integer-only cast. bool isIntegerCast() const; /// A lossless cast is one that does not alter the basic value. It implies /// a no-op cast but is more stringent, preventing things like int->float, /// long->double, or int->ptr. /// @returns true iff the cast is lossless. - /// @brief Determine if this is a lossless cast. + /// Determine if this is a lossless cast. bool isLosslessCast() const; /// A no-op cast is one that can be effected without changing any bits. @@ -811,7 +811,7 @@ public: /// involving Integer and Pointer types. They are no-op casts if the integer /// is the same size as the pointer. However, pointer size varies with /// platform. - /// @brief Determine if the described cast is a no-op cast. + /// Determine if the described cast is a no-op cast. static bool isNoopCast( Instruction::CastOps Opcode, ///< Opcode of cast Type *SrcTy, ///< SrcTy of cast @@ -819,7 +819,7 @@ public: const DataLayout &DL ///< DataLayout to get the Int Ptr type from. ); - /// @brief Determine if this cast is a no-op cast. + /// Determine if this cast is a no-op cast. /// /// \param DL is the DataLayout to determine pointer size. bool isNoopCast(const DataLayout &DL) const; @@ -829,7 +829,7 @@ public: /// @returns 0 if the CastInst pair can't be eliminated, otherwise /// returns Instruction::CastOps value for a cast that can replace /// the pair, casting SrcTy to DstTy. - /// @brief Determine if a cast pair is eliminable + /// Determine if a cast pair is eliminable static unsigned isEliminableCastPair( Instruction::CastOps firstOpcode, ///< Opcode of first cast Instruction::CastOps secondOpcode, ///< Opcode of second cast @@ -841,23 +841,23 @@ public: Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null ); - /// @brief Return the opcode of this CastInst + /// Return the opcode of this CastInst Instruction::CastOps getOpcode() const { return Instruction::CastOps(Instruction::getOpcode()); } - /// @brief Return the source type, as a convenience + /// Return the source type, as a convenience Type* getSrcTy() const { return getOperand(0)->getType(); } - /// @brief Return the destination type, as a convenience + /// Return the destination type, as a convenience Type* getDestTy() const { return getType(); } /// This method can be used to determine if a cast from S to DstTy using /// Opcode op is valid or not. /// @returns true iff the proposed cast is valid. - /// @brief Determine if a cast is valid without creating one. + /// Determine if a cast is valid without creating one. static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy); - /// @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 Instruction *I) { return I->isCast(); } @@ -871,7 +871,7 @@ public: //===----------------------------------------------------------------------===// /// This class is the base class for the comparison instructions. -/// @brief Abstract base class of comparison instructions. +/// Abstract base class of comparison instructions. class CmpInst : public Instruction { public: /// This enumeration lists the possible predicates for CmpInst subclasses. @@ -937,7 +937,7 @@ public: /// the two operands. Optionally (if InstBefore is specified) insert the /// instruction into a BasicBlock right before the specified instruction. /// The specified Instruction is allowed to be a dereferenced end iterator. - /// @brief Create a CmpInst + /// Create a CmpInst static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, const Twine &Name = "", @@ -946,21 +946,21 @@ public: /// Construct a compare instruction, given the opcode, the predicate and the /// two operands. Also automatically insert this instruction to the end of /// the BasicBlock specified. - /// @brief Create a CmpInst + /// Create a CmpInst static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, const Twine &Name, BasicBlock *InsertAtEnd); - /// @brief Get the opcode casted to the right type + /// Get the opcode casted to the right type OtherOps getOpcode() const { return static_cast<OtherOps>(Instruction::getOpcode()); } - /// @brief Return the predicate for this instruction. + /// Return the predicate for this instruction. Predicate getPredicate() const { return Predicate(getSubclassDataFromInstruction()); } - /// @brief Set the predicate for this instruction to the specified value. + /// Set the predicate for this instruction to the specified value. void setPredicate(Predicate P) { setInstructionSubclassData(P); } static bool isFPPredicate(Predicate P) { @@ -979,7 +979,7 @@ public: /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. /// @returns the inverse predicate for the instruction's current predicate. - /// @brief Return the inverse of the instruction's predicate. + /// Return the inverse of the instruction's predicate. Predicate getInversePredicate() const { return getInversePredicate(getPredicate()); } @@ -987,7 +987,7 @@ public: /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. /// @returns the inverse predicate for predicate provided in \p pred. - /// @brief Return the inverse of a given predicate + /// Return the inverse of a given predicate static Predicate getInversePredicate(Predicate pred); /// For example, EQ->EQ, SLE->SGE, ULT->UGT, @@ -995,14 +995,14 @@ public: /// @returns the predicate that would be the result of exchanging the two /// operands of the CmpInst instruction without changing the result /// produced. - /// @brief Return the predicate as if the operands were swapped + /// Return the predicate as if the operands were swapped Predicate getSwappedPredicate() const { return getSwappedPredicate(getPredicate()); } /// This is a static version that you can use without an instruction /// available. - /// @brief Return the predicate as if the operands were swapped. + /// Return the predicate as if the operands were swapped. static Predicate getSwappedPredicate(Predicate pred); /// For predicate of kind "is X or equal to 0" returns the predicate "is X". @@ -1010,18 +1010,18 @@ public: /// does not support other kind of predicates. /// @returns the predicate that does not contains is equal to zero if /// it had and vice versa. - /// @brief Return the flipped strictness of predicate + /// Return the flipped strictness of predicate Predicate getFlippedStrictnessPredicate() const { return getFlippedStrictnessPredicate(getPredicate()); } /// This is a static version that you can use without an instruction /// available. - /// @brief Return the flipped strictness of predicate + /// Return the flipped strictness of predicate static Predicate getFlippedStrictnessPredicate(Predicate pred); /// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE. - /// @brief Returns the non-strict version of strict comparisons. + /// Returns the non-strict version of strict comparisons. Predicate getNonStrictPredicate() const { return getNonStrictPredicate(getPredicate()); } @@ -1030,74 +1030,74 @@ public: /// available. /// @returns the non-strict version of comparison provided in \p pred. /// If \p pred is not a strict comparison predicate, returns \p pred. - /// @brief Returns the non-strict version of strict comparisons. + /// Returns the non-strict version of strict comparisons. static Predicate getNonStrictPredicate(Predicate pred); - /// @brief Provide more efficient getOperand methods. + /// Provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); /// This is just a convenience that dispatches to the subclasses. - /// @brief Swap the operands and adjust predicate accordingly to retain + /// Swap the operands and adjust predicate accordingly to retain /// the same comparison. void swapOperands(); /// This is just a convenience that dispatches to the subclasses. - /// @brief Determine if this CmpInst is commutative. + /// Determine if this CmpInst is commutative. bool isCommutative() const; /// This is just a convenience that dispatches to the subclasses. - /// @brief Determine if this is an equals/not equals predicate. + /// Determine if this is an equals/not equals predicate. bool isEquality() const; /// @returns true if the comparison is signed, false otherwise. - /// @brief Determine if this instruction is using a signed comparison. + /// Determine if this instruction is using a signed comparison. bool isSigned() const { return isSigned(getPredicate()); } /// @returns true if the comparison is unsigned, false otherwise. - /// @brief Determine if this instruction is using an unsigned comparison. + /// Determine if this instruction is using an unsigned comparison. bool isUnsigned() const { return isUnsigned(getPredicate()); } /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert /// @returns the signed version of the unsigned predicate pred. - /// @brief return the signed version of a predicate + /// return the signed version of a predicate static Predicate getSignedPredicate(Predicate pred); /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert /// @returns the signed version of the predicate for this instruction (which /// has to be an unsigned predicate). - /// @brief return the signed version of a predicate + /// return the signed version of a predicate Predicate getSignedPredicate() { return getSignedPredicate(getPredicate()); } /// This is just a convenience. - /// @brief Determine if this is true when both operands are the same. + /// Determine if this is true when both operands are the same. bool isTrueWhenEqual() const { return isTrueWhenEqual(getPredicate()); } /// This is just a convenience. - /// @brief Determine if this is false when both operands are the same. + /// Determine if this is false when both operands are the same. bool isFalseWhenEqual() const { return isFalseWhenEqual(getPredicate()); } /// @returns true if the predicate is unsigned, false otherwise. - /// @brief Determine if the predicate is an unsigned operation. + /// Determine if the predicate is an unsigned operation. static bool isUnsigned(Predicate predicate); /// @returns true if the predicate is signed, false otherwise. - /// @brief Determine if the predicate is an signed operation. + /// Determine if the predicate is an signed operation. static bool isSigned(Predicate predicate); - /// @brief Determine if the predicate is an ordered operation. + /// Determine if the predicate is an ordered operation. static bool isOrdered(Predicate predicate); - /// @brief Determine if the predicate is an unordered operation. + /// Determine if the predicate is an unordered operation. static bool isUnordered(Predicate predicate); /// Determine if the predicate is true when comparing a value with itself. @@ -1114,7 +1114,7 @@ public: /// operands. static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2); - /// @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 Instruction *I) { return I->getOpcode() == Instruction::ICmp || I->getOpcode() == Instruction::FCmp; @@ -1123,7 +1123,7 @@ public: return isa<Instruction>(V) && classof(cast<Instruction>(V)); } - /// @brief Create a result type for fcmp/icmp + /// Create a result type for fcmp/icmp static Type* makeCmpResultType(Type* opnd_type) { if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) { return VectorType::get(Type::getInt1Ty(opnd_type->getContext()), diff --git a/llvm/include/llvm/IR/Instruction.h b/llvm/include/llvm/IR/Instruction.h index 76bc4010d8c..dddea3e11f7 100644 --- a/llvm/include/llvm/IR/Instruction.h +++ b/llvm/include/llvm/IR/Instruction.h @@ -590,7 +590,7 @@ public: /// be identical. /// @returns true if the specified instruction is the same operation as /// the current one. - /// @brief Determine if one instruction is the same operation as another. + /// Determine if one instruction is the same operation as another. bool isSameOperationAs(const Instruction *I, unsigned flags = 0) const; /// Return true if there are any uses of this instruction in blocks other than diff --git a/llvm/include/llvm/IR/Instructions.h b/llvm/include/llvm/IR/Instructions.h index 6c15d5d62d7..59a19034f32 100644 --- a/llvm/include/llvm/IR/Instructions.h +++ b/llvm/include/llvm/IR/Instructions.h @@ -1719,7 +1719,7 @@ public: return Attrs.getDereferenceableOrNullBytes(i); } - /// @brief Determine if the return value is marked with NoAlias attribute. + /// Determine if the return value is marked with NoAlias attribute. bool returnDoesNotAlias() const { return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias); } @@ -1763,7 +1763,7 @@ public: addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly); } - /// @brief Determine if the call can access memmory only using pointers based + /// Determine if the call can access memmory only using pointers based /// on its arguments. bool onlyAccessesArgMemory() const { return hasFnAttr(Attribute::ArgMemOnly); @@ -1772,7 +1772,7 @@ public: addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly); } - /// @brief Determine if the function may only access memory that is + /// Determine if the function may only access memory that is /// inaccessible from the IR. bool onlyAccessesInaccessibleMemory() const { return hasFnAttr(Attribute::InaccessibleMemOnly); @@ -1781,7 +1781,7 @@ public: addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly); } - /// @brief Determine if the function may only access memory that is + /// Determine if the function may only access memory that is /// either inaccessible from the IR or pointed to by its arguments. bool onlyAccessesInaccessibleMemOrArgMem() const { return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly); diff --git a/llvm/include/llvm/IR/Module.h b/llvm/include/llvm/IR/Module.h index 941e5b3c2ae..0d1265d0753 100644 --- a/llvm/include/llvm/IR/Module.h +++ b/llvm/include/llvm/IR/Module.h @@ -59,7 +59,7 @@ class StructType; /// A module maintains a GlobalValRefMap object that is used to hold all /// constant references to global variables in the module. When a global /// variable is destroyed, it should have no entries in the GlobalValueRefMap. -/// @brief The main container class for the LLVM Intermediate Representation. +/// The main container class for the LLVM Intermediate Representation. class Module { /// @name Types And Enumerations /// @{ diff --git a/llvm/include/llvm/IR/Type.h b/llvm/include/llvm/IR/Type.h index 39a79764387..ae120645dbd 100644 --- a/llvm/include/llvm/IR/Type.h +++ b/llvm/include/llvm/IR/Type.h @@ -229,7 +229,7 @@ public: /// Return true if this type could be converted with a lossless BitCast to /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the /// same size only where no re-interpretation of the bits is done. - /// @brief Determine if this type could be losslessly bitcast to Ty + /// Determine if this type could be losslessly bitcast to Ty bool canLosslesslyBitCastTo(Type *Ty) const; /// Return true if this type is empty, that is, it has no elements or all of diff --git a/llvm/include/llvm/IR/ValueSymbolTable.h b/llvm/include/llvm/IR/ValueSymbolTable.h index 26cbbfabfc0..012e717c747 100644 --- a/llvm/include/llvm/IR/ValueSymbolTable.h +++ b/llvm/include/llvm/IR/ValueSymbolTable.h @@ -48,13 +48,13 @@ class ValueSymbolTable { /// @name Types /// @{ public: - /// @brief A mapping of names to values. + /// A mapping of names to values. using ValueMap = StringMap<Value*>; - /// @brief An iterator over a ValueMap. + /// An iterator over a ValueMap. using iterator = ValueMap::iterator; - /// @brief A const_iterator over a ValueMap. + /// A const_iterator over a ValueMap. using const_iterator = ValueMap::const_iterator; /// @} @@ -71,35 +71,35 @@ public: /// This method finds the value with the given \p Name in the /// the symbol table. /// @returns the value associated with the \p Name - /// @brief Lookup a named Value. + /// Lookup a named Value. Value *lookup(StringRef Name) const { return vmap.lookup(Name); } /// @returns true iff the symbol table is empty - /// @brief Determine if the symbol table is empty + /// Determine if the symbol table is empty inline bool empty() const { return vmap.empty(); } - /// @brief The number of name/type pairs is returned. + /// The number of name/type pairs is returned. inline unsigned size() const { return unsigned(vmap.size()); } /// This function can be used from the debugger to display the /// content of the symbol table while debugging. - /// @brief Print out symbol table on stderr + /// Print out symbol table on stderr void dump() const; /// @} /// @name Iteration /// @{ - /// @brief Get an iterator that from the beginning of the symbol table. + /// Get an iterator that from the beginning of the symbol table. inline iterator begin() { return vmap.begin(); } - /// @brief Get a const_iterator that from the beginning of the symbol table. + /// Get a const_iterator that from the beginning of the symbol table. inline const_iterator begin() const { return vmap.begin(); } - /// @brief Get an iterator to the end of the symbol table. + /// Get an iterator to the end of the symbol table. inline iterator end() { return vmap.end(); } - /// @brief Get a const_iterator to the end of the symbol table. + /// Get a const_iterator to the end of the symbol table. inline const_iterator end() const { return vmap.end(); } /// @} @@ -111,7 +111,7 @@ private: /// This method adds the provided value \p N to the symbol table. The Value /// must have a name which is used to place the value in the symbol table. /// If the inserted name conflicts, this renames the value. - /// @brief Add a named value to the symbol table + /// Add a named value to the symbol table void reinsertValue(Value *V); /// createValueName - This method attempts to create a value name and insert diff --git a/llvm/include/llvm/Object/Binary.h b/llvm/include/llvm/Object/Binary.h index 5e93691d1fd..99745e24b8c 100644 --- a/llvm/include/llvm/Object/Binary.h +++ b/llvm/include/llvm/Object/Binary.h @@ -156,7 +156,7 @@ public: } }; -/// @brief Create a Binary from Source, autodetecting the file type. +/// Create a Binary from Source, autodetecting the file type. /// /// @param Source The data to create the Binary from. Expected<std::unique_ptr<Binary>> createBinary(MemoryBufferRef Source, diff --git a/llvm/include/llvm/Object/Decompressor.h b/llvm/include/llvm/Object/Decompressor.h index c8e888d285e..2a77d2ffbf6 100644 --- a/llvm/include/llvm/Object/Decompressor.h +++ b/llvm/include/llvm/Object/Decompressor.h @@ -17,10 +17,10 @@ namespace llvm { namespace object { -/// @brief Decompressor helps to handle decompression of compressed sections. +/// Decompressor helps to handle decompression of compressed sections. class Decompressor { public: - /// @brief Create decompressor object. + /// Create decompressor object. /// @param Name Section name. /// @param Data Section content. /// @param IsLE Flag determines if Data is in little endian form. @@ -28,27 +28,27 @@ public: static Expected<Decompressor> create(StringRef Name, StringRef Data, bool IsLE, bool Is64Bit); - /// @brief Resize the buffer and uncompress section data into it. + /// Resize the buffer and uncompress section data into it. /// @param Out Destination buffer. template <class T> Error resizeAndDecompress(T &Out) { Out.resize(DecompressedSize); return decompress({Out.data(), (size_t)DecompressedSize}); } - /// @brief Uncompress section data to raw buffer provided. + /// Uncompress section data to raw buffer provided. /// @param Buffer Destination buffer. Error decompress(MutableArrayRef<char> Buffer); - /// @brief Return memory buffer size required for decompression. + /// Return memory buffer size required for decompression. uint64_t getDecompressedSize() { return DecompressedSize; } - /// @brief Return true if section is compressed, including gnu-styled case. + /// Return true if section is compressed, including gnu-styled case. static bool isCompressed(const object::SectionRef &Section); - /// @brief Return true if section is a ELF compressed one. + /// Return true if section is a ELF compressed one. static bool isCompressedELFSection(uint64_t Flags, StringRef Name); - /// @brief Return true if section name matches gnu style compressed one. + /// Return true if section name matches gnu style compressed one. static bool isGnuStyle(StringRef Name); private: diff --git a/llvm/include/llvm/Object/ELFTypes.h b/llvm/include/llvm/Object/ELFTypes.h index 260ca96c9cc..521421af32a 100644 --- a/llvm/include/llvm/Object/ELFTypes.h +++ b/llvm/include/llvm/Object/ELFTypes.h @@ -148,7 +148,7 @@ struct Elf_Shdr_Impl : Elf_Shdr_Base<ELFT> { using Elf_Shdr_Base<ELFT>::sh_entsize; using Elf_Shdr_Base<ELFT>::sh_size; - /// @brief Get the number of entities this section contains if it has any. + /// Get the number of entities this section contains if it has any. unsigned getEntityCount() const { if (sh_entsize == 0) return 0; diff --git a/llvm/include/llvm/Object/ObjectFile.h b/llvm/include/llvm/Object/ObjectFile.h index 9c4ae94d3a6..f0685482b6a 100644 --- a/llvm/include/llvm/Object/ObjectFile.h +++ b/llvm/include/llvm/Object/ObjectFile.h @@ -65,7 +65,7 @@ public: symbol_iterator getSymbol() const; uint64_t getType() const; - /// @brief Get a string that represents the type of this relocation. + /// Get a string that represents the type of this relocation. /// /// This is for display purposes only. void getTypeName(SmallVectorImpl<char> &Result) const; @@ -100,7 +100,7 @@ public: uint64_t getSize() const; std::error_code getContents(StringRef &Result) const; - /// @brief Get the alignment of this section as the actual value (not log 2). + /// Get the alignment of this section as the actual value (not log 2). uint64_t getAlignment() const; bool isCompressed() const; @@ -154,12 +154,12 @@ public: /// offset or a virtual address. uint64_t getValue() const; - /// @brief Get the alignment of this symbol as the actual value (not log 2). + /// Get the alignment of this symbol as the actual value (not log 2). uint32_t getAlignment() const; uint64_t getCommonSize() const; Expected<SymbolRef::Type> getType() const; - /// @brief Get section this symbol is defined in reference to. Result is + /// Get section this symbol is defined in reference to. Result is /// end_sections() if it is undefined or is an absolute symbol. Expected<section_iterator> getSection() const; @@ -275,7 +275,7 @@ public: return section_iterator_range(section_begin(), section_end()); } - /// @brief The number of bytes used to represent an address in this object + /// The number of bytes used to represent an address in this object /// file format. virtual uint8_t getBytesInAddress() const = 0; @@ -284,7 +284,7 @@ public: virtual SubtargetFeatures getFeatures() const = 0; virtual void setARMSubArch(Triple &TheTriple) const { } - /// @brief Create a triple from the data in this object file. + /// Create a triple from the data in this object file. Triple makeTriple() const; virtual std::error_code @@ -301,7 +301,7 @@ public: /// @returns Pointer to ObjectFile subclass to handle this type of object. /// @param ObjectPath The path to the object file. ObjectPath.isObject must /// return true. - /// @brief Create ObjectFile from path. + /// Create ObjectFile from path. static Expected<OwningBinary<ObjectFile>> createObjectFile(StringRef ObjectPath); diff --git a/llvm/include/llvm/Object/RelocVisitor.h b/llvm/include/llvm/Object/RelocVisitor.h index bc6606820c9..008e109f667 100644 --- a/llvm/include/llvm/Object/RelocVisitor.h +++ b/llvm/include/llvm/Object/RelocVisitor.h @@ -32,7 +32,7 @@ namespace llvm { namespace object { -/// @brief Base class for object file relocation visitors. +/// Base class for object file relocation visitors. class RelocVisitor { public: explicit RelocVisitor(const ObjectFile &Obj) : ObjToVisit(Obj) {} diff --git a/llvm/include/llvm/Pass.h b/llvm/include/llvm/Pass.h index a29b3771abb..d65347d611e 100644 --- a/llvm/include/llvm/Pass.h +++ b/llvm/include/llvm/Pass.h @@ -353,18 +353,18 @@ protected: /// If the user specifies the -time-passes argument on an LLVM tool command line /// then the value of this boolean will be true, otherwise false. -/// @brief This is the storage for the -time-passes option. +/// This is the storage for the -time-passes option. extern bool TimePassesIsEnabled; /// isFunctionInPrintList - returns true if a function should be printed via // debugging options like -print-after-all/-print-before-all. -// @brief Tells if the function IR should be printed by PrinterPass. +// Tells if the function IR should be printed by PrinterPass. extern bool isFunctionInPrintList(StringRef FunctionName); /// forcePrintModuleIR - returns true if IR printing passes should // be printing module IR (even for local-pass printers e.g. function-pass) // to provide more context, as enabled by debugging option -print-module-scope -// @brief Tells if IR printer should be printing module IR +// Tells if IR printer should be printing module IR extern bool forcePrintModuleIR(); } // end namespace llvm diff --git a/llvm/include/llvm/Support/DynamicLibrary.h b/llvm/include/llvm/Support/DynamicLibrary.h index 469d5dfad06..9563b483f6d 100644 --- a/llvm/include/llvm/Support/DynamicLibrary.h +++ b/llvm/include/llvm/Support/DynamicLibrary.h @@ -64,7 +64,7 @@ namespace sys { /// if the library fails to load. /// /// It is safe to call this function multiple times for the same library. - /// @brief Open a dynamic library permanently. + /// Open a dynamic library permanently. static DynamicLibrary getPermanentLibrary(const char *filename, std::string *errMsg = nullptr); @@ -110,10 +110,10 @@ namespace sys { /// search permanently loaded libraries (getPermanentLibrary()) as well /// as explicitly registered symbols (AddSymbol()). /// @throws std::string on error. - /// @brief Search through libraries for address of a symbol + /// Search through libraries for address of a symbol static void *SearchForAddressOfSymbol(const char *symbolName); - /// @brief Convenience function for C++ophiles. + /// Convenience function for C++ophiles. static void *SearchForAddressOfSymbol(const std::string &symbolName) { return SearchForAddressOfSymbol(symbolName.c_str()); } @@ -121,7 +121,7 @@ namespace sys { /// This functions permanently adds the symbol \p symbolName with the /// value \p symbolValue. These symbols are searched before any /// libraries. - /// @brief Add searchable symbol/value pair. + /// Add searchable symbol/value pair. static void AddSymbol(StringRef symbolName, void *symbolValue); class HandleSet; diff --git a/llvm/include/llvm/Support/FileSystem.h b/llvm/include/llvm/Support/FileSystem.h index 32a29290585..df1bdbbdc11 100644 --- a/llvm/include/llvm/Support/FileSystem.h +++ b/llvm/include/llvm/Support/FileSystem.h @@ -263,7 +263,7 @@ public: /// @name Physical Operators /// @{ -/// @brief Make \a path an absolute path. +/// Make \a path an absolute path. /// /// Makes \a path absolute using the \a current_directory if it is not already. /// An empty \a path will result in the \a current_directory. @@ -277,7 +277,7 @@ public: std::error_code make_absolute(const Twine ¤t_directory, SmallVectorImpl<char> &path); -/// @brief Make \a path an absolute path. +/// Make \a path an absolute path. /// /// Makes \a path absolute using the current directory if it is not already. An /// empty \a path will result in the current directory. @@ -290,7 +290,7 @@ std::error_code make_absolute(const Twine ¤t_directory, /// platform-specific error_code. std::error_code make_absolute(SmallVectorImpl<char> &path); -/// @brief Create all the non-existent directories in path. +/// Create all the non-existent directories in path. /// /// @param path Directories to create. /// @returns errc::success if is_directory(path), otherwise a platform @@ -300,7 +300,7 @@ std::error_code create_directories(const Twine &path, bool IgnoreExisting = true, perms Perms = owner_all | group_all); -/// @brief Create the directory in path. +/// Create the directory in path. /// /// @param path Directory to create. /// @returns errc::success if is_directory(path), otherwise a platform @@ -309,7 +309,7 @@ std::error_code create_directories(const Twine &path, std::error_code create_directory(const Twine &path, bool IgnoreExisting = true, perms Perms = owner_all | group_all); -/// @brief Create a link from \a from to \a to. +/// Create a link from \a from to \a to. /// /// The link may be a soft or a hard link, depending on the platform. The caller /// may not assume which one. Currently on windows it creates a hard link since @@ -330,7 +330,7 @@ std::error_code create_link(const Twine &to, const Twine &from); /// specific error_code. std::error_code create_hard_link(const Twine &to, const Twine &from); -/// @brief Collapse all . and .. patterns, resolve all symlinks, and optionally +/// Collapse all . and .. patterns, resolve all symlinks, and optionally /// expand ~ expressions to the user's home directory. /// /// @param path The path to resolve. @@ -340,21 +340,21 @@ std::error_code create_hard_link(const Twine &to, const Twine &from); std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output, bool expand_tilde = false); -/// @brief Get the current path. +/// Get the current path. /// /// @param result Holds the current path on return. /// @returns errc::success if the current path has been stored in result, /// otherwise a platform-specific error_code. std::error_code current_path(SmallVectorImpl<char> &result); -/// @brief Set the current path. +/// Set the current path. /// /// @param path The path to set. /// @returns errc::success if the current path was successfully set, /// otherwise a platform-specific error_code. std::error_code set_current_path(const Twine &path); -/// @brief Remove path. Equivalent to POSIX remove(). +/// Remove path. Equivalent to POSIX remove(). /// /// @param path Input path. /// @returns errc::success if path has been removed or didn't exist, otherwise a @@ -362,14 +362,14 @@ std::error_code set_current_path(const Twine &path); /// returns error if the file didn't exist. std::error_code remove(const Twine &path, bool IgnoreNonExisting = true); -/// @brief Recursively delete a directory. +/// Recursively delete a directory. /// /// @param path Input path. /// @returns errc::success if path has been removed or didn't exist, otherwise a /// platform-specific error code. std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true); -/// @brief Rename \a from to \a to. +/// Rename \a from to \a to. /// /// Files are renamed as if by POSIX rename(), except that on Windows there may /// be a short interval of time during which the destination file does not @@ -379,13 +379,13 @@ std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true); /// @param to The path to rename to. This is created. std::error_code rename(const Twine &from, const Twine &to); -/// @brief Copy the contents of \a From to \a To. +/// Copy the contents of \a From to \a To. /// /// @param From The path to copy from. /// @param To The path to copy to. This is created. std::error_code copy_file(const Twine &From, const Twine &To); -/// @brief Resize path to size. File is resized as if by POSIX truncate(). +/// Resize path to size. File is resized as if by POSIX truncate(). /// /// @param FD Input file descriptor. /// @param Size Size to resize to. @@ -393,21 +393,21 @@ std::error_code copy_file(const Twine &From, const Twine &To); /// platform-specific error_code. std::error_code resize_file(int FD, uint64_t Size); -/// @brief Compute an MD5 hash of a file's contents. +/// Compute an MD5 hash of a file's contents. /// /// @param FD Input file descriptor. /// @returns An MD5Result with the hash computed, if successful, otherwise a /// std::error_code. ErrorOr<MD5::MD5Result> md5_contents(int FD); -/// @brief Version of compute_md5 that doesn't require an open file descriptor. +/// Version of compute_md5 that doesn't require an open file descriptor. ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path); /// @} /// @name Physical Observers /// @{ -/// @brief Does file exist? +/// Does file exist? /// /// @param status A basic_file_status previously returned from stat. /// @returns True if the file represented by status exists, false if it does @@ -416,14 +416,14 @@ bool exists(const basic_file_status &status); enum class AccessMode { Exist, Write, Execute }; -/// @brief Can the file be accessed? +/// Can the file be accessed? /// /// @param Path Input path. /// @returns errc::success if the path can be accessed, otherwise a /// platform-specific error_code. std::error_code access(const Twine &Path, AccessMode Mode); -/// @brief Does file exist? +/// Does file exist? /// /// @param Path Input path. /// @returns True if it exists, false otherwise. @@ -431,13 +431,13 @@ inline bool exists(const Twine &Path) { return !access(Path, AccessMode::Exist); } -/// @brief Can we execute this file? +/// Can we execute this file? /// /// @param Path Input path. /// @returns True if we can execute it, false otherwise. bool can_execute(const Twine &Path); -/// @brief Can we write this file? +/// Can we write this file? /// /// @param Path Input path. /// @returns True if we can write to it, false otherwise. @@ -445,7 +445,7 @@ inline bool can_write(const Twine &Path) { return !access(Path, AccessMode::Write); } -/// @brief Do file_status's represent the same thing? +/// Do file_status's represent the same thing? /// /// @param A Input file_status. /// @param B Input file_status. @@ -456,7 +456,7 @@ inline bool can_write(const Twine &Path) { /// otherwise. bool equivalent(file_status A, file_status B); -/// @brief Do paths represent the same thing? +/// Do paths represent the same thing? /// /// assert(status_known(A) || status_known(B)); /// @@ -468,14 +468,14 @@ bool equivalent(file_status A, file_status B); /// platform-specific error_code. std::error_code equivalent(const Twine &A, const Twine &B, bool &result); -/// @brief Simpler version of equivalent for clients that don't need to +/// Simpler version of equivalent for clients that don't need to /// differentiate between an error and false. inline bool equivalent(const Twine &A, const Twine &B) { bool result; return !equivalent(A, B, result) && result; } -/// @brief Is the file mounted on a local filesystem? +/// Is the file mounted on a local filesystem? /// /// @param path Input path. /// @param result Set to true if \a path is on fixed media such as a hard disk, @@ -484,24 +484,24 @@ inline bool equivalent(const Twine &A, const Twine &B) { /// platform specific error_code. std::error_code is_local(const Twine &path, bool &result); -/// @brief Version of is_local accepting an open file descriptor. +/// Version of is_local accepting an open file descriptor. std::error_code is_local(int FD, bool &result); -/// @brief Simpler version of is_local for clients that don't need to +/// Simpler version of is_local for clients that don't need to /// differentiate between an error and false. inline bool is_local(const Twine &Path) { bool Result; return !is_local(Path, Result) && Result; } -/// @brief Simpler version of is_local accepting an open file descriptor for +/// Simpler version of is_local accepting an open file descriptor for /// clients that don't need to differentiate between an error and false. inline bool is_local(int FD) { bool Result; return !is_local(FD, Result) && Result; } -/// @brief Does status represent a directory? +/// Does status represent a directory? /// /// @param Path The path to get the type of. /// @param Follow For symbolic links, indicates whether to return the file type @@ -509,13 +509,13 @@ inline bool is_local(int FD) { /// @returns A value from the file_type enumeration indicating the type of file. file_type get_file_type(const Twine &Path, bool Follow = true); -/// @brief Does status represent a directory? +/// Does status represent a directory? /// /// @param status A basic_file_status previously returned from status. /// @returns status.type() == file_type::directory_file. bool is_directory(const basic_file_status &status); -/// @brief Is path a directory? +/// Is path a directory? /// /// @param path Input path. /// @param result Set to true if \a path is a directory (after following @@ -524,20 +524,20 @@ bool is_directory(const basic_file_status &status); /// platform-specific error_code. std::error_code is_directory(const Twine &path, bool &result); -/// @brief Simpler version of is_directory for clients that don't need to +/// Simpler version of is_directory for clients that don't need to /// differentiate between an error and false. inline bool is_directory(const Twine &Path) { bool Result; return !is_directory(Path, Result) && Result; } -/// @brief Does status represent a regular file? +/// Does status represent a regular file? /// /// @param status A basic_file_status previously returned from status. /// @returns status_known(status) && status.type() == file_type::regular_file. bool is_regular_file(const basic_file_status &status); -/// @brief Is path a regular file? +/// Is path a regular file? /// /// @param path Input path. /// @param result Set to true if \a path is a regular file (after following @@ -546,7 +546,7 @@ bool is_regular_file(const basic_file_status &status); /// platform-specific error_code. std::error_code is_regular_file(const Twine &path, bool &result); -/// @brief Simpler version of is_regular_file for clients that don't need to +/// Simpler version of is_regular_file for clients that don't need to /// differentiate between an error and false. inline bool is_regular_file(const Twine &Path) { bool Result; @@ -555,13 +555,13 @@ inline bool is_regular_file(const Twine &Path) { return Result; } -/// @brief Does status represent a symlink file? +/// Does status represent a symlink file? /// /// @param status A basic_file_status previously returned from status. /// @returns status_known(status) && status.type() == file_type::symlink_file. bool is_symlink_file(const basic_file_status &status); -/// @brief Is path a symlink file? +/// Is path a symlink file? /// /// @param path Input path. /// @param result Set to true if \a path is a symlink file, false if it is not. @@ -570,7 +570,7 @@ bool is_symlink_file(const basic_file_status &status); /// platform-specific error_code. std::error_code is_symlink_file(const Twine &path, bool &result); -/// @brief Simpler version of is_symlink_file for clients that don't need to +/// Simpler version of is_symlink_file for clients that don't need to /// differentiate between an error and false. inline bool is_symlink_file(const Twine &Path) { bool Result; @@ -579,14 +579,14 @@ inline bool is_symlink_file(const Twine &Path) { return Result; } -/// @brief Does this status represent something that exists but is not a +/// Does this status represent something that exists but is not a /// directory or regular file? /// /// @param status A basic_file_status previously returned from status. /// @returns exists(s) && !is_regular_file(s) && !is_directory(s) bool is_other(const basic_file_status &status); -/// @brief Is path something that exists but is not a directory, +/// Is path something that exists but is not a directory, /// regular file, or symlink? /// /// @param path Input path. @@ -596,7 +596,7 @@ bool is_other(const basic_file_status &status); /// platform-specific error_code. std::error_code is_other(const Twine &path, bool &result); -/// @brief Get file status as if by POSIX stat(). +/// Get file status as if by POSIX stat(). /// /// @param path Input path. /// @param result Set to the file status. @@ -607,10 +607,10 @@ std::error_code is_other(const Twine &path, bool &result); std::error_code status(const Twine &path, file_status &result, bool follow = true); -/// @brief A version for when a file descriptor is already available. +/// A version for when a file descriptor is already available. std::error_code status(int FD, file_status &Result); -/// @brief Set file permissions. +/// Set file permissions. /// /// @param Path File to set permissions on. /// @param Permissions New file permissions. @@ -621,7 +621,7 @@ std::error_code status(int FD, file_status &Result); /// Otherwise, the file will be marked as read-only. std::error_code setPermissions(const Twine &Path, perms Permissions); -/// @brief Get file permissions. +/// Get file permissions. /// /// @param Path File to get permissions from. /// @returns the permissions if they were successfully retrieved, otherwise a @@ -631,7 +631,7 @@ std::error_code setPermissions(const Twine &Path, perms Permissions); /// will be returned. ErrorOr<perms> getPermissions(const Twine &Path); -/// @brief Get file size. +/// Get file size. /// /// @param Path Input path. /// @param Result Set to the size of the file in \a Path. @@ -646,20 +646,20 @@ inline std::error_code file_size(const Twine &Path, uint64_t &Result) { return std::error_code(); } -/// @brief Set the file modification and access time. +/// Set the file modification and access time. /// /// @returns errc::success if the file times were successfully set, otherwise a /// platform-specific error_code or errc::function_not_supported on /// platforms where the functionality isn't available. std::error_code setLastModificationAndAccessTime(int FD, TimePoint<> Time); -/// @brief Is status available? +/// Is status available? /// /// @param s Input file status. /// @returns True if status() != status_error. bool status_known(const basic_file_status &s); -/// @brief Is status available? +/// Is status available? /// /// @param path Input path. /// @param result Set to true if status() != status_error. @@ -695,7 +695,7 @@ enum OpenFlags : unsigned { F_Delete = 32 }; -/// @brief Create a uniquely named file. +/// Create a uniquely named file. /// /// Generates a unique path suitable for a temporary file and then opens it as a /// file. The name is based on \a model with '%' replaced by a random char in @@ -721,7 +721,7 @@ std::error_code createUniqueFile(const Twine &Model, int &ResultFD, unsigned Mode = all_read | all_write, sys::fs::OpenFlags Flags = sys::fs::F_RW); -/// @brief Simpler version for clients that don't want an open file. An empty +/// Simpler version for clients that don't want an open file. An empty /// file will still be created. std::error_code createUniqueFile(const Twine &Model, SmallVectorImpl<char> &ResultPath, @@ -765,7 +765,7 @@ public: ~TempFile(); }; -/// @brief Create a file in the system temporary directory. +/// Create a file in the system temporary directory. /// /// The filename is of the form prefix-random_chars.suffix. Since the directory /// is not know to the caller, Prefix and Suffix cannot have path separators. @@ -778,7 +778,7 @@ std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, SmallVectorImpl<char> &ResultPath, sys::fs::OpenFlags Flags = sys::fs::F_RW); -/// @brief Simpler version for clients that don't want an open file. An empty +/// Simpler version for clients that don't want an open file. An empty /// file will still be created. std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, SmallVectorImpl<char> &ResultPath); @@ -786,7 +786,7 @@ std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, std::error_code createUniqueDirectory(const Twine &Prefix, SmallVectorImpl<char> &ResultPath); -/// @brief Get a unique name, not currently exisiting in the filesystem. Subject +/// Get a unique name, not currently exisiting in the filesystem. Subject /// to race conditions, prefer to use createUniqueFile instead. /// /// Similar to createUniqueFile, but instead of creating a file only @@ -796,7 +796,7 @@ std::error_code createUniqueDirectory(const Twine &Prefix, std::error_code getPotentiallyUniqueFileName(const Twine &Model, SmallVectorImpl<char> &ResultPath); -/// @brief Get a unique temporary file name, not currently exisiting in the +/// Get a unique temporary file name, not currently exisiting in the /// filesystem. Subject to race conditions, prefer to use createTemporaryFile /// instead. /// @@ -825,7 +825,7 @@ std::error_code openFileForRead(const Twine &Name, int &ResultFD, std::error_code getUniqueID(const Twine Path, UniqueID &Result); -/// @brief Get disk space usage information. +/// Get disk space usage information. /// /// Note: Users must be careful about "Time Of Check, Time Of Use" kind of bug. /// Note: Windows reports results according to the quota allocated to the user. diff --git a/llvm/include/llvm/Support/Memory.h b/llvm/include/llvm/Support/Memory.h index 3140dc6eef4..fa026d49a61 100644 --- a/llvm/include/llvm/Support/Memory.h +++ b/llvm/include/llvm/Support/Memory.h @@ -25,7 +25,7 @@ namespace sys { /// and a size. It is used by the Memory class (a friend) as the result of /// various memory allocation operations. /// @see Memory - /// @brief Memory block abstraction. + /// Memory block abstraction. class MemoryBlock { public: MemoryBlock() : Address(nullptr), Size(0) { } @@ -42,7 +42,7 @@ namespace sys { /// This class provides various memory handling functions that manipulate /// MemoryBlock instances. /// @since 1.4 - /// @brief An abstraction for memory operations. + /// An abstraction for memory operations. class Memory { public: enum ProtectionFlags { @@ -74,7 +74,7 @@ namespace sys { /// \r a non-null MemoryBlock if the function was successful, /// otherwise a null MemoryBlock is with \p EC describing the error. /// - /// @brief Allocate mapped memory. + /// Allocate mapped memory. static MemoryBlock allocateMappedMemory(size_t NumBytes, const MemoryBlock *const NearBlock, unsigned Flags, @@ -88,7 +88,7 @@ namespace sys { /// \r error_success if the function was successful, or an error_code /// describing the failure if an error occurred. /// - /// @brief Release mapped memory. + /// Release mapped memory. static std::error_code releaseMappedMemory(MemoryBlock &Block); /// This method sets the protection flags for a block of memory to the @@ -105,7 +105,7 @@ namespace sys { /// \r error_success if the function was successful, or an error_code /// describing the failure if an error occurred. /// - /// @brief Set memory protection state. + /// Set memory protection state. static std::error_code protectMappedMemory(const MemoryBlock &Block, unsigned Flags); diff --git a/llvm/include/llvm/Support/Mutex.h b/llvm/include/llvm/Support/Mutex.h index d1d9c0c88fb..680d94b24ef 100644 --- a/llvm/include/llvm/Support/Mutex.h +++ b/llvm/include/llvm/Support/Mutex.h @@ -23,7 +23,7 @@ namespace llvm { namespace sys { - /// @brief Platform agnostic Mutex class. + /// Platform agnostic Mutex class. class MutexImpl { /// @name Constructors @@ -34,11 +34,11 @@ namespace llvm /// to false, the lock will not be recursive which makes it cheaper but /// also more likely to deadlock (same thread can't acquire more than /// once). - /// @brief Default Constructor. + /// Default Constructor. explicit MutexImpl(bool recursive = true); /// Releases and removes the lock - /// @brief Destructor + /// Destructor ~MutexImpl(); /// @} @@ -49,14 +49,14 @@ namespace llvm /// Attempts to unconditionally acquire the lock. If the lock is held by /// another thread, this method will wait until it can acquire the lock. /// @returns false if any kind of error occurs, true otherwise. - /// @brief Unconditionally acquire the lock. + /// Unconditionally acquire the lock. bool acquire(); /// Attempts to release the lock. If the lock is held by the current /// thread, the lock is released allowing other threads to acquire the /// lock. /// @returns false if any kind of error occurs, true otherwise. - /// @brief Unconditionally release the lock. + /// Unconditionally release the lock. bool release(); /// Attempts to acquire the lock without blocking. If the lock is not @@ -64,7 +64,7 @@ namespace llvm /// the lock is available, it is acquired. /// @returns false if any kind of error occurs or the lock is not /// available, true otherwise. - /// @brief Try to acquire the lock. + /// Try to acquire the lock. bool tryacquire(); //@} diff --git a/llvm/include/llvm/Support/MutexGuard.h b/llvm/include/llvm/Support/MutexGuard.h index 07b64b61196..641d64d9498 100644 --- a/llvm/include/llvm/Support/MutexGuard.h +++ b/llvm/include/llvm/Support/MutexGuard.h @@ -23,7 +23,7 @@ namespace llvm { /// these on the stack at the top of some scope to be assured that C++ /// destruction of the object will always release the Mutex and thus avoid /// a host of nasty multi-threading problems in the face of exceptions, etc. - /// @brief Guard a section of code with a Mutex. + /// Guard a section of code with a Mutex. class MutexGuard { sys::Mutex &M; MutexGuard(const MutexGuard &) = delete; diff --git a/llvm/include/llvm/Support/Path.h b/llvm/include/llvm/Support/Path.h index e5979674cf1..57c33592728 100644 --- a/llvm/include/llvm/Support/Path.h +++ b/llvm/include/llvm/Support/Path.h @@ -30,7 +30,7 @@ enum class Style { windows, posix, native }; /// @name Lexical Component Iterator /// @{ -/// @brief Path iterator. +/// Path iterator. /// /// This is an input iterator that iterates over the individual components in /// \a path. The traversal order is as follows: @@ -66,11 +66,11 @@ public: const_iterator &operator++(); // preincrement bool operator==(const const_iterator &RHS) const; - /// @brief Difference in bytes between this and RHS. + /// Difference in bytes between this and RHS. ptrdiff_t operator-(const const_iterator &RHS) const; }; -/// @brief Reverse path iterator. +/// Reverse path iterator. /// /// This is an input iterator that iterates over the individual components in /// \a path in reverse order. The traversal order is exactly reversed from that @@ -91,26 +91,26 @@ public: reverse_iterator &operator++(); // preincrement bool operator==(const reverse_iterator &RHS) const; - /// @brief Difference in bytes between this and RHS. + /// Difference in bytes between this and RHS. ptrdiff_t operator-(const reverse_iterator &RHS) const; }; -/// @brief Get begin iterator over \a path. +/// Get begin iterator over \a path. /// @param path Input path. /// @returns Iterator initialized with the first component of \a path. const_iterator begin(StringRef path, Style style = Style::native); -/// @brief Get end iterator over \a path. +/// Get end iterator over \a path. /// @param path Input path. /// @returns Iterator initialized to the end of \a path. const_iterator end(StringRef path); -/// @brief Get reverse begin iterator over \a path. +/// Get reverse begin iterator over \a path. /// @param path Input path. /// @returns Iterator initialized with the first reverse component of \a path. reverse_iterator rbegin(StringRef path, Style style = Style::native); -/// @brief Get reverse end iterator over \a path. +/// Get reverse end iterator over \a path. /// @param path Input path. /// @returns Iterator initialized to the reverse end of \a path. reverse_iterator rend(StringRef path); @@ -119,7 +119,7 @@ reverse_iterator rend(StringRef path); /// @name Lexical Modifiers /// @{ -/// @brief Remove the last component from \a path unless it is the root dir. +/// Remove the last component from \a path unless it is the root dir. /// /// @code /// directory/filename.cpp => directory/ @@ -131,7 +131,7 @@ reverse_iterator rend(StringRef path); /// @param path A path that is modified to not have a file component. void remove_filename(SmallVectorImpl<char> &path, Style style = Style::native); -/// @brief Replace the file extension of \a path with \a extension. +/// Replace the file extension of \a path with \a extension. /// /// @code /// ./filename.cpp => ./filename.extension @@ -146,7 +146,7 @@ void remove_filename(SmallVectorImpl<char> &path, Style style = Style::native); void replace_extension(SmallVectorImpl<char> &path, const Twine &extension, Style style = Style::native); -/// @brief Replace matching path prefix with another path. +/// Replace matching path prefix with another path. /// /// @code /// /foo, /old, /new => /foo @@ -163,7 +163,7 @@ void replace_path_prefix(SmallVectorImpl<char> &Path, const StringRef &OldPrefix, const StringRef &NewPrefix, Style style = Style::native); -/// @brief Append to path. +/// Append to path. /// /// @code /// /foo + bar/f => /foo/bar/f @@ -181,7 +181,7 @@ void append(SmallVectorImpl<char> &path, const Twine &a, void append(SmallVectorImpl<char> &path, Style style, const Twine &a, const Twine &b = "", const Twine &c = "", const Twine &d = ""); -/// @brief Append to path. +/// Append to path. /// /// @code /// /foo + [bar,f] => /foo/bar/f @@ -215,7 +215,7 @@ void native(const Twine &path, SmallVectorImpl<char> &result, /// @param path A path that is transformed to native format. void native(SmallVectorImpl<char> &path, Style style = Style::native); -/// @brief Replaces backslashes with slashes if Windows. +/// Replaces backslashes with slashes if Windows. /// /// @param path processed path /// @result The result of replacing backslashes with forward slashes if Windows. @@ -227,7 +227,7 @@ std::string convert_to_slash(StringRef path, Style style = Style::native); /// @name Lexical Observers /// @{ -/// @brief Get root name. +/// Get root name. /// /// @code /// //net/hello => //net @@ -239,7 +239,7 @@ std::string convert_to_slash(StringRef path, Style style = Style::native); /// @result The root name of \a path if it has one, otherwise "". StringRef root_name(StringRef path, Style style = Style::native); -/// @brief Get root directory. +/// Get root directory. /// /// @code /// /goo/hello => / @@ -252,7 +252,7 @@ StringRef root_name(StringRef path, Style style = Style::native); /// "". StringRef root_directory(StringRef path, Style style = Style::native); -/// @brief Get root path. +/// Get root path. /// /// Equivalent to root_name + root_directory. /// @@ -260,7 +260,7 @@ StringRef root_directory(StringRef path, Style style = Style::native); /// @result The root path of \a path if it has one, otherwise "". StringRef root_path(StringRef path, Style style = Style::native); -/// @brief Get relative path. +/// Get relative path. /// /// @code /// C:\hello\world => hello\world @@ -272,7 +272,7 @@ StringRef root_path(StringRef path, Style style = Style::native); /// @result The path starting after root_path if one exists, otherwise "". StringRef relative_path(StringRef path, Style style = Style::native); -/// @brief Get parent path. +/// Get parent path. /// /// @code /// / => <empty> @@ -284,7 +284,7 @@ StringRef relative_path(StringRef path, Style style = Style::native); /// @result The parent path of \a path if one exists, otherwise "". StringRef parent_path(StringRef path, Style style = Style::native); -/// @brief Get filename. +/// Get filename. /// /// @code /// /foo.txt => foo.txt @@ -298,7 +298,7 @@ StringRef parent_path(StringRef path, Style style = Style::native); /// of \a path. StringRef filename(StringRef path, Style style = Style::native); -/// @brief Get stem. +/// Get stem. /// /// If filename contains a dot but not solely one or two dots, result is the /// substring of filename ending at (but not including) the last dot. Otherwise @@ -316,7 +316,7 @@ StringRef filename(StringRef path, Style style = Style::native); /// @result The stem of \a path. StringRef stem(StringRef path, Style style = Style::native); -/// @brief Get extension. +/// Get extension. /// /// If filename contains a dot but not solely one or two dots, result is the /// substring of filename starting at (and including) the last dot, and ending @@ -332,18 +332,18 @@ StringRef stem(StringRef path, Style style = Style::native); /// @result The extension of \a path. StringRef extension(StringRef path, Style style = Style::native); -/// @brief Check whether the given char is a path separator on the host OS. +/// Check whether the given char is a path separator on the host OS. /// /// @param value a character /// @result true if \a value is a path separator character on the host OS bool is_separator(char value, Style style = Style::native); -/// @brief Return the preferred separator for this platform. +/// Return the preferred separator for this platform. /// /// @result StringRef of the preferred separator, null-terminated. StringRef get_separator(Style style = Style::native); -/// @brief Get the typical temporary directory for the system, e.g., +/// Get the typical temporary directory for the system, e.g., /// "/var/tmp" or "C:/TEMP" /// /// @param erasedOnReboot Whether to favor a path that is erased on reboot @@ -354,13 +354,13 @@ StringRef get_separator(Style style = Style::native); /// @param result Holds the resulting path name. void system_temp_directory(bool erasedOnReboot, SmallVectorImpl<char> &result); -/// @brief Get the user's home directory. +/// Get the user's home directory. /// /// @param result Holds the resulting path name. /// @result True if a home directory is set, false otherwise. bool home_directory(SmallVectorImpl<char> &result); -/// @brief Get the user's cache directory. +/// Get the user's cache directory. /// /// Expect the resulting path to be a directory shared with other /// applications/services used by the user. Params \p Path1 to \p Path3 can be @@ -376,7 +376,7 @@ bool home_directory(SmallVectorImpl<char> &result); bool user_cache_directory(SmallVectorImpl<char> &Result, const Twine &Path1, const Twine &Path2 = "", const Twine &Path3 = ""); -/// @brief Has root name? +/// Has root name? /// /// root_name != "" /// @@ -384,7 +384,7 @@ bool user_cache_directory(SmallVectorImpl<char> &Result, const Twine &Path1, /// @result True if the path has a root name, false otherwise. bool has_root_name(const Twine &path, Style style = Style::native); -/// @brief Has root directory? +/// Has root directory? /// /// root_directory != "" /// @@ -392,7 +392,7 @@ bool has_root_name(const Twine &path, Style style = Style::native); /// @result True if the path has a root directory, false otherwise. bool has_root_directory(const Twine &path, Style style = Style::native); -/// @brief Has root path? +/// Has root path? /// /// root_path != "" /// @@ -400,7 +400,7 @@ bool has_root_directory(const Twine &path, Style style = Style::native); /// @result True if the path has a root path, false otherwise. bool has_root_path(const Twine &path, Style style = Style::native); -/// @brief Has relative path? +/// Has relative path? /// /// relative_path != "" /// @@ -408,7 +408,7 @@ bool has_root_path(const Twine &path, Style style = Style::native); /// @result True if the path has a relative path, false otherwise. bool has_relative_path(const Twine &path, Style style = Style::native); -/// @brief Has parent path? +/// Has parent path? /// /// parent_path != "" /// @@ -416,7 +416,7 @@ bool has_relative_path(const Twine &path, Style style = Style::native); /// @result True if the path has a parent path, false otherwise. bool has_parent_path(const Twine &path, Style style = Style::native); -/// @brief Has filename? +/// Has filename? /// /// filename != "" /// @@ -424,7 +424,7 @@ bool has_parent_path(const Twine &path, Style style = Style::native); /// @result True if the path has a filename, false otherwise. bool has_filename(const Twine &path, Style style = Style::native); -/// @brief Has stem? +/// Has stem? /// /// stem != "" /// @@ -432,7 +432,7 @@ bool has_filename(const Twine &path, Style style = Style::native); /// @result True if the path has a stem, false otherwise. bool has_stem(const Twine &path, Style style = Style::native); -/// @brief Has extension? +/// Has extension? /// /// extension != "" /// @@ -440,25 +440,25 @@ bool has_stem(const Twine &path, Style style = Style::native); /// @result True if the path has a extension, false otherwise. bool has_extension(const Twine &path, Style style = Style::native); -/// @brief Is path absolute? +/// Is path absolute? /// /// @param path Input path. /// @result True if the path is absolute, false if it is not. bool is_absolute(const Twine &path, Style style = Style::native); -/// @brief Is path relative? +/// Is path relative? /// /// @param path Input path. /// @result True if the path is relative, false if it is not. bool is_relative(const Twine &path, Style style = Style::native); -/// @brief Remove redundant leading "./" pieces and consecutive separators. +/// Remove redundant leading "./" pieces and consecutive separators. /// /// @param path Input path. /// @result The cleaned-up \a path. StringRef remove_leading_dotslash(StringRef path, Style style = Style::native); -/// @brief In-place remove any './' and optionally '../' components from a path. +/// In-place remove any './' and optionally '../' components from a path. /// /// @param path processed path /// @param remove_dot_dot specify if '../' (except for leading "../") should be diff --git a/llvm/include/llvm/Support/Process.h b/llvm/include/llvm/Support/Process.h index 1ac9eb3521e..f9f1cac8627 100644 --- a/llvm/include/llvm/Support/Process.h +++ b/llvm/include/llvm/Support/Process.h @@ -66,7 +66,7 @@ public: /// This function makes the necessary calls to the operating system to /// prevent core files or any other kind of large memory dumps that can /// occur when a program fails. - /// @brief Prevent core file generation. + /// Prevent core file generation. static void PreventCoreFiles(); /// true if PreventCoreFiles has been called, false otherwise. diff --git a/llvm/include/llvm/Support/Program.h b/llvm/include/llvm/Support/Program.h index 2cf867453cd..8f8a6a6f29b 100644 --- a/llvm/include/llvm/Support/Program.h +++ b/llvm/include/llvm/Support/Program.h @@ -32,7 +32,7 @@ namespace sys { const char EnvPathSeparator = ';'; #endif -/// @brief This struct encapsulates information about a process. +/// This struct encapsulates information about a process. struct ProcessInfo { #if defined(LLVM_ON_UNIX) typedef pid_t ProcessId; diff --git a/llvm/include/llvm/Support/RWMutex.h b/llvm/include/llvm/Support/RWMutex.h index 85f4fc09fb8..5ac3e558999 100644 --- a/llvm/include/llvm/Support/RWMutex.h +++ b/llvm/include/llvm/Support/RWMutex.h @@ -21,7 +21,7 @@ namespace llvm { namespace sys { - /// @brief Platform agnostic RWMutex class. + /// Platform agnostic RWMutex class. class RWMutexImpl { /// @name Constructors @@ -29,7 +29,7 @@ namespace sys { public: /// Initializes the lock but doesn't acquire it. - /// @brief Default Constructor. + /// Default Constructor. explicit RWMutexImpl(); /// @} @@ -40,7 +40,7 @@ namespace sys { /// @} /// Releases and removes the lock - /// @brief Destructor + /// Destructor ~RWMutexImpl(); /// @} @@ -52,24 +52,24 @@ namespace sys { /// lock is held by a writer, this method will wait until it can acquire /// the lock. /// @returns false if any kind of error occurs, true otherwise. - /// @brief Unconditionally acquire the lock in reader mode. + /// Unconditionally acquire the lock in reader mode. bool reader_acquire(); /// Attempts to release the lock in reader mode. /// @returns false if any kind of error occurs, true otherwise. - /// @brief Unconditionally release the lock in reader mode. + /// Unconditionally release the lock in reader mode. bool reader_release(); /// Attempts to unconditionally acquire the lock in reader mode. If the /// lock is held by any readers, this method will wait until it can /// acquire the lock. /// @returns false if any kind of error occurs, true otherwise. - /// @brief Unconditionally acquire the lock in writer mode. + /// Unconditionally acquire the lock in writer mode. bool writer_acquire(); /// Attempts to release the lock in writer mode. /// @returns false if any kind of error occurs, true otherwise. - /// @brief Unconditionally release the lock in write mode. + /// Unconditionally release the lock in write mode. bool writer_release(); //@} diff --git a/llvm/include/llvm/Support/Signals.h b/llvm/include/llvm/Support/Signals.h index 0f1f980d994..6a1ec7bac7e 100644 --- a/llvm/include/llvm/Support/Signals.h +++ b/llvm/include/llvm/Support/Signals.h @@ -29,7 +29,7 @@ namespace sys { /// This function registers signal handlers to ensure that if a signal gets /// delivered that the named file is removed. - /// @brief Remove a file if a fatal signal occurs. + /// Remove a file if a fatal signal occurs. bool RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg = nullptr); /// This function removes a file from the list of files to be removed on @@ -69,7 +69,7 @@ namespace sys { /// functions. An null interrupt function pointer disables the current /// installed function. Note also that the handler may be executed on a /// different thread on some platforms. - /// @brief Register a function to be called when ctrl-c is pressed. + /// Register a function to be called when ctrl-c is pressed. void SetInterruptFunction(void (*IF)()); } // End sys namespace } // End llvm namespace diff --git a/llvm/include/llvm/Support/SystemUtils.h b/llvm/include/llvm/Support/SystemUtils.h index 2997b1b0c9c..bd60793d155 100644 --- a/llvm/include/llvm/Support/SystemUtils.h +++ b/llvm/include/llvm/Support/SystemUtils.h @@ -21,7 +21,7 @@ namespace llvm { /// Determine if the raw_ostream provided is connected to a terminal. If so, /// generate a warning message to errs() advising against display of bitcode /// and return true. Otherwise just return false. -/// @brief Check for output written to a console +/// Check for output written to a console bool CheckBitcodeOutputToConsole( raw_ostream &stream_to_check, ///< The stream to be checked bool print_warning = true ///< Control whether warnings are printed diff --git a/llvm/include/llvm/Support/UniqueLock.h b/llvm/include/llvm/Support/UniqueLock.h index b4675f4b43a..91dc911036d 100644 --- a/llvm/include/llvm/Support/UniqueLock.h +++ b/llvm/include/llvm/Support/UniqueLock.h @@ -24,7 +24,7 @@ namespace llvm { /// an associated mutex, which is guaranteed to be locked upon creation /// and unlocked after destruction. unique_lock can also unlock the mutex /// and re-lock it freely during its lifetime. - /// @brief Guard a section of code with a mutex. + /// Guard a section of code with a mutex. template<typename MutexT> class unique_lock { MutexT *M = nullptr; diff --git a/llvm/include/llvm/Transforms/Utils/IntegerDivision.h b/llvm/include/llvm/Transforms/Utils/IntegerDivision.h index 0ec3321b9cf..5d9927eb51b 100644 --- a/llvm/include/llvm/Transforms/Utils/IntegerDivision.h +++ b/llvm/include/llvm/Transforms/Utils/IntegerDivision.h @@ -29,7 +29,7 @@ namespace llvm { /// e.g. when more information about the operands are known. Implements both /// 32bit and 64bit scalar division. /// - /// @brief Replace Rem with generated code. + /// Replace Rem with generated code. bool expandRemainder(BinaryOperator *Rem); /// Generate code to divide two integers, replacing Div with the generated @@ -38,7 +38,7 @@ namespace llvm { /// when more information about the operands are known. Implements both /// 32bit and 64bit scalar division. /// - /// @brief Replace Div with generated code. + /// Replace Div with generated code. bool expandDivision(BinaryOperator* Div); /// Generate code to calculate the remainder of two integers, replacing Rem @@ -46,26 +46,26 @@ namespace llvm { /// makes it useful for targets with little or no support for less than /// 32 bit arithmetic. /// - /// @brief Replace Rem with generated code. + /// Replace Rem with generated code. bool expandRemainderUpTo32Bits(BinaryOperator *Rem); /// Generate code to calculate the remainder of two integers, replacing Rem /// with the generated code. Uses ExpandReminder with a 64bit Rem. /// - /// @brief Replace Rem with generated code. + /// Replace Rem with generated code. bool expandRemainderUpTo64Bits(BinaryOperator *Rem); /// Generate code to divide two integers, replacing Div with the generated /// code. Uses ExpandDivision with a 32bit Div which makes it useful for /// targets with little or no support for less than 32 bit arithmetic. /// - /// @brief Replace Rem with generated code. + /// Replace Rem with generated code. bool expandDivisionUpTo32Bits(BinaryOperator *Div); /// Generate code to divide two integers, replacing Div with the generated /// code. Uses ExpandDivision with a 64bit Div. /// - /// @brief Replace Rem with generated code. + /// Replace Rem with generated code. bool expandDivisionUpTo64Bits(BinaryOperator *Div); } // End llvm namespace diff --git a/llvm/include/llvm/Transforms/Vectorize.h b/llvm/include/llvm/Transforms/Vectorize.h index 19845e471e4..950af7ffe05 100644 --- a/llvm/include/llvm/Transforms/Vectorize.h +++ b/llvm/include/llvm/Transforms/Vectorize.h @@ -21,88 +21,88 @@ class BasicBlockPass; class Pass; //===----------------------------------------------------------------------===// -/// @brief Vectorize configuration. +/// Vectorize configuration. struct VectorizeConfig { //===--------------------------------------------------------------------===// // Target architecture related parameters - /// @brief The size of the native vector registers. + /// The size of the native vector registers. unsigned VectorBits; - /// @brief Vectorize boolean values. + /// Vectorize boolean values. bool VectorizeBools; - /// @brief Vectorize integer values. + /// Vectorize integer values. bool VectorizeInts; - /// @brief Vectorize floating-point values. + /// Vectorize floating-point values. bool VectorizeFloats; - /// @brief Vectorize pointer values. + /// Vectorize pointer values. bool VectorizePointers; - /// @brief Vectorize casting (conversion) operations. + /// Vectorize casting (conversion) operations. bool VectorizeCasts; - /// @brief Vectorize floating-point math intrinsics. + /// Vectorize floating-point math intrinsics. bool VectorizeMath; - /// @brief Vectorize bit intrinsics. + /// Vectorize bit intrinsics. bool VectorizeBitManipulations; - /// @brief Vectorize the fused-multiply-add intrinsic. + /// Vectorize the fused-multiply-add intrinsic. bool VectorizeFMA; - /// @brief Vectorize select instructions. + /// Vectorize select instructions. bool VectorizeSelect; - /// @brief Vectorize comparison instructions. + /// Vectorize comparison instructions. bool VectorizeCmp; - /// @brief Vectorize getelementptr instructions. + /// Vectorize getelementptr instructions. bool VectorizeGEP; - /// @brief Vectorize loads and stores. + /// Vectorize loads and stores. bool VectorizeMemOps; - /// @brief Only generate aligned loads and stores. + /// Only generate aligned loads and stores. bool AlignedOnly; //===--------------------------------------------------------------------===// // Misc parameters - /// @brief The required chain depth for vectorization. + /// The required chain depth for vectorization. unsigned ReqChainDepth; - /// @brief The maximum search distance for instruction pairs. + /// The maximum search distance for instruction pairs. unsigned SearchLimit; - /// @brief The maximum number of candidate pairs with which to use a full + /// The maximum number of candidate pairs with which to use a full /// cycle check. unsigned MaxCandPairsForCycleCheck; - /// @brief Replicating one element to a pair breaks the chain. + /// Replicating one element to a pair breaks the chain. bool SplatBreaksChain; - /// @brief The maximum number of pairable instructions per group. + /// The maximum number of pairable instructions per group. unsigned MaxInsts; - /// @brief The maximum number of candidate instruction pairs per group. + /// The maximum number of candidate instruction pairs per group. unsigned MaxPairs; - /// @brief The maximum number of pairing iterations. + /// The maximum number of pairing iterations. unsigned MaxIter; - /// @brief Don't try to form odd-length vectors. + /// Don't try to form odd-length vectors. bool Pow2LenOnly; - /// @brief Don't boost the chain-depth contribution of loads and stores. + /// Don't boost the chain-depth contribution of loads and stores. bool NoMemOpBoost; - /// @brief Use a fast instruction dependency analysis. + /// Use a fast instruction dependency analysis. bool FastDep; - /// @brief Initialize the VectorizeConfig from command line options. + /// Initialize the VectorizeConfig from command line options. VectorizeConfig(); }; @@ -120,7 +120,7 @@ Pass *createLoopVectorizePass(bool NoUnrolling = false, Pass *createSLPVectorizerPass(); //===----------------------------------------------------------------------===// -/// @brief Vectorize the BasicBlock. +/// Vectorize the BasicBlock. /// /// @param BB The BasicBlock to be vectorized /// @param P The current running pass, should require AliasAnalysis and diff --git a/llvm/lib/BinaryFormat/Magic.cpp b/llvm/lib/BinaryFormat/Magic.cpp index afc217c6a51..5a339583fca 100644 --- a/llvm/lib/BinaryFormat/Magic.cpp +++ b/llvm/lib/BinaryFormat/Magic.cpp @@ -31,7 +31,7 @@ static bool startswith(StringRef Magic, const char (&S)[N]) { return Magic.startswith(StringRef(S, N - 1)); } -/// @brief Identify the magic in magic. +/// Identify the magic in magic. file_magic llvm::identify_magic(StringRef Magic) { if (Magic.size() < 4) return file_magic::unknown; diff --git a/llvm/lib/CodeGen/RegAllocPBQP.cpp b/llvm/lib/CodeGen/RegAllocPBQP.cpp index 7ce4438e613..879330a0b4d 100644 --- a/llvm/lib/CodeGen/RegAllocPBQP.cpp +++ b/llvm/lib/CodeGen/RegAllocPBQP.cpp @@ -188,7 +188,7 @@ private: char RegAllocPBQP::ID = 0; -/// @brief Set spill costs for each node in the PBQP reg-alloc graph. +/// Set spill costs for each node in the PBQP reg-alloc graph. class SpillCosts : public PBQPRAConstraint { public: void apply(PBQPRAGraph &G) override { @@ -212,7 +212,7 @@ public: } }; -/// @brief Add interference edges between overlapping vregs. +/// Add interference edges between overlapping vregs. class Interference : public PBQPRAConstraint { private: using AllowedRegVecPtr = const PBQP::RegAlloc::AllowedRegVector *; diff --git a/llvm/lib/ExecutionEngine/Orc/Core.cpp b/llvm/lib/ExecutionEngine/Orc/Core.cpp index 602edb02859..b2b53471ee1 100644 --- a/llvm/lib/ExecutionEngine/Orc/Core.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Core.cpp @@ -708,7 +708,7 @@ Expected<SymbolMap> lookup(const std::vector<VSO *> &VSOs, SymbolNameSet Names, #endif } -/// @brief Look up a symbol by searching a list of VSOs. +/// Look up a symbol by searching a list of VSOs. Expected<JITEvaluatedSymbol> lookup(const std::vector<VSO *> VSOs, SymbolStringPtr Name, MaterializationDispatcher DispatchMaterialization) { diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp index 2b3c00fd7d7..18eb0e46192 100644 --- a/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp +++ b/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp @@ -48,7 +48,7 @@ ARMJITSymbolFlags llvm::ARMJITSymbolFlags::fromObjectSymbol( return Flags; } -/// @brief Performs lookup by, for each symbol, first calling +/// Performs lookup by, for each symbol, first calling /// findSymbolInLogicalDylib and if that fails calling /// findSymbol. Expected<JITSymbolResolver::LookupResult> @@ -81,7 +81,7 @@ LegacyJITSymbolResolver::lookup(const LookupSet &Symbols) { return std::move(Result); } -/// @brief Performs flags lookup by calling findSymbolInLogicalDylib and +/// Performs flags lookup by calling findSymbolInLogicalDylib and /// returning the flags value for that symbol. Expected<JITSymbolResolver::LookupFlagsResult> LegacyJITSymbolResolver::lookupFlags(const LookupSet &Symbols) { diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h index 0e27e51c93e..4d7cc36d066 100644 --- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h +++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h @@ -217,7 +217,7 @@ public: } }; -/// @brief Symbol info for RuntimeDyld. +/// Symbol info for RuntimeDyld. class SymbolTableEntry { public: SymbolTableEntry() = default; diff --git a/llvm/lib/IR/ConstantFold.cpp b/llvm/lib/IR/ConstantFold.cpp index 3859dfbbd3f..2404ce4115e 100644 --- a/llvm/lib/IR/ConstantFold.cpp +++ b/llvm/lib/IR/ConstantFold.cpp @@ -71,7 +71,7 @@ static Constant *BitCastConstantVector(Constant *CV, VectorType *DstTy) { /// This function determines which opcode to use to fold two constant cast /// expressions together. It uses CastInst::isEliminableCastPair to determine /// the opcode. Consequently its just a wrapper around that function. -/// @brief Determine if it is valid to fold a cast of a cast +/// Determine if it is valid to fold a cast of a cast static unsigned foldConstantCastPair( unsigned opc, ///< opcode of the second cast constant expression diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index 21a0042d26e..e486890e616 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -2081,7 +2081,7 @@ bool CastInst::isLosslessCast() const { /// # bitcast i32* %x to i8* /// # bitcast <2 x i32> %x to <4 x i16> /// # ptrtoint i32* %x to i32 ; on 32-bit plaforms only -/// @brief Determine if the described cast is a no-op. +/// Determine if the described cast is a no-op. bool CastInst::isNoopCast(Instruction::CastOps Opcode, Type *SrcTy, Type *DestTy, @@ -2449,7 +2449,7 @@ CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertAtEnd); } -/// @brief Create a BitCast or a PtrToInt cast instruction +/// Create a BitCast or a PtrToInt cast instruction CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore) { diff --git a/llvm/lib/Support/APInt.cpp b/llvm/lib/Support/APInt.cpp index a09ace5a1e2..98e44d24966 100644 --- a/llvm/lib/Support/APInt.cpp +++ b/llvm/lib/Support/APInt.cpp @@ -168,7 +168,7 @@ void APInt::Profile(FoldingSetNodeID& ID) const { ID.AddInteger(U.pVal[i]); } -/// @brief Prefix increment operator. Increments the APInt by one. +/// Prefix increment operator. Increments the APInt by one. APInt& APInt::operator++() { if (isSingleWord()) ++U.VAL; @@ -177,7 +177,7 @@ APInt& APInt::operator++() { return clearUnusedBits(); } -/// @brief Prefix decrement operator. Decrements the APInt by one. +/// Prefix decrement operator. Decrements the APInt by one. APInt& APInt::operator--() { if (isSingleWord()) --U.VAL; @@ -188,7 +188,7 @@ APInt& APInt::operator--() { /// Adds the RHS APint to this APInt. /// @returns this, after addition of RHS. -/// @brief Addition assignment operator. +/// Addition assignment operator. APInt& APInt::operator+=(const APInt& RHS) { assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); if (isSingleWord()) @@ -208,7 +208,7 @@ APInt& APInt::operator+=(uint64_t RHS) { /// Subtracts the RHS APInt from this APInt /// @returns this, after subtraction -/// @brief Subtraction assignment operator. +/// Subtraction assignment operator. APInt& APInt::operator-=(const APInt& RHS) { assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); if (isSingleWord()) @@ -326,7 +326,7 @@ void APInt::setBitsSlowCase(unsigned loBit, unsigned hiBit) { U.pVal[word] = WORD_MAX; } -/// @brief Toggle every bit to its opposite value. +/// Toggle every bit to its opposite value. void APInt::flipAllBitsSlowCase() { tcComplement(U.pVal, getNumWords()); clearUnusedBits(); @@ -334,7 +334,7 @@ void APInt::flipAllBitsSlowCase() { /// Toggle a given bit to its opposite value whose position is given /// as "bitPosition". -/// @brief Toggles a given bit to its opposite value. +/// Toggles a given bit to its opposite value. void APInt::flipBit(unsigned bitPosition) { assert(bitPosition < BitWidth && "Out of the bit-width range!"); if ((*this)[bitPosition]) clearBit(bitPosition); @@ -908,13 +908,13 @@ APInt APInt::sextOrSelf(unsigned width) const { } /// Arithmetic right-shift this APInt by shiftAmt. -/// @brief Arithmetic right-shift function. +/// Arithmetic right-shift function. void APInt::ashrInPlace(const APInt &shiftAmt) { ashrInPlace((unsigned)shiftAmt.getLimitedValue(BitWidth)); } /// Arithmetic right-shift this APInt by shiftAmt. -/// @brief Arithmetic right-shift function. +/// Arithmetic right-shift function. void APInt::ashrSlowCase(unsigned ShiftAmt) { // Don't bother performing a no-op shift. if (!ShiftAmt) @@ -957,19 +957,19 @@ void APInt::ashrSlowCase(unsigned ShiftAmt) { } /// Logical right-shift this APInt by shiftAmt. -/// @brief Logical right-shift function. +/// Logical right-shift function. void APInt::lshrInPlace(const APInt &shiftAmt) { lshrInPlace((unsigned)shiftAmt.getLimitedValue(BitWidth)); } /// Logical right-shift this APInt by shiftAmt. -/// @brief Logical right-shift function. +/// Logical right-shift function. void APInt::lshrSlowCase(unsigned ShiftAmt) { tcShiftRight(U.pVal, getNumWords(), ShiftAmt); } /// Left-shift this APInt by shiftAmt. -/// @brief Left-shift function. +/// Left-shift function. APInt &APInt::operator<<=(const APInt &shiftAmt) { // It's undefined behavior in C to shift by BitWidth or greater. *this <<= (unsigned)shiftAmt.getLimitedValue(BitWidth); diff --git a/llvm/lib/Support/Unix/Unix.h b/llvm/lib/Support/Unix/Unix.h index 239a6d60aae..0c5d4de556d 100644 --- a/llvm/lib/Support/Unix/Unix.h +++ b/llvm/lib/Support/Unix/Unix.h @@ -56,7 +56,7 @@ /// This function builds an error message into \p ErrMsg using the \p prefix /// string and the Unix error number given by \p errnum. If errnum is -1, the /// default then the value of errno is used. -/// @brief Make an error message +/// Make an error message /// /// If the error number can be converted to a string, it will be /// separated from prefix by ": ". diff --git a/llvm/lib/Support/YAMLParser.cpp b/llvm/lib/Support/YAMLParser.cpp index 3f71ab8fc6f..354b7d0740d 100644 --- a/llvm/lib/Support/YAMLParser.cpp +++ b/llvm/lib/Support/YAMLParser.cpp @@ -168,7 +168,7 @@ using TokenQueueT = BumpPtrList<Token>; namespace { -/// @brief This struct is used to track simple keys. +/// This struct is used to track simple keys. /// /// Simple keys are handled by creating an entry in SimpleKeys for each Token /// which could legally be the start of a simple key. When peekNext is called, @@ -191,7 +191,7 @@ struct SimpleKey { } // end anonymous namespace -/// @brief The Unicode scalar value of a UTF-8 minimal well-formed code unit +/// The Unicode scalar value of a UTF-8 minimal well-formed code unit /// subsequence and the subsequence's length in code units (uint8_t). /// A length of 0 represents an error. using UTF8Decoded = std::pair<uint32_t, unsigned>; @@ -249,7 +249,7 @@ static UTF8Decoded decodeUTF8(StringRef Range) { namespace llvm { namespace yaml { -/// @brief Scans YAML tokens from a MemoryBuffer. +/// Scans YAML tokens from a MemoryBuffer. class Scanner { public: Scanner(StringRef Input, SourceMgr &SM, bool ShowColors = true, @@ -257,10 +257,10 @@ public: Scanner(MemoryBufferRef Buffer, SourceMgr &SM_, bool ShowColors = true, std::error_code *EC = nullptr); - /// @brief Parse the next token and return it without popping it. + /// Parse the next token and return it without popping it. Token &peekNext(); - /// @brief Parse the next token and pop it from the queue. + /// Parse the next token and pop it from the queue. Token getNext(); void printError(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Message, @@ -287,7 +287,7 @@ public: setError(Message, Current); } - /// @brief Returns true if an error occurred while parsing. + /// Returns true if an error occurred while parsing. bool failed() { return Failed; } @@ -299,7 +299,7 @@ private: return StringRef(Current, End - Current); } - /// @brief Decode a UTF-8 minimal well-formed code unit subsequence starting + /// Decode a UTF-8 minimal well-formed code unit subsequence starting /// at \a Position. /// /// If the UTF-8 code units starting at Position do not form a well-formed @@ -329,7 +329,7 @@ private: // l- // A production matching complete line(s). - /// @brief Skip a single nb-char[27] starting at Position. + /// Skip a single nb-char[27] starting at Position. /// /// A nb-char is 0x9 | [0x20-0x7E] | 0x85 | [0xA0-0xD7FF] | [0xE000-0xFEFE] /// | [0xFF00-0xFFFD] | [0x10000-0x10FFFF] @@ -338,7 +338,7 @@ private: /// nb-char. StringRef::iterator skip_nb_char(StringRef::iterator Position); - /// @brief Skip a single b-break[28] starting at Position. + /// Skip a single b-break[28] starting at Position. /// /// A b-break is 0xD 0xA | 0xD | 0xA /// @@ -354,7 +354,7 @@ private: /// s-space. StringRef::iterator skip_s_space(StringRef::iterator Position); - /// @brief Skip a single s-white[33] starting at Position. + /// Skip a single s-white[33] starting at Position. /// /// A s-white is 0x20 | 0x9 /// @@ -362,7 +362,7 @@ private: /// s-white. StringRef::iterator skip_s_white(StringRef::iterator Position); - /// @brief Skip a single ns-char[34] starting at Position. + /// Skip a single ns-char[34] starting at Position. /// /// A ns-char is nb-char - s-white /// @@ -372,7 +372,7 @@ private: using SkipWhileFunc = StringRef::iterator (Scanner::*)(StringRef::iterator); - /// @brief Skip minimal well-formed code unit subsequences until Func + /// Skip minimal well-formed code unit subsequences until Func /// returns its input. /// /// @returns The code unit after the last minimal well-formed code unit @@ -384,20 +384,20 @@ private: /// input. void advanceWhile(SkipWhileFunc Func); - /// @brief Scan ns-uri-char[39]s starting at Cur. + /// Scan ns-uri-char[39]s starting at Cur. /// /// This updates Cur and Column while scanning. void scan_ns_uri_char(); - /// @brief Consume a minimal well-formed code unit subsequence starting at + /// Consume a minimal well-formed code unit subsequence starting at /// \a Cur. Return false if it is not the same Unicode scalar value as /// \a Expected. This updates \a Column. bool consume(uint32_t Expected); - /// @brief Skip \a Distance UTF-8 code units. Updates \a Cur and \a Column. + /// Skip \a Distance UTF-8 code units. Updates \a Cur and \a Column. void skip(uint32_t Distance); - /// @brief Return true if the minimal well-formed code unit subsequence at + /// Return true if the minimal well-formed code unit subsequence at /// Pos is whitespace or a new line bool isBlankOrBreak(StringRef::iterator Position); @@ -406,77 +406,77 @@ private: /// Return false if the code unit at the current position isn't a line break. bool consumeLineBreakIfPresent(); - /// @brief If IsSimpleKeyAllowed, create and push_back a new SimpleKey. + /// If IsSimpleKeyAllowed, create and push_back a new SimpleKey. void saveSimpleKeyCandidate( TokenQueueT::iterator Tok , unsigned AtColumn , bool IsRequired); - /// @brief Remove simple keys that can no longer be valid simple keys. + /// Remove simple keys that can no longer be valid simple keys. /// /// Invalid simple keys are not on the current line or are further than 1024 /// columns back. void removeStaleSimpleKeyCandidates(); - /// @brief Remove all simple keys on FlowLevel \a Level. + /// Remove all simple keys on FlowLevel \a Level. void removeSimpleKeyCandidatesOnFlowLevel(unsigned Level); - /// @brief Unroll indentation in \a Indents back to \a Col. Creates BlockEnd + /// Unroll indentation in \a Indents back to \a Col. Creates BlockEnd /// tokens if needed. bool unrollIndent(int ToColumn); - /// @brief Increase indent to \a Col. Creates \a Kind token at \a InsertPoint + /// Increase indent to \a Col. Creates \a Kind token at \a InsertPoint /// if needed. bool rollIndent( int ToColumn , Token::TokenKind Kind , TokenQueueT::iterator InsertPoint); - /// @brief Skip a single-line comment when the comment starts at the current + /// Skip a single-line comment when the comment starts at the current /// position of the scanner. void skipComment(); - /// @brief Skip whitespace and comments until the start of the next token. + /// Skip whitespace and comments until the start of the next token. void scanToNextToken(); - /// @brief Must be the first token generated. + /// Must be the first token generated. bool scanStreamStart(); - /// @brief Generate tokens needed to close out the stream. + /// Generate tokens needed to close out the stream. bool scanStreamEnd(); - /// @brief Scan a %BLAH directive. + /// Scan a %BLAH directive. bool scanDirective(); - /// @brief Scan a ... or ---. + /// Scan a ... or ---. bool scanDocumentIndicator(bool IsStart); - /// @brief Scan a [ or { and generate the proper flow collection start token. + /// Scan a [ or { and generate the proper flow collection start token. bool scanFlowCollectionStart(bool IsSequence); - /// @brief Scan a ] or } and generate the proper flow collection end token. + /// Scan a ] or } and generate the proper flow collection end token. bool scanFlowCollectionEnd(bool IsSequence); - /// @brief Scan the , that separates entries in a flow collection. + /// Scan the , that separates entries in a flow collection. bool scanFlowEntry(); - /// @brief Scan the - that starts block sequence entries. + /// Scan the - that starts block sequence entries. bool scanBlockEntry(); - /// @brief Scan an explicit ? indicating a key. + /// Scan an explicit ? indicating a key. bool scanKey(); - /// @brief Scan an explicit : indicating a value. + /// Scan an explicit : indicating a value. bool scanValue(); - /// @brief Scan a quoted scalar. + /// Scan a quoted scalar. bool scanFlowScalar(bool IsDoubleQuoted); - /// @brief Scan an unquoted scalar. + /// Scan an unquoted scalar. bool scanPlainScalar(); - /// @brief Scan an Alias or Anchor starting with * or &. + /// Scan an Alias or Anchor starting with * or &. bool scanAliasOrAnchor(bool IsAlias); - /// @brief Scan a block scalar starting with | or >. + /// Scan a block scalar starting with | or >. bool scanBlockScalar(bool IsLiteral); /// Scan a chomping indicator in a block scalar header. @@ -503,57 +503,57 @@ private: bool scanBlockScalarIndent(unsigned BlockIndent, unsigned BlockExitIndent, bool &IsDone); - /// @brief Scan a tag of the form !stuff. + /// Scan a tag of the form !stuff. bool scanTag(); - /// @brief Dispatch to the next scanning function based on \a *Cur. + /// Dispatch to the next scanning function based on \a *Cur. bool fetchMoreTokens(); - /// @brief The SourceMgr used for diagnostics and buffer management. + /// The SourceMgr used for diagnostics and buffer management. SourceMgr &SM; - /// @brief The original input. + /// The original input. MemoryBufferRef InputBuffer; - /// @brief The current position of the scanner. + /// The current position of the scanner. StringRef::iterator Current; - /// @brief The end of the input (one past the last character). + /// The end of the input (one past the last character). StringRef::iterator End; - /// @brief Current YAML indentation level in spaces. + /// Current YAML indentation level in spaces. int Indent; - /// @brief Current column number in Unicode code points. + /// Current column number in Unicode code points. unsigned Column; - /// @brief Current line number. + /// Current line number. unsigned Line; - /// @brief How deep we are in flow style containers. 0 Means at block level. + /// How deep we are in flow style containers. 0 Means at block level. unsigned FlowLevel; - /// @brief Are we at the start of the stream? + /// Are we at the start of the stream? bool IsStartOfStream; - /// @brief Can the next token be the start of a simple key? + /// Can the next token be the start of a simple key? bool IsSimpleKeyAllowed; - /// @brief True if an error has occurred. + /// True if an error has occurred. bool Failed; - /// @brief Should colors be used when printing out the diagnostic messages? + /// Should colors be used when printing out the diagnostic messages? bool ShowColors; - /// @brief Queue of tokens. This is required to queue up tokens while looking + /// Queue of tokens. This is required to queue up tokens while looking /// for the end of a simple key. And for cases where a single character /// can produce multiple tokens (e.g. BlockEnd). TokenQueueT TokenQueue; - /// @brief Indentation levels. + /// Indentation levels. SmallVector<int, 4> Indents; - /// @brief Potential simple keys. + /// Potential simple keys. SmallVector<SimpleKey, 4> SimpleKeys; std::error_code *EC; diff --git a/llvm/lib/Target/AMDGPU/AMDKernelCodeT.h b/llvm/lib/Target/AMDGPU/AMDKernelCodeT.h index df70a9f8bba..289642aaa2d 100644 --- a/llvm/lib/Target/AMDGPU/AMDKernelCodeT.h +++ b/llvm/lib/Target/AMDGPU/AMDKernelCodeT.h @@ -198,7 +198,7 @@ enum amd_code_property_mask_t { AMD_CODE_PROPERTY_RESERVED2 = ((1 << AMD_CODE_PROPERTY_RESERVED2_WIDTH) - 1) << AMD_CODE_PROPERTY_RESERVED2_SHIFT }; -/// @brief The hsa_ext_control_directives_t specifies the values for the HSAIL +/// The hsa_ext_control_directives_t specifies the values for the HSAIL /// control directives. These control how the finalizer generates code. This /// struct is used both as an argument to hsaFinalizeKernel to specify values for /// the control directives, and is used in HsaKernelCode to record the values of diff --git a/llvm/lib/Transforms/IPO/ExtractGV.cpp b/llvm/lib/Transforms/IPO/ExtractGV.cpp index 042cacb70ad..d45a8832391 100644 --- a/llvm/lib/Transforms/IPO/ExtractGV.cpp +++ b/llvm/lib/Transforms/IPO/ExtractGV.cpp @@ -51,7 +51,7 @@ static void makeVisible(GlobalValue &GV, bool Delete) { } namespace { - /// @brief A pass to extract specific global values and their dependencies. + /// A pass to extract specific global values and their dependencies. class GVExtractorPass : public ModulePass { SetVector<GlobalValue *> Named; bool deleteStuff; diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp index f20d9d38180..be93022f245 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp @@ -257,7 +257,7 @@ Instruction::CastOps InstCombiner::isEliminableCastPair(const CastInst *CI1, return Instruction::CastOps(Res); } -/// @brief Implement the transforms common to all CastInst visitors. +/// Implement the transforms common to all CastInst visitors. Instruction *InstCombiner::commonCastTransforms(CastInst &CI) { Value *Src = CI.getOperand(0); @@ -1748,7 +1748,7 @@ Instruction *InstCombiner::visitIntToPtr(IntToPtrInst &CI) { return nullptr; } -/// @brief Implement the transforms for cast of pointer (bitcast/ptrtoint) +/// Implement the transforms for cast of pointer (bitcast/ptrtoint) Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) { Value *Src = CI.getOperand(0); diff --git a/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp b/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp index 2885591b537..f9f9873cd24 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp @@ -689,7 +689,7 @@ static bool isMultiple(const APInt &C1, const APInt &C2, APInt &Quotient, /// This function implements the transforms common to both integer division /// instructions (udiv and sdiv). It is called by the visitors to those integer /// division instructions. -/// @brief Common integer divide transforms +/// Common integer divide transforms Instruction *InstCombiner::commonIDivTransforms(BinaryOperator &I) { Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); bool IsSigned = I.getOpcode() == Instruction::SDiv; @@ -1280,7 +1280,7 @@ Instruction *InstCombiner::visitFDiv(BinaryOperator &I) { /// This function implements the transforms common to both integer remainder /// instructions (urem and srem). It is called by the visitors to those integer /// remainder instructions. -/// @brief Common integer remainder transforms +/// Common integer remainder transforms Instruction *InstCombiner::commonIRemTransforms(BinaryOperator &I) { Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); diff --git a/llvm/lib/Transforms/Scalar/StructurizeCFG.cpp b/llvm/lib/Transforms/Scalar/StructurizeCFG.cpp index 6f5c32cd1bc..25816f70c56 100644 --- a/llvm/lib/Transforms/Scalar/StructurizeCFG.cpp +++ b/llvm/lib/Transforms/Scalar/StructurizeCFG.cpp @@ -127,7 +127,7 @@ public: bool resultIsRememberedBlock() { return ResultIsRemembered; } }; -/// @brief Transforms the control flow graph on one single entry/exit region +/// Transforms the control flow graph on one single entry/exit region /// at a time. /// /// After the transform all "If"/"Then"/"Else" style control flow looks like diff --git a/llvm/lib/Transforms/Utils/IntegerDivision.cpp b/llvm/lib/Transforms/Utils/IntegerDivision.cpp index 5a90dcb033b..3fbb3487884 100644 --- a/llvm/lib/Transforms/Utils/IntegerDivision.cpp +++ b/llvm/lib/Transforms/Utils/IntegerDivision.cpp @@ -372,7 +372,7 @@ static Value *generateUnsignedDivisionCode(Value *Dividend, Value *Divisor, /// information about the operands are known. Implements both 32bit and 64bit /// scalar division. /// -/// @brief Replace Rem with generated code. +/// Replace Rem with generated code. bool llvm::expandRemainder(BinaryOperator *Rem) { assert((Rem->getOpcode() == Instruction::SRem || Rem->getOpcode() == Instruction::URem) && @@ -430,7 +430,7 @@ bool llvm::expandRemainder(BinaryOperator *Rem) { /// when more information about the operands are known. Implements both /// 32bit and 64bit scalar division. /// -/// @brief Replace Div with generated code. +/// Replace Div with generated code. bool llvm::expandDivision(BinaryOperator *Div) { assert((Div->getOpcode() == Instruction::SDiv || Div->getOpcode() == Instruction::UDiv) && @@ -482,7 +482,7 @@ bool llvm::expandDivision(BinaryOperator *Div) { /// that have no or very little suppport for smaller than 32 bit integer /// arithmetic. /// -/// @brief Replace Rem with emulation code. +/// Replace Rem with emulation code. bool llvm::expandRemainderUpTo32Bits(BinaryOperator *Rem) { assert((Rem->getOpcode() == Instruction::SRem || Rem->getOpcode() == Instruction::URem) && @@ -531,7 +531,7 @@ bool llvm::expandRemainderUpTo32Bits(BinaryOperator *Rem) { /// 64 bits. Uses the above routines and extends the inputs/truncates the /// outputs to operate in 64 bits. /// -/// @brief Replace Rem with emulation code. +/// Replace Rem with emulation code. bool llvm::expandRemainderUpTo64Bits(BinaryOperator *Rem) { assert((Rem->getOpcode() == Instruction::SRem || Rem->getOpcode() == Instruction::URem) && @@ -580,7 +580,7 @@ bool llvm::expandRemainderUpTo64Bits(BinaryOperator *Rem) { /// in 32 bits; that is, these routines are good for targets that have no /// or very little support for smaller than 32 bit integer arithmetic. /// -/// @brief Replace Div with emulation code. +/// Replace Div with emulation code. bool llvm::expandDivisionUpTo32Bits(BinaryOperator *Div) { assert((Div->getOpcode() == Instruction::SDiv || Div->getOpcode() == Instruction::UDiv) && @@ -628,7 +628,7 @@ bool llvm::expandDivisionUpTo32Bits(BinaryOperator *Div) { /// above routines and extends the inputs/truncates the outputs to operate /// in 64 bits. /// -/// @brief Replace Div with emulation code. +/// Replace Div with emulation code. bool llvm::expandDivisionUpTo64Bits(BinaryOperator *Div) { assert((Div->getOpcode() == Instruction::SDiv || Div->getOpcode() == Instruction::UDiv) && diff --git a/llvm/tools/bugpoint/ToolRunner.cpp b/llvm/tools/bugpoint/ToolRunner.cpp index 20eb738bd51..ea0128d0e82 100644 --- a/llvm/tools/bugpoint/ToolRunner.cpp +++ b/llvm/tools/bugpoint/ToolRunner.cpp @@ -215,7 +215,7 @@ const char EXESuffix[] = "exe"; /// itself. This allows us to find another LLVM tool if it is built in the same /// directory. An empty string is returned on error; note that this function /// just mainpulates the path and doesn't check for executability. -/// @brief Find a named executable. +/// Find a named executable. static std::string PrependMainExecutablePath(const std::string &ExeName, const char *Argv0, void *MainAddr) { diff --git a/llvm/tools/llvm-objdump/llvm-objdump.cpp b/llvm/tools/llvm-objdump/llvm-objdump.cpp index 0a1f0e2cda7..ce2bd1092be 100644 --- a/llvm/tools/llvm-objdump/llvm-objdump.cpp +++ b/llvm/tools/llvm-objdump/llvm-objdump.cpp @@ -1129,7 +1129,7 @@ static std::error_code getRelocationValueString(const RelocationRef &Rel, llvm_unreachable("unknown object file format"); } -/// @brief Indicates whether this relocation should hidden when listing +/// Indicates whether this relocation should hidden when listing /// relocations, usually because it is the trailing part of a multipart /// relocation that will be printed as part of the leading relocation. static bool getHidden(RelocationRef RelRef) { @@ -2149,7 +2149,7 @@ static void DumpObject(const COFFImportFile *I, const Archive *A) { printCOFFSymbolTable(I); } -/// @brief Dump each object file in \a a; +/// Dump each object file in \a a; static void DumpArchive(const Archive *a) { Error Err = Error::success(); for (auto &C : a->children(Err)) { @@ -2170,7 +2170,7 @@ static void DumpArchive(const Archive *a) { report_error(a->getFileName(), std::move(Err)); } -/// @brief Open file and figure out how to dump it. +/// Open file and figure out how to dump it. static void DumpInput(StringRef file) { // If we are using the Mach-O specific object file parser, then let it parse diff --git a/llvm/tools/llvm-readobj/llvm-readobj.cpp b/llvm/tools/llvm-readobj/llvm-readobj.cpp index 2ff92a0a21f..4b8a1b32471 100644 --- a/llvm/tools/llvm-readobj/llvm-readobj.cpp +++ b/llvm/tools/llvm-readobj/llvm-readobj.cpp @@ -359,7 +359,7 @@ struct ReadObjTypeTableBuilder { } static ReadObjTypeTableBuilder CVTypes; -/// @brief Creates an format-specific object file dumper. +/// Creates an format-specific object file dumper. static std::error_code createDumper(const ObjectFile *Obj, ScopedPrinter &Writer, std::unique_ptr<ObjDumper> &Result) { @@ -378,7 +378,7 @@ static std::error_code createDumper(const ObjectFile *Obj, return readobj_error::unsupported_obj_file_format; } -/// @brief Dumps the specified object file. +/// Dumps the specified object file. static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer) { std::unique_ptr<ObjDumper> Dumper; if (std::error_code EC = createDumper(Obj, Writer, Dumper)) @@ -482,7 +482,7 @@ static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer) { Dumper->printStackMap(); } -/// @brief Dumps each object file in \a Arc; +/// Dumps each object file in \a Arc; static void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) { Error Err = Error::success(); for (auto &Child : Arc->children(Err)) { @@ -504,7 +504,7 @@ static void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) { reportError(Arc->getFileName(), std::move(Err)); } -/// @brief Dumps each object file in \a MachO Universal Binary; +/// Dumps each object file in \a MachO Universal Binary; static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary, ScopedPrinter &Writer) { for (const MachOUniversalBinary::ObjectForArch &Obj : UBinary->objects()) { @@ -519,7 +519,7 @@ static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary, } } -/// @brief Dumps \a WinRes, Windows Resource (.res) file; +/// Dumps \a WinRes, Windows Resource (.res) file; static void dumpWindowsResourceFile(WindowsResource *WinRes) { ScopedPrinter Printer{outs()}; WindowsRes::Dumper Dumper(WinRes, Printer); @@ -528,7 +528,7 @@ static void dumpWindowsResourceFile(WindowsResource *WinRes) { } -/// @brief Opens \a File and dumps it. +/// Opens \a File and dumps it. static void dumpInput(StringRef File) { ScopedPrinter Writer(outs()); diff --git a/llvm/utils/KillTheDoctor/KillTheDoctor.cpp b/llvm/utils/KillTheDoctor/KillTheDoctor.cpp index 19c880ae94d..c9def83309f 100644 --- a/llvm/utils/KillTheDoctor/KillTheDoctor.cpp +++ b/llvm/utils/KillTheDoctor/KillTheDoctor.cpp @@ -218,7 +218,7 @@ static std::error_code GetFileNameFromHandle(HANDLE FileHandle, } } -/// @brief Find program using shell lookup rules. +/// Find program using shell lookup rules. /// @param Program This is either an absolute path, relative path, or simple a /// program name. Look in PATH for any programs that match. If no /// extension is present, try all extensions in PATHEXT. |
