[llvm-commits] [llvm] r163790 - in /llvm/trunk: include/llvm/ include/llvm/ADT/ include/llvm/Support/ lib/Transforms/Scalar/ utils/TableGen/
Sean Silva
silvas at purdue.edu
Thu Sep 13 13:08:27 PDT 2012
Hi Dmitri, it looks like you're quite the doxygen-ninja. Do you think
that you could write up some documentation regarding proper use of
Doxygen for LLVM? Nothing fancy, just a few paragraphs and examples of
common cases like the expected form for function and class comments,
along with common formatting markup.
If you need help navigating/creating the new Sphinx docs let me know
and I can explain how to make a new page and link it in with the rest
of the documentation, along with anything else you need to know :)
--Sean Silva
On Thu, Sep 13, 2012 at 8:34 AM, Dmitri Gribenko <gribozavr at gmail.com> wrote:
> Author: gribozavr
> Date: Thu Sep 13 07:34:29 2012
> New Revision: 163790
>
> URL: http://llvm.org/viewvc/llvm-project?rev=163790&view=rev
> Log:
> Fix Doxygen issues:
> * wrap code blocks in \code ... \endcode;
> * refer to parameter names in paragraphs correctly (\arg is not what most
> people want -- it starts a new paragraph).
>
> Modified:
> llvm/trunk/include/llvm/ADT/APInt.h
> llvm/trunk/include/llvm/ADT/DAGDeltaAlgorithm.h
> llvm/trunk/include/llvm/ADT/SmallString.h
> llvm/trunk/include/llvm/ADT/SmallVector.h
> llvm/trunk/include/llvm/ADT/StringExtras.h
> llvm/trunk/include/llvm/ADT/StringRef.h
> llvm/trunk/include/llvm/ADT/Triple.h
> llvm/trunk/include/llvm/ADT/Twine.h
> llvm/trunk/include/llvm/IRBuilder.h
> llvm/trunk/include/llvm/Support/MathExtras.h
> llvm/trunk/include/llvm/Support/TargetRegistry.h
> llvm/trunk/include/llvm/Support/Threading.h
> llvm/trunk/include/llvm/Support/raw_ostream.h
> llvm/trunk/include/llvm/Value.h
> llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp
> llvm/trunk/utils/TableGen/X86ModRMFilters.h
> llvm/trunk/utils/TableGen/X86RecognizableInstr.h
>
> Modified: llvm/trunk/include/llvm/ADT/APInt.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/APInt.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/APInt.h (original)
> +++ llvm/trunk/include/llvm/ADT/APInt.h Thu Sep 13 07:34:29 2012
> @@ -251,7 +251,7 @@
> /// constructor.
> APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[]);
>
> - /// This constructor interprets the string \arg str in the given radix. The
> + /// This constructor interprets the string \p str in the given radix. The
> /// interpretation stops when the first character that is not suitable for the
> /// radix is encountered, or the end of the string. Acceptable radix values
> /// are 2, 8, 10, 16, and 36. It is an error for the value implied by the
> @@ -1231,7 +1231,7 @@
> }
>
> /// This method determines how many bits are required to hold the APInt
> - /// equivalent of the string given by \arg str.
> + /// equivalent of the string given by \p str.
> /// @brief Get bits required for string value.
> static unsigned getBitsNeeded(StringRef str, uint8_t radix);
>
>
> Modified: llvm/trunk/include/llvm/ADT/DAGDeltaAlgorithm.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/DAGDeltaAlgorithm.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/DAGDeltaAlgorithm.h (original)
> +++ llvm/trunk/include/llvm/ADT/DAGDeltaAlgorithm.h Thu Sep 13 07:34:29 2012
> @@ -57,8 +57,9 @@
> ///
> /// \param Dependencies The list of dependencies amongst changes. For each
> /// (x,y) in \arg Dependencies, both x and y must be in \arg Changes. The
> - /// minimization algorithm guarantees that for each tested changed set S, x
> - /// \in S implies y \in S. It is an error to have cyclic dependencies.
> + /// minimization algorithm guarantees that for each tested changed set S,
> + /// \f$ x \in S \f$ implies \f$ y \in S \f$. It is an error to have cyclic
> + /// dependencies.
> changeset_ty Run(const changeset_ty &Changes,
> const std::vector<edge_ty> &Dependencies);
>
>
> Modified: llvm/trunk/include/llvm/ADT/SmallString.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/SmallString.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/SmallString.h (original)
> +++ llvm/trunk/include/llvm/ADT/SmallString.h Thu Sep 13 07:34:29 2012
> @@ -44,25 +44,25 @@
> /// @name String Assignment
> /// @{
>
> - /// Assign from a repeated element
> + /// Assign from a repeated element.
> void assign(size_t NumElts, char Elt) {
> this->SmallVectorImpl<char>::assign(NumElts, Elt);
> }
>
> - /// Assign from an iterator pair
> + /// Assign from an iterator pair.
> template<typename in_iter>
> void assign(in_iter S, in_iter E) {
> this->clear();
> SmallVectorImpl<char>::append(S, E);
> }
>
> - /// Assign from a StringRef
> + /// Assign from a StringRef.
> void assign(StringRef RHS) {
> this->clear();
> SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
> }
>
> - /// Assign from a SmallVector
> + /// Assign from a SmallVector.
> void assign(const SmallVectorImpl<char> &RHS) {
> this->clear();
> SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
> @@ -72,7 +72,7 @@
> /// @name String Concatenation
> /// @{
>
> - /// Append from an iterator pair
> + /// Append from an iterator pair.
> template<typename in_iter>
> void append(in_iter S, in_iter E) {
> SmallVectorImpl<char>::append(S, E);
> @@ -83,12 +83,12 @@
> }
>
>
> - /// Append from a StringRef
> + /// Append from a StringRef.
> void append(StringRef RHS) {
> SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
> }
>
> - /// Append from a SmallVector
> + /// Append from a SmallVector.
> void append(const SmallVectorImpl<char> &RHS) {
> SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
> }
> @@ -97,19 +97,19 @@
> /// @name String Comparison
> /// @{
>
> - /// equals - Check for string equality, this is more efficient than
> - /// compare() when the relative ordering of inequal strings isn't needed.
> + /// Check for string equality. This is more efficient than compare() when
> + /// the relative ordering of inequal strings isn't needed.
> bool equals(StringRef RHS) const {
> return str().equals(RHS);
> }
>
> - /// equals_lower - Check for string equality, ignoring case.
> + /// Check for string equality, ignoring case.
> bool equals_lower(StringRef RHS) const {
> return str().equals_lower(RHS);
> }
>
> - /// compare - Compare two strings; the result is -1, 0, or 1 if this string
> - /// is lexicographically less than, equal to, or greater than the \arg RHS.
> + /// Compare two strings; the result is -1, 0, or 1 if this string is
> + /// lexicographically less than, equal to, or greater than the \p RHS.
> int compare(StringRef RHS) const {
> return str().compare(RHS);
> }
> @@ -129,12 +129,12 @@
> /// @name String Predicates
> /// @{
>
> - /// startswith - Check if this string starts with the given \arg Prefix.
> + /// startswith - Check if this string starts with the given \p Prefix.
> bool startswith(StringRef Prefix) const {
> return str().startswith(Prefix);
> }
>
> - /// endswith - Check if this string ends with the given \arg Suffix.
> + /// endswith - Check if this string ends with the given \p Suffix.
> bool endswith(StringRef Suffix) const {
> return str().endswith(Suffix);
> }
> @@ -143,76 +143,76 @@
> /// @name String Searching
> /// @{
>
> - /// find - Search for the first character \arg C in the string.
> + /// find - Search for the first character \p C in the string.
> ///
> - /// \return - The index of the first occurrence of \arg C, or npos if not
> + /// \return - The index of the first occurrence of \p C, or npos if not
> /// found.
> size_t find(char C, size_t From = 0) const {
> return str().find(C, From);
> }
>
> - /// find - Search for the first string \arg Str in the string.
> + /// Search for the first string \p Str in the string.
> ///
> - /// \return - The index of the first occurrence of \arg Str, or npos if not
> + /// \returns The index of the first occurrence of \p Str, or npos if not
> /// found.
> size_t find(StringRef Str, size_t From = 0) const {
> return str().find(Str, From);
> }
>
> - /// rfind - Search for the last character \arg C in the string.
> + /// Search for the last character \p C in the string.
> ///
> - /// \return - The index of the last occurrence of \arg C, or npos if not
> + /// \returns The index of the last occurrence of \p C, or npos if not
> /// found.
> size_t rfind(char C, size_t From = StringRef::npos) const {
> return str().rfind(C, From);
> }
>
> - /// rfind - Search for the last string \arg Str in the string.
> + /// Search for the last string \p Str in the string.
> ///
> - /// \return - The index of the last occurrence of \arg Str, or npos if not
> + /// \returns The index of the last occurrence of \p Str, or npos if not
> /// found.
> size_t rfind(StringRef Str) const {
> return str().rfind(Str);
> }
>
> - /// find_first_of - Find the first character in the string that is \arg C,
> - /// or npos if not found. Same as find.
> + /// Find the first character in the string that is \p C, or npos if not
> + /// found. Same as find.
> size_t find_first_of(char C, size_t From = 0) const {
> return str().find_first_of(C, From);
> }
>
> - /// find_first_of - Find the first character in the string that is in \arg
> - /// Chars, or npos if not found.
> + /// Find the first character in the string that is in \p Chars, or npos if
> + /// not found.
> ///
> - /// Note: O(size() + Chars.size())
> + /// Complexity: O(size() + Chars.size())
> size_t find_first_of(StringRef Chars, size_t From = 0) const {
> return str().find_first_of(Chars, From);
> }
>
> - /// find_first_not_of - Find the first character in the string that is not
> - /// \arg C or npos if not found.
> + /// Find the first character in the string that is not \p C or npos if not
> + /// found.
> size_t find_first_not_of(char C, size_t From = 0) const {
> return str().find_first_not_of(C, From);
> }
>
> - /// find_first_not_of - Find the first character in the string that is not
> - /// in the string \arg Chars, or npos if not found.
> + /// Find the first character in the string that is not in the string
> + /// \p Chars, or npos if not found.
> ///
> - /// Note: O(size() + Chars.size())
> + /// Complexity: O(size() + Chars.size())
> size_t find_first_not_of(StringRef Chars, size_t From = 0) const {
> return str().find_first_not_of(Chars, From);
> }
>
> - /// find_last_of - Find the last character in the string that is \arg C, or
> - /// npos if not found.
> + /// Find the last character in the string that is \p C, or npos if not
> + /// found.
> size_t find_last_of(char C, size_t From = StringRef::npos) const {
> return str().find_last_of(C, From);
> }
>
> - /// find_last_of - Find the last character in the string that is in \arg C,
> - /// or npos if not found.
> + /// Find the last character in the string that is in \p C, or npos if not
> + /// found.
> ///
> - /// Note: O(size() + Chars.size())
> + /// Complexity: O(size() + Chars.size())
> size_t find_last_of(
> StringRef Chars, size_t From = StringRef::npos) const {
> return str().find_last_of(Chars, From);
> @@ -222,13 +222,13 @@
> /// @name Helpful Algorithms
> /// @{
>
> - /// count - Return the number of occurrences of \arg C in the string.
> + /// Return the number of occurrences of \p C in the string.
> size_t count(char C) const {
> return str().count(C);
> }
>
> - /// count - Return the number of non-overlapped occurrences of \arg Str in
> - /// the string.
> + /// Return the number of non-overlapped occurrences of \p Str in the
> + /// string.
> size_t count(StringRef Str) const {
> return str().count(Str);
> }
> @@ -237,36 +237,36 @@
> /// @name Substring Operations
> /// @{
>
> - /// substr - Return a reference to the substring from [Start, Start + N).
> + /// Return a reference to the substring from [Start, Start + N).
> ///
> - /// \param Start - The index of the starting character in the substring; if
> + /// \param Start The index of the starting character in the substring; if
> /// the index is npos or greater than the length of the string then the
> /// empty substring will be returned.
> ///
> - /// \param N - The number of characters to included in the substring. If N
> + /// \param N The number of characters to included in the substring. If \p N
> /// exceeds the number of characters remaining in the string, the string
> - /// suffix (starting with \arg Start) will be returned.
> + /// suffix (starting with \p Start) will be returned.
> StringRef substr(size_t Start, size_t N = StringRef::npos) const {
> return str().substr(Start, N);
> }
>
> - /// slice - Return a reference to the substring from [Start, End).
> + /// Return a reference to the substring from [Start, End).
> ///
> - /// \param Start - The index of the starting character in the substring; if
> + /// \param Start The index of the starting character in the substring; if
> /// the index is npos or greater than the length of the string then the
> /// empty substring will be returned.
> ///
> - /// \param End - The index following the last character to include in the
> - /// substring. If this is npos, or less than \arg Start, or exceeds the
> + /// \param End The index following the last character to include in the
> + /// substring. If this is npos, or less than \p Start, or exceeds the
> /// number of characters remaining in the string, the string suffix
> - /// (starting with \arg Start) will be returned.
> + /// (starting with \p Start) will be returned.
> StringRef slice(size_t Start, size_t End) const {
> return str().slice(Start, End);
> }
>
> // Extra methods.
>
> - /// Explicit conversion to StringRef
> + /// Explicit conversion to StringRef.
> StringRef str() const { return StringRef(this->begin(), this->size()); }
>
> // TODO: Make this const, if it's safe...
>
> Modified: llvm/trunk/include/llvm/ADT/SmallVector.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/SmallVector.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/SmallVector.h (original)
> +++ llvm/trunk/include/llvm/ADT/SmallVector.h Thu Sep 13 07:34:29 2012
> @@ -684,8 +684,8 @@
> RHS.begin(), RHS.end());
> }
>
> - /// set_size - Set the array size to \arg N, which the current array must have
> - /// enough capacity for.
> + /// Set the array size to \p N, which the current array must have enough
> + /// capacity for.
> ///
> /// This does not construct or destroy any elements in the vector.
> ///
>
> Modified: llvm/trunk/include/llvm/ADT/StringExtras.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/StringExtras.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/StringExtras.h (original)
> +++ llvm/trunk/include/llvm/ADT/StringExtras.h Thu Sep 13 07:34:29 2012
> @@ -21,7 +21,7 @@
> template<typename T> class SmallVectorImpl;
>
> /// hexdigit - Return the hexadecimal character for the
> -/// given number \arg X (which should be less than 16).
> +/// given number \p X (which should be less than 16).
> static inline char hexdigit(unsigned X, bool LowerCase = false) {
> const char HexChar = LowerCase ? 'a' : 'A';
> return X < 10 ? '0' + X : HexChar + X - 10;
>
> Modified: llvm/trunk/include/llvm/ADT/StringRef.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/StringRef.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/StringRef.h (original)
> +++ llvm/trunk/include/llvm/ADT/StringRef.h Thu Sep 13 07:34:29 2012
> @@ -138,7 +138,7 @@
> }
>
> /// compare - Compare two strings; the result is -1, 0, or 1 if this string
> - /// is lexicographically less than, equal to, or greater than the \arg RHS.
> + /// is lexicographically less than, equal to, or greater than the \p RHS.
> int compare(StringRef RHS) const {
> // Check the prefix for a mismatch.
> if (int Res = compareMemory(Data, RHS.Data, min(Length, RHS.Length)))
> @@ -205,13 +205,13 @@
> /// @name String Predicates
> /// @{
>
> - /// startswith - Check if this string starts with the given \arg Prefix.
> + /// Check if this string starts with the given \p Prefix.
> bool startswith(StringRef Prefix) const {
> return Length >= Prefix.Length &&
> compareMemory(Data, Prefix.Data, Prefix.Length) == 0;
> }
>
> - /// endswith - Check if this string ends with the given \arg Suffix.
> + /// Check if this string ends with the given \p Suffix.
> bool endswith(StringRef Suffix) const {
> return Length >= Suffix.Length &&
> compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
> @@ -221,9 +221,9 @@
> /// @name String Searching
> /// @{
>
> - /// find - Search for the first character \arg C in the string.
> + /// Search for the first character \p C in the string.
> ///
> - /// \return - The index of the first occurrence of \arg C, or npos if not
> + /// \returns The index of the first occurrence of \p C, or npos if not
> /// found.
> size_t find(char C, size_t From = 0) const {
> for (size_t i = min(From, Length), e = Length; i != e; ++i)
> @@ -232,15 +232,15 @@
> return npos;
> }
>
> - /// find - Search for the first string \arg Str in the string.
> + /// Search for the first string \p Str in the string.
> ///
> - /// \return - The index of the first occurrence of \arg Str, or npos if not
> + /// \returns The index of the first occurrence of \p Str, or npos if not
> /// found.
> size_t find(StringRef Str, size_t From = 0) const;
>
> - /// rfind - Search for the last character \arg C in the string.
> + /// Search for the last character \p C in the string.
> ///
> - /// \return - The index of the last occurrence of \arg C, or npos if not
> + /// \returns The index of the last occurrence of \p C, or npos if not
> /// found.
> size_t rfind(char C, size_t From = npos) const {
> From = min(From, Length);
> @@ -253,61 +253,61 @@
> return npos;
> }
>
> - /// rfind - Search for the last string \arg Str in the string.
> + /// Search for the last string \p Str in the string.
> ///
> - /// \return - The index of the last occurrence of \arg Str, or npos if not
> + /// \returns The index of the last occurrence of \p Str, or npos if not
> /// found.
> size_t rfind(StringRef Str) const;
>
> - /// find_first_of - Find the first character in the string that is \arg C,
> - /// or npos if not found. Same as find.
> + /// Find the first character in the string that is \p C, or npos if not
> + /// found. Same as find.
> size_type find_first_of(char C, size_t From = 0) const {
> return find(C, From);
> }
>
> - /// find_first_of - Find the first character in the string that is in \arg
> - /// Chars, or npos if not found.
> + /// Find the first character in the string that is in \p Chars, or npos if
> + /// not found.
> ///
> - /// Note: O(size() + Chars.size())
> + /// Complexity: O(size() + Chars.size())
> size_type find_first_of(StringRef Chars, size_t From = 0) const;
>
> - /// find_first_not_of - Find the first character in the string that is not
> - /// \arg C or npos if not found.
> + /// Find the first character in the string that is not \p C or npos if not
> + /// found.
> size_type find_first_not_of(char C, size_t From = 0) const;
>
> - /// find_first_not_of - Find the first character in the string that is not
> - /// in the string \arg Chars, or npos if not found.
> + /// Find the first character in the string that is not in the string
> + /// \p Chars, or npos if not found.
> ///
> - /// Note: O(size() + Chars.size())
> + /// Complexity: O(size() + Chars.size())
> size_type find_first_not_of(StringRef Chars, size_t From = 0) const;
>
> - /// find_last_of - Find the last character in the string that is \arg C, or
> - /// npos if not found.
> + /// Find the last character in the string that is \p C, or npos if not
> + /// found.
> size_type find_last_of(char C, size_t From = npos) const {
> return rfind(C, From);
> }
>
> - /// find_last_of - Find the last character in the string that is in \arg C,
> - /// or npos if not found.
> + /// Find the last character in the string that is in \p C, or npos if not
> + /// found.
> ///
> - /// Note: O(size() + Chars.size())
> + /// Complexity: O(size() + Chars.size())
> size_type find_last_of(StringRef Chars, size_t From = npos) const;
>
> - /// find_last_not_of - Find the last character in the string that is not
> - /// \arg C, or npos if not found.
> + /// Find the last character in the string that is not \p C, or npos if not
> + /// found.
> size_type find_last_not_of(char C, size_t From = npos) const;
>
> - /// find_last_not_of - Find the last character in the string that is not in
> - /// \arg Chars, or npos if not found.
> + /// Find the last character in the string that is not in \p Chars, or
> + /// npos if not found.
> ///
> - /// Note: O(size() + Chars.size())
> + /// Complexity: O(size() + Chars.size())
> size_type find_last_not_of(StringRef Chars, size_t From = npos) const;
>
> /// @}
> /// @name Helpful Algorithms
> /// @{
>
> - /// count - Return the number of occurrences of \arg C in the string.
> + /// Return the number of occurrences of \p C in the string.
> size_t count(char C) const {
> size_t Count = 0;
> for (size_t i = 0, e = Length; i != e; ++i)
> @@ -316,18 +316,17 @@
> return Count;
> }
>
> - /// count - Return the number of non-overlapped occurrences of \arg Str in
> + /// Return the number of non-overlapped occurrences of \p Str in
> /// the string.
> size_t count(StringRef Str) const;
>
> - /// getAsInteger - Parse the current string as an integer of the specified
> - /// radix. If Radix is specified as zero, this does radix autosensing using
> + /// Parse the current string as an integer of the specified radix. If
> + /// \p Radix is specified as zero, this does radix autosensing using
> /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
> ///
> /// If the string is invalid or if only a subset of the string is valid,
> /// this returns true to signify the error. The string is considered
> /// erroneous if empty or if it overflows T.
> - ///
> template <typename T>
> typename enable_if_c<std::numeric_limits<T>::is_signed, bool>::type
> getAsInteger(unsigned Radix, T &Result) const {
> @@ -350,13 +349,12 @@
> return false;
> }
>
> - /// getAsInteger - Parse the current string as an integer of the
> - /// specified radix, or of an autosensed radix if the radix given
> - /// is 0. The current value in Result is discarded, and the
> - /// storage is changed to be wide enough to store the parsed
> - /// integer.
> + /// Parse the current string as an integer of the specified \p Radix, or of
> + /// an autosensed radix if the \p Radix given is 0. The current value in
> + /// \p Result is discarded, and the storage is changed to be wide enough to
> + /// store the parsed integer.
> ///
> - /// Returns true if the string does not solely consist of a valid
> + /// \returns true if the string does not solely consist of a valid
> /// non-empty number in the appropriate base.
> ///
> /// APInt::fromString is superficially similar but assumes the
> @@ -367,70 +365,70 @@
> /// @name String Operations
> /// @{
>
> - // lower - Convert the given ASCII string to lowercase.
> + // Convert the given ASCII string to lowercase.
> std::string lower() const;
>
> - /// upper - Convert the given ASCII string to uppercase.
> + /// Convert the given ASCII string to uppercase.
> std::string upper() const;
>
> /// @}
> /// @name Substring Operations
> /// @{
>
> - /// substr - Return a reference to the substring from [Start, Start + N).
> + /// Return a reference to the substring from [Start, Start + N).
> ///
> - /// \param Start - The index of the starting character in the substring; if
> + /// \param Start The index of the starting character in the substring; if
> /// the index is npos or greater than the length of the string then the
> /// empty substring will be returned.
> ///
> - /// \param N - The number of characters to included in the substring. If N
> + /// \param N The number of characters to included in the substring. If N
> /// exceeds the number of characters remaining in the string, the string
> - /// suffix (starting with \arg Start) will be returned.
> + /// suffix (starting with \p Start) will be returned.
> StringRef substr(size_t Start, size_t N = npos) const {
> Start = min(Start, Length);
> return StringRef(Data + Start, min(N, Length - Start));
> }
>
> - /// drop_front - Return a StringRef equal to 'this' but with the first
> - /// elements dropped.
> + /// Return a StringRef equal to 'this' but with the first \p N elements
> + /// dropped.
> StringRef drop_front(unsigned N = 1) const {
> assert(size() >= N && "Dropping more elements than exist");
> return substr(N);
> }
>
> - /// drop_back - Return a StringRef equal to 'this' but with the last
> - /// elements dropped.
> + /// Return a StringRef equal to 'this' but with the last \p N elements
> + /// dropped.
> StringRef drop_back(unsigned N = 1) const {
> assert(size() >= N && "Dropping more elements than exist");
> return substr(0, size()-N);
> }
>
> - /// slice - Return a reference to the substring from [Start, End).
> + /// Return a reference to the substring from [Start, End).
> ///
> - /// \param Start - The index of the starting character in the substring; if
> + /// \param Start The index of the starting character in the substring; if
> /// the index is npos or greater than the length of the string then the
> /// empty substring will be returned.
> ///
> - /// \param End - The index following the last character to include in the
> - /// substring. If this is npos, or less than \arg Start, or exceeds the
> + /// \param End The index following the last character to include in the
> + /// substring. If this is npos, or less than \p Start, or exceeds the
> /// number of characters remaining in the string, the string suffix
> - /// (starting with \arg Start) will be returned.
> + /// (starting with \p Start) will be returned.
> StringRef slice(size_t Start, size_t End) const {
> Start = min(Start, Length);
> End = min(max(Start, End), Length);
> return StringRef(Data + Start, End - Start);
> }
>
> - /// split - Split into two substrings around the first occurrence of a
> - /// separator character.
> + /// Split into two substrings around the first occurrence of a separator
> + /// character.
> ///
> - /// If \arg Separator is in the string, then the result is a pair (LHS, RHS)
> + /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
> /// such that (*this == LHS + Separator + RHS) is true and RHS is
> - /// maximal. If \arg Separator is not in the string, then the result is a
> + /// maximal. If \p Separator is not in the string, then the result is a
> /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").
> ///
> - /// \param Separator - The character to split on.
> - /// \return - The split substrings.
> + /// \param Separator The character to split on.
> + /// \returns The split substrings.
> std::pair<StringRef, StringRef> split(char Separator) const {
> size_t Idx = find(Separator);
> if (Idx == npos)
> @@ -438,12 +436,12 @@
> return std::make_pair(slice(0, Idx), slice(Idx+1, npos));
> }
>
> - /// split - Split into two substrings around the first occurrence of a
> - /// separator string.
> + /// Split into two substrings around the first occurrence of a separator
> + /// string.
> ///
> - /// If \arg Separator is in the string, then the result is a pair (LHS, RHS)
> + /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
> /// such that (*this == LHS + Separator + RHS) is true and RHS is
> - /// maximal. If \arg Separator is not in the string, then the result is a
> + /// maximal. If \p Separator is not in the string, then the result is a
> /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").
> ///
> /// \param Separator - The string to split on.
> @@ -455,14 +453,13 @@
> return std::make_pair(slice(0, Idx), slice(Idx + Separator.size(), npos));
> }
>
> - /// split - Split into substrings around the occurrences of a separator
> - /// string.
> + /// Split into substrings around the occurrences of a separator string.
> ///
> - /// Each substring is stored in \arg A. If \arg MaxSplit is >= 0, at most
> - /// \arg MaxSplit splits are done and consequently <= \arg MaxSplit
> + /// Each substring is stored in \p A. If \p MaxSplit is >= 0, at most
> + /// \p MaxSplit splits are done and consequently <= \p MaxSplit
> /// elements are added to A.
> - /// If \arg KeepEmpty is false, empty strings are not added to \arg A. They
> - /// still count when considering \arg MaxSplit
> + /// If \p KeepEmpty is false, empty strings are not added to \p A. They
> + /// still count when considering \p MaxSplit
> /// An useful invariant is that
> /// Separator.join(A) == *this if MaxSplit == -1 and KeepEmpty == true
> ///
> @@ -474,12 +471,12 @@
> StringRef Separator, int MaxSplit = -1,
> bool KeepEmpty = true) const;
>
> - /// rsplit - Split into two substrings around the last occurrence of a
> - /// separator character.
> + /// Split into two substrings around the last occurrence of a separator
> + /// character.
> ///
> - /// If \arg Separator is in the string, then the result is a pair (LHS, RHS)
> + /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
> /// such that (*this == LHS + Separator + RHS) is true and RHS is
> - /// minimal. If \arg Separator is not in the string, then the result is a
> + /// minimal. If \p Separator is not in the string, then the result is a
> /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").
> ///
> /// \param Separator - The character to split on.
> @@ -491,20 +488,20 @@
> return std::make_pair(slice(0, Idx), slice(Idx+1, npos));
> }
>
> - /// ltrim - Return string with consecutive characters in \arg Chars starting
> - /// from the left removed.
> + /// Return string with consecutive characters in \p Chars starting from
> + /// the left removed.
> StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const {
> return drop_front(std::min(Length, find_first_not_of(Chars)));
> }
>
> - /// rtrim - Return string with consecutive characters in \arg Chars starting
> - /// from the right removed.
> + /// Return string with consecutive characters in \p Chars starting from
> + /// the right removed.
> StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const {
> return drop_back(Length - std::min(Length, find_last_not_of(Chars) + 1));
> }
>
> - /// trim - Return string with consecutive characters in \arg Chars starting
> - /// from the left and right removed.
> + /// Return string with consecutive characters in \p Chars starting from
> + /// the left and right removed.
> StringRef trim(StringRef Chars = " \t\n\v\f\r") const {
> return ltrim(Chars).rtrim(Chars);
> }
>
> Modified: llvm/trunk/include/llvm/ADT/Triple.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/Triple.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/Triple.h (original)
> +++ llvm/trunk/include/llvm/ADT/Triple.h Thu Sep 13 07:34:29 2012
> @@ -342,7 +342,7 @@
> /// to a known type.
> void setEnvironment(EnvironmentType Kind);
>
> - /// setTriple - Set all components to the new triple \arg Str.
> + /// setTriple - Set all components to the new triple \p Str.
> void setTriple(const Twine &Str);
>
> /// setArchName - Set the architecture (first) component of the
> @@ -393,11 +393,10 @@
> /// @name Static helpers for IDs.
> /// @{
>
> - /// getArchTypeName - Get the canonical name for the \arg Kind
> - /// architecture.
> + /// getArchTypeName - Get the canonical name for the \p Kind architecture.
> static const char *getArchTypeName(ArchType Kind);
>
> - /// getArchTypePrefix - Get the "prefix" canonical name for the \arg Kind
> + /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind
> /// architecture. This is the prefix used by the architecture specific
> /// builtins, and is suitable for passing to \see
> /// Intrinsic::getIntrinsicForGCCBuiltin().
> @@ -405,15 +404,13 @@
> /// \return - The architecture prefix, or 0 if none is defined.
> static const char *getArchTypePrefix(ArchType Kind);
>
> - /// getVendorTypeName - Get the canonical name for the \arg Kind
> - /// vendor.
> + /// getVendorTypeName - Get the canonical name for the \p Kind vendor.
> static const char *getVendorTypeName(VendorType Kind);
>
> - /// getOSTypeName - Get the canonical name for the \arg Kind operating
> - /// system.
> + /// getOSTypeName - Get the canonical name for the \p Kind operating system.
> static const char *getOSTypeName(OSType Kind);
>
> - /// getEnvironmentTypeName - Get the canonical name for the \arg Kind
> + /// getEnvironmentTypeName - Get the canonical name for the \p Kind
> /// environment.
> static const char *getEnvironmentTypeName(EnvironmentType Kind);
>
>
> Modified: llvm/trunk/include/llvm/ADT/Twine.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/Twine.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/Twine.h (original)
> +++ llvm/trunk/include/llvm/ADT/Twine.h Thu Sep 13 07:34:29 2012
> @@ -44,7 +44,7 @@
> /// itself, and renders as an empty string. This can be returned from APIs to
> /// effectively nullify any concatenations performed on the result.
> ///
> - /// \b Implementation \n
> + /// \b Implementation
> ///
> /// Given the nature of a Twine, it is not possible for the Twine's
> /// concatenation method to construct interior nodes; the result must be
> @@ -67,7 +67,7 @@
> ///
> /// These invariants are check by \see isValid().
> ///
> - /// \b Efficiency Considerations \n
> + /// \b Efficiency Considerations
> ///
> /// The Twine is designed to yield efficient and small code for common
> /// situations. For this reason, the concat() method is inlined so that
> @@ -303,37 +303,37 @@
> LHS.character = static_cast<char>(Val);
> }
>
> - /// Construct a twine to print \arg Val as an unsigned decimal integer.
> + /// Construct a twine to print \p Val as an unsigned decimal integer.
> explicit Twine(unsigned Val)
> : LHSKind(DecUIKind), RHSKind(EmptyKind) {
> LHS.decUI = Val;
> }
>
> - /// Construct a twine to print \arg Val as a signed decimal integer.
> + /// Construct a twine to print \p Val as a signed decimal integer.
> explicit Twine(int Val)
> : LHSKind(DecIKind), RHSKind(EmptyKind) {
> LHS.decI = Val;
> }
>
> - /// Construct a twine to print \arg Val as an unsigned decimal integer.
> + /// Construct a twine to print \p Val as an unsigned decimal integer.
> explicit Twine(const unsigned long &Val)
> : LHSKind(DecULKind), RHSKind(EmptyKind) {
> LHS.decUL = &Val;
> }
>
> - /// Construct a twine to print \arg Val as a signed decimal integer.
> + /// Construct a twine to print \p Val as a signed decimal integer.
> explicit Twine(const long &Val)
> : LHSKind(DecLKind), RHSKind(EmptyKind) {
> LHS.decL = &Val;
> }
>
> - /// Construct a twine to print \arg Val as an unsigned decimal integer.
> + /// Construct a twine to print \p Val as an unsigned decimal integer.
> explicit Twine(const unsigned long long &Val)
> : LHSKind(DecULLKind), RHSKind(EmptyKind) {
> LHS.decULL = &Val;
> }
>
> - /// Construct a twine to print \arg Val as a signed decimal integer.
> + /// Construct a twine to print \p Val as a signed decimal integer.
> explicit Twine(const long long &Val)
> : LHSKind(DecLLKind), RHSKind(EmptyKind) {
> LHS.decLL = &Val;
> @@ -370,7 +370,7 @@
> /// @name Numeric Conversions
> /// @{
>
> - // Construct a twine to print \arg Val as an unsigned hexadecimal integer.
> + // Construct a twine to print \p Val as an unsigned hexadecimal integer.
> static Twine utohexstr(const uint64_t &Val) {
> Child LHS, RHS;
> LHS.uHex = &Val;
> @@ -447,17 +447,17 @@
> /// The returned StringRef's size does not include the null terminator.
> StringRef toNullTerminatedStringRef(SmallVectorImpl<char> &Out) const;
>
> - /// print - Write the concatenated string represented by this twine to the
> - /// stream \arg OS.
> + /// Write the concatenated string represented by this twine to the
> + /// stream \p OS.
> void print(raw_ostream &OS) const;
>
> - /// dump - Dump the concatenated string represented by this twine to stderr.
> + /// Dump the concatenated string represented by this twine to stderr.
> void dump() const;
>
> - /// print - Write the representation of this twine to the stream \arg OS.
> + /// Write the representation of this twine to the stream \p OS.
> void printRepr(raw_ostream &OS) const;
>
> - /// dumpRepr - Dump the representation of this twine to stderr.
> + /// Dump the representation of this twine to stderr.
> void dumpRepr() const;
>
> /// @}
>
> Modified: llvm/trunk/include/llvm/IRBuilder.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IRBuilder.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/IRBuilder.h (original)
> +++ llvm/trunk/include/llvm/IRBuilder.h Thu Sep 13 07:34:29 2012
> @@ -1261,13 +1261,13 @@
> // Utility creation methods
> //===--------------------------------------------------------------------===//
>
> - /// CreateIsNull - Return an i1 value testing if \arg Arg is null.
> + /// CreateIsNull - Return an i1 value testing if \p Arg is null.
> Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
> return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
> Name);
> }
>
> - /// CreateIsNotNull - Return an i1 value testing if \arg Arg is not null.
> + /// CreateIsNotNull - Return an i1 value testing if \p Arg is not null.
> Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
> return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
> Name);
>
> Modified: llvm/trunk/include/llvm/Support/MathExtras.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/MathExtras.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/MathExtras.h (original)
> +++ llvm/trunk/include/llvm/Support/MathExtras.h Thu Sep 13 07:34:29 2012
> @@ -431,21 +431,22 @@
> return A + 1;
> }
>
> -/// RoundUpToAlignment - Returns the next integer (mod 2**64) that is
> -/// greater than or equal to \arg Value and is a multiple of \arg
> -/// Align. Align must be non-zero.
> +/// Returns the next integer (mod 2**64) that is greater than or equal to
> +/// \p Value and is a multiple of \p Align. \p Align must be non-zero.
> ///
> /// Examples:
> -/// RoundUpToAlignment(5, 8) = 8
> -/// RoundUpToAlignment(17, 8) = 24
> -/// RoundUpToAlignment(~0LL, 8) = 0
> +/// \code
> +/// RoundUpToAlignment(5, 8) = 8
> +/// RoundUpToAlignment(17, 8) = 24
> +/// RoundUpToAlignment(~0LL, 8) = 0
> +/// \endcode
> inline uint64_t RoundUpToAlignment(uint64_t Value, uint64_t Align) {
> return ((Value + Align - 1) / Align) * Align;
> }
>
> -/// OffsetToAlignment - Return the offset to the next integer (mod 2**64) that
> -/// is greater than or equal to \arg Value and is a multiple of \arg
> -/// Align. Align must be non-zero.
> +/// Returns the offset to the next integer (mod 2**64) that is greater than
> +/// or equal to \p Value and is a multiple of \p Align. \p Align must be
> +/// non-zero.
> inline uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align) {
> return RoundUpToAlignment(Value, Align) - Value;
> }
>
> Modified: llvm/trunk/include/llvm/Support/TargetRegistry.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/TargetRegistry.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/TargetRegistry.h (original)
> +++ llvm/trunk/include/llvm/Support/TargetRegistry.h Thu Sep 13 07:34:29 2012
> @@ -271,7 +271,7 @@
> /// createMCAsmInfo - Create a MCAsmInfo implementation for the specified
> /// target triple.
> ///
> - /// \arg Triple - This argument is used to determine the target machine
> + /// \param Triple This argument is used to determine the target machine
> /// feature set; it should always be provided. Generally this should be
> /// either the target triple from the module, or the target triple of the
> /// host if that does not exist.
> @@ -317,12 +317,12 @@
>
> /// createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
> ///
> - /// \arg Triple - This argument is used to determine the target machine
> + /// \param Triple This argument is used to determine the target machine
> /// feature set; it should always be provided. Generally this should be
> /// either the target triple from the module, or the target triple of the
> /// host if that does not exist.
> - /// \arg CPU - This specifies the name of the target CPU.
> - /// \arg Features - This specifies the string representation of the
> + /// \param CPU This specifies the name of the target CPU.
> + /// \param Features This specifies the string representation of the
> /// additional target features.
> MCSubtargetInfo *createMCSubtargetInfo(StringRef Triple, StringRef CPU,
> StringRef Features) const {
> @@ -332,9 +332,9 @@
> }
>
> /// createTargetMachine - Create a target specific machine implementation
> - /// for the specified \arg Triple.
> + /// for the specified \p Triple.
> ///
> - /// \arg Triple - This argument is used to determine the target machine
> + /// \param Triple This argument is used to determine the target machine
> /// feature set; it should always be provided. Generally this should be
> /// either the target triple from the module, or the target triple of the
> /// host if that does not exist.
> @@ -351,8 +351,8 @@
>
> /// createMCAsmBackend - Create a target specific assembly parser.
> ///
> - /// \arg Triple - The target triple string.
> - /// \arg Backend - The target independent assembler object.
> + /// \param Triple The target triple string.
> + /// \param Backend The target independent assembler object.
> MCAsmBackend *createMCAsmBackend(StringRef Triple) const {
> if (!MCAsmBackendCtorFn)
> return 0;
> @@ -370,7 +370,7 @@
>
> /// createMCAsmParser - Create a target specific assembly parser.
> ///
> - /// \arg Parser - The target independent parser implementation to use for
> + /// \param Parser The target independent parser implementation to use for
> /// parsing and lexing.
> MCTargetAsmParser *createMCAsmParser(MCSubtargetInfo &STI,
> MCAsmParser &Parser) const {
> @@ -416,13 +416,13 @@
>
> /// createMCObjectStreamer - Create a target specific MCStreamer.
> ///
> - /// \arg TT - The target triple.
> - /// \arg Ctx - The target context.
> - /// \arg TAB - The target assembler backend object. Takes ownership.
> - /// \arg _OS - The stream object.
> - /// \arg _Emitter - The target independent assembler object.Takes ownership.
> - /// \arg RelaxAll - Relax all fixups?
> - /// \arg NoExecStack - Mark file as not needing a executable stack.
> + /// \param TT The target triple.
> + /// \param Ctx The target context.
> + /// \param TAB The target assembler backend object. Takes ownership.
> + /// \param _OS The stream object.
> + /// \param _Emitter The target independent assembler object.Takes ownership.
> + /// \param RelaxAll Relax all fixups?
> + /// \param NoExecStack Mark file as not needing a executable stack.
> MCStreamer *createMCObjectStreamer(StringRef TT, MCContext &Ctx,
> MCAsmBackend &TAB,
> raw_ostream &_OS,
>
> Modified: llvm/trunk/include/llvm/Support/Threading.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/Threading.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/Threading.h (original)
> +++ llvm/trunk/include/llvm/Support/Threading.h Thu Sep 13 07:34:29 2012
> @@ -41,8 +41,8 @@
> /// before llvm_start_multithreaded().
> void llvm_release_global_lock();
>
> - /// llvm_execute_on_thread - Execute the given \arg UserFn on a separate
> - /// thread, passing it the provided \arg UserData.
> + /// llvm_execute_on_thread - Execute the given \p UserFn on a separate
> + /// thread, passing it the provided \p UserData.
> ///
> /// This function does not guarantee that the code will actually be executed
> /// on a separate thread or honoring the requested stack size, but tries to do
>
> Modified: llvm/trunk/include/llvm/Support/raw_ostream.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/raw_ostream.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/raw_ostream.h (original)
> +++ llvm/trunk/include/llvm/Support/raw_ostream.h Thu Sep 13 07:34:29 2012
> @@ -191,10 +191,10 @@
>
> raw_ostream &operator<<(double N);
>
> - /// write_hex - Output \arg N in hexadecimal, without any prefix or padding.
> + /// write_hex - Output \p N in hexadecimal, without any prefix or padding.
> raw_ostream &write_hex(unsigned long long N);
>
> - /// write_escaped - Output \arg Str, turning '\\', '\t', '\n', '"', and
> + /// write_escaped - Output \p Str, turning '\\', '\t', '\n', '"', and
> /// anything that doesn't satisfy std::isprint into an escape sequence.
> raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false);
>
> @@ -245,15 +245,16 @@
>
> private:
> /// write_impl - The is the piece of the class that is implemented
> - /// by subclasses. This writes the \args Size bytes starting at
> - /// \arg Ptr to the underlying stream.
> + /// by subclasses. This writes the \p Size bytes starting at
> + /// \p Ptr to the underlying stream.
> ///
> /// This function is guaranteed to only be called at a point at which it is
> /// safe for the subclass to install a new buffer via SetBuffer.
> ///
> - /// \arg Ptr - The start of the data to be written. For buffered streams this
> + /// \param Ptr The start of the data to be written. For buffered streams this
> /// is guaranteed to be the start of the buffer.
> - /// \arg Size - The number of bytes to be written.
> + ///
> + /// \param Size The number of bytes to be written.
> ///
> /// \invariant { Size > 0 }
> virtual void write_impl(const char *Ptr, size_t Size) = 0;
> @@ -473,7 +474,7 @@
> public:
> /// Construct a new raw_svector_ostream.
> ///
> - /// \arg O - The vector to write to; this should generally have at least 128
> + /// \param O The vector to write to; this should generally have at least 128
> /// bytes free to avoid any extraneous memory overhead.
> explicit raw_svector_ostream(SmallVectorImpl<char> &O);
> ~raw_svector_ostream();
>
> Modified: llvm/trunk/include/llvm/Value.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Value.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Value.h (original)
> +++ llvm/trunk/include/llvm/Value.h Thu Sep 13 07:34:29 2012
> @@ -120,7 +120,7 @@
> /// setName() - Change the name of the value, choosing a new unique name if
> /// the provided name is taken.
> ///
> - /// \arg Name - The new name; or "" if the value's name should be removed.
> + /// \param Name The new name; or "" if the value's name should be removed.
> void setName(const Twine &Name);
>
>
>
> Modified: llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp Thu Sep 13 07:34:29 2012
> @@ -662,6 +662,7 @@
> /// DupRetToEnableTailCallOpts - Look for opportunities to duplicate return
> /// instructions to the predecessor to enable tail call optimizations. The
> /// case it is currently looking for is:
> +/// @code
> /// bb0:
> /// %tmp0 = tail call i32 @f0()
> /// br label %return
> @@ -674,9 +675,11 @@
> /// return:
> /// %retval = phi i32 [ %tmp0, %bb0 ], [ %tmp1, %bb1 ], [ %tmp2, %bb2 ]
> /// ret i32 %retval
> +/// @endcode
> ///
> /// =>
> ///
> +/// @code
> /// bb0:
> /// %tmp0 = tail call i32 @f0()
> /// ret i32 %tmp0
> @@ -686,7 +689,7 @@
> /// bb2:
> /// %tmp2 = tail call i32 @f2()
> /// ret i32 %tmp2
> -///
> +/// @endcode
> bool CodeGenPrepare::DupRetToEnableTailCallOpts(ReturnInst *RI) {
> if (!TLI)
> return false;
>
> Modified: llvm/trunk/utils/TableGen/X86ModRMFilters.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/X86ModRMFilters.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/utils/TableGen/X86ModRMFilters.h (original)
> +++ llvm/trunk/utils/TableGen/X86ModRMFilters.h Thu Sep 13 07:34:29 2012
> @@ -70,7 +70,7 @@
> public:
> /// Constructor
> ///
> - /// @r - True if the mod bits of the ModR/M byte must be 11; false
> + /// \param r True if the mod bits of the ModR/M byte must be 11; false
> /// otherwise. The name r derives from the fact that the mod
> /// bits indicate whether the R/M bits [bits 2-0] signify a
> /// register or a memory operand.
> @@ -98,11 +98,12 @@
> public:
> /// Constructor
> ///
> - /// @c0_ff - True if the ModR/M byte must fall between 0xc0 and 0xff;
> - /// false otherwise.
> - /// @nnn_or_modRM - If c0_ff is true, the required value of the entire ModR/M
> - /// byte. If c0_ff is false, the required value of the nnn
> - /// field.
> + /// \param c0_ff True if the ModR/M byte must fall between 0xc0 and 0xff;
> + /// false otherwise.
> + ///
> + /// \param nnn_or_modRM If c0_ff is true, the required value of the entire
> + /// ModR/M byte. If c0_ff is false, the required value
> + /// of the nnn field.
> EscapeFilter(bool c0_ff, uint8_t nnn_or_modRM) :
> ModRMFilter(),
> C0_FF(c0_ff),
> @@ -128,8 +129,8 @@
> public:
> /// Constructor
> ///
> - /// @modRM - The value of the ModR/M byte when the register operand
> - /// refers to the first register in the register set.
> + /// \param modRM The value of the ModR/M byte when the register operand
> + /// refers to the first register in the register set.
> AddRegEscapeFilter(uint8_t modRM) : ModRM(modRM) {
> }
>
> @@ -150,9 +151,9 @@
> public:
> /// Constructor
> ///
> - /// @r - True if the mod field must be set to 11; false otherwise.
> - /// The name is explained at ModFilter.
> - /// @nnn - The required value of the nnn field.
> + /// \param r True if the mod field must be set to 11; false otherwise.
> + /// The name is explained at ModFilter.
> + /// \param nnn The required value of the nnn field.
> ExtendedFilter(bool r, uint8_t nnn) :
> ModRMFilter(),
> R(r),
> @@ -177,7 +178,7 @@
> public:
> /// Constructor
> ///
> - /// @modRM - The required value of the full ModR/M byte.
> + /// \param modRM The required value of the full ModR/M byte.
> ExactFilter(uint8_t modRM) :
> ModRMFilter(),
> ModRM(modRM) {
>
> Modified: llvm/trunk/utils/TableGen/X86RecognizableInstr.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/X86RecognizableInstr.h?rev=163790&r1=163789&r2=163790&view=diff
> ==============================================================================
> --- llvm/trunk/utils/TableGen/X86RecognizableInstr.h (original)
> +++ llvm/trunk/utils/TableGen/X86RecognizableInstr.h Thu Sep 13 07:34:29 2012
> @@ -225,23 +225,23 @@
> /// emitInstructionSpecifier - Loads the instruction specifier for the current
> /// instruction into a DisassemblerTables.
> ///
> - /// @arg tables - The DisassemblerTables to populate with the specifier for
> + /// \param tables The DisassemblerTables to populate with the specifier for
> /// the current instruction.
> void emitInstructionSpecifier(DisassemblerTables &tables);
>
> /// emitDecodePath - Populates the proper fields in the decode tables
> /// corresponding to the decode paths for this instruction.
> ///
> - /// @arg tables - The DisassemblerTables to populate with the decode
> + /// \param tables The DisassemblerTables to populate with the decode
> /// decode information for the current instruction.
> void emitDecodePath(DisassemblerTables &tables) const;
>
> /// Constructor - Initializes a RecognizableInstr with the appropriate fields
> /// from a CodeGenInstruction.
> ///
> - /// @arg tables - The DisassemblerTables that the specifier will be added to.
> - /// @arg insn - The CodeGenInstruction to extract information from.
> - /// @arg uid - The unique ID of the current instruction.
> + /// \param tables The DisassemblerTables that the specifier will be added to.
> + /// \param insn The CodeGenInstruction to extract information from.
> + /// \param uid The unique ID of the current instruction.
> RecognizableInstr(DisassemblerTables &tables,
> const CodeGenInstruction &insn,
> InstrUID uid);
> @@ -249,11 +249,11 @@
> /// processInstr - Accepts a CodeGenInstruction and loads decode information
> /// for it into a DisassemblerTables if appropriate.
> ///
> - /// @arg tables - The DiassemblerTables to be populated with decode
> + /// \param tables The DiassemblerTables to be populated with decode
> /// information.
> - /// @arg insn - The CodeGenInstruction to be used as a source for this
> + /// \param insn The CodeGenInstruction to be used as a source for this
> /// information.
> - /// @uid - The unique ID of the instruction.
> + /// \param uid The unique ID of the instruction.
> static void processInstr(DisassemblerTables &tables,
> const CodeGenInstruction &insn,
> InstrUID uid);
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list