Index: llvm/trunk/include/llvm-c/lto.h =================================================================== --- llvm/trunk/include/llvm-c/lto.h +++ llvm/trunk/include/llvm-c/lto.h @@ -190,7 +190,7 @@ const char *path); /** - * \brief Loads an object file in its own context. + * Loads an object file in its own context. * * Loads an object file in its own LLVMContext. This function call is * thread-safe. However, modules created this way should not be merged into an @@ -205,7 +205,7 @@ const char *path); /** - * \brief Loads an object file in the codegen context. + * Loads an object file in the codegen context. * * Loads an object file into the same context as \c cg. The module is safe to * add using \a lto_codegen_add_module(). @@ -345,7 +345,7 @@ lto_codegen_create(void); /** - * \brief Instantiate a code generator in its own context. + * Instantiate a code generator in its own context. * * Instantiates a code generator in its own context. Modules added via \a * lto_codegen_add_module() must have all been created in the same context, @@ -539,7 +539,7 @@ lto_bool_t ShouldInternalize); /** - * \brief Set whether to embed uselists in bitcode. + * Set whether to embed uselists in bitcode. * * Sets whether \a lto_codegen_write_merged_modules() should embed uselists in * output bitcode. This should be turned on for all -save-temps output. Index: llvm/trunk/include/llvm/ADT/APFloat.h =================================================================== --- llvm/trunk/include/llvm/ADT/APFloat.h +++ llvm/trunk/include/llvm/ADT/APFloat.h @@ -1215,7 +1215,7 @@ return X; } -/// \brief Returns the negated value of the argument. +/// Returns the negated value of the argument. inline APFloat neg(APFloat X) { X.changeSign(); return X; Index: llvm/trunk/include/llvm/ADT/APInt.h =================================================================== --- llvm/trunk/include/llvm/ADT/APInt.h +++ llvm/trunk/include/llvm/ADT/APInt.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief This file implements a class to represent arbitrary precision +/// This file implements a class to represent arbitrary precision /// integral constant values and operations on them. /// //===----------------------------------------------------------------------===// @@ -40,7 +40,7 @@ // APInt Class //===----------------------------------------------------------------------===// -/// \brief Class for arbitrary precision integers. +/// Class for arbitrary precision integers. /// /// APInt is a functional replacement for common case unsigned integer type like /// "unsigned", "unsigned long" or "uint64_t", but also allows non-byte-width @@ -94,7 +94,7 @@ friend class APSInt; - /// \brief Fast internal constructor + /// Fast internal constructor /// /// This constructor is used only internally for speed of construction of /// temporaries. It is unsafe for general use so it is not public. @@ -102,19 +102,19 @@ U.pVal = val; } - /// \brief Determine if this APInt just has one word to store value. + /// Determine if this APInt just has one word to store value. /// /// \returns true if the number of bits <= 64, false otherwise. bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; } - /// \brief Determine which word a bit is in. + /// Determine which word a bit is in. /// /// \returns the word position for the specified bit position. static unsigned whichWord(unsigned bitPosition) { return bitPosition / APINT_BITS_PER_WORD; } - /// \brief Determine which bit in a word a bit is in. + /// Determine which bit in a word a bit is in. /// /// \returns the bit position in a word for the specified bit position /// in the APInt. @@ -122,7 +122,7 @@ return bitPosition % APINT_BITS_PER_WORD; } - /// \brief Get a single bit mask. + /// Get a single bit mask. /// /// \returns a uint64_t with only bit at "whichBit(bitPosition)" set /// This method generates and returns a uint64_t (word) mask for a single @@ -132,7 +132,7 @@ return 1ULL << whichBit(bitPosition); } - /// \brief Clear unused high order bits + /// Clear unused high order bits /// /// This method is used internally to clear the top "N" bits in the high order /// word that are not used by the APInt. This is needed after the most @@ -151,7 +151,7 @@ return *this; } - /// \brief Get the word corresponding to a bit position + /// Get the word corresponding to a bit position /// \returns the corresponding word for the specified bit position. uint64_t getWord(unsigned bitPosition) const { return isSingleWord() ? U.VAL : U.pVal[whichWord(bitPosition)]; @@ -162,7 +162,7 @@ /// value of any bits upon return. Caller should populate the bits after. void reallocate(unsigned NewBitWidth); - /// \brief Convert a char array into an APInt + /// Convert a char array into an APInt /// /// \param radix 2, 8, 10, 16, or 36 /// Converts a string into a number. The string must be non-empty @@ -176,7 +176,7 @@ /// result to hold the input. void fromString(unsigned numBits, StringRef str, uint8_t radix); - /// \brief An internal division function for dividing APInts. + /// An internal division function for dividing APInts. /// /// This is used by the toString method to divide by the radix. It simply /// provides a more convenient form of divide for internal use since KnuthDiv @@ -258,7 +258,7 @@ /// \name Constructors /// @{ - /// \brief Create a new APInt of numBits width, initialized as val. + /// Create a new APInt of numBits width, initialized as val. /// /// If isSigned is true then val is treated as if it were a signed value /// (i.e. as an int64_t) and the appropriate sign extension to the bit width @@ -279,7 +279,7 @@ } } - /// \brief Construct an APInt of numBits width, initialized as bigVal[]. + /// Construct an APInt of numBits width, initialized as bigVal[]. /// /// Note that bigVal.size() can be smaller or larger than the corresponding /// bit width but any extraneous bits will be dropped. @@ -297,7 +297,7 @@ /// constructor. APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[]); - /// \brief Construct an APInt from a string representation. + /// Construct an APInt from a string representation. /// /// This constructor interprets the string \p str in the given radix. The /// interpretation stops when the first character that is not suitable for the @@ -319,26 +319,26 @@ initSlowCase(that); } - /// \brief Move Constructor. + /// Move Constructor. APInt(APInt &&that) : BitWidth(that.BitWidth) { memcpy(&U, &that.U, sizeof(U)); that.BitWidth = 0; } - /// \brief Destructor. + /// Destructor. ~APInt() { if (needsCleanup()) delete[] U.pVal; } - /// \brief Default constructor that creates an uninteresting APInt + /// Default constructor that creates an uninteresting APInt /// representing a 1-bit zero value. /// /// This is useful for object deserialization (pair this with the static /// method Read). explicit APInt() : BitWidth(1) { U.VAL = 0; } - /// \brief Returns whether this instance allocated memory. + /// Returns whether this instance allocated memory. bool needsCleanup() const { return !isSingleWord(); } /// Used to insert APInt objects, or objects that contain APInt objects, into @@ -349,33 +349,33 @@ /// \name Value Tests /// @{ - /// \brief Determine sign of this APInt. + /// Determine sign of this APInt. /// /// This tests the high bit of this APInt to determine if it is set. /// /// \returns true if this APInt is negative, false otherwise bool isNegative() const { return (*this)[BitWidth - 1]; } - /// \brief Determine if this APInt Value is non-negative (>= 0) + /// Determine if this APInt Value is non-negative (>= 0) /// /// This tests the high bit of the APInt to determine if it is unset. bool isNonNegative() const { return !isNegative(); } - /// \brief Determine if sign bit of this APInt is set. + /// Determine if sign bit of this APInt is set. /// /// This tests the high bit of this APInt to determine if it is set. /// /// \returns true if this APInt has its sign bit set, false otherwise. bool isSignBitSet() const { return (*this)[BitWidth-1]; } - /// \brief Determine if sign bit of this APInt is clear. + /// Determine if sign bit of this APInt is clear. /// /// This tests the high bit of this APInt to determine if it is clear. /// /// \returns true if this APInt has its sign bit clear, false otherwise. bool isSignBitClear() const { return !isSignBitSet(); } - /// \brief Determine if this APInt Value is positive. + /// Determine if this APInt Value is positive. /// /// This tests if the value of this APInt is positive (> 0). Note /// that 0 is not a positive value. @@ -383,7 +383,7 @@ /// \returns true if this APInt is positive. bool isStrictlyPositive() const { return isNonNegative() && !isNullValue(); } - /// \brief Determine if all bits are set + /// Determine if all bits are set /// /// This checks to see if the value has all bits of the APInt are set or not. bool isAllOnesValue() const { @@ -392,13 +392,13 @@ return countTrailingOnesSlowCase() == BitWidth; } - /// \brief Determine if all bits are clear + /// Determine if all bits are clear /// /// This checks to see if the value has all bits of the APInt are clear or /// not. bool isNullValue() const { return !*this; } - /// \brief Determine if this is a value of 1. + /// Determine if this is a value of 1. /// /// This checks to see if the value of this APInt is one. bool isOneValue() const { @@ -407,13 +407,13 @@ return countLeadingZerosSlowCase() == BitWidth - 1; } - /// \brief Determine if this is the largest unsigned value. + /// Determine if this is the largest unsigned value. /// /// This checks to see if the value of this APInt is the maximum unsigned /// value for the APInt's bit width. bool isMaxValue() const { return isAllOnesValue(); } - /// \brief Determine if this is the largest signed value. + /// Determine if this is the largest signed value. /// /// This checks to see if the value of this APInt is the maximum signed /// value for the APInt's bit width. @@ -423,13 +423,13 @@ return !isNegative() && countTrailingOnesSlowCase() == BitWidth - 1; } - /// \brief Determine if this is the smallest unsigned value. + /// Determine if this is the smallest unsigned value. /// /// This checks to see if the value of this APInt is the minimum unsigned /// value for the APInt's bit width. bool isMinValue() const { return isNullValue(); } - /// \brief Determine if this is the smallest signed value. + /// Determine if this is the smallest signed value. /// /// This checks to see if the value of this APInt is the minimum signed /// value for the APInt's bit width. @@ -439,19 +439,19 @@ return isNegative() && countTrailingZerosSlowCase() == BitWidth - 1; } - /// \brief Check if this APInt has an N-bits unsigned integer value. + /// Check if this APInt has an N-bits unsigned integer value. bool isIntN(unsigned N) const { assert(N && "N == 0 ???"); return getActiveBits() <= N; } - /// \brief Check if this APInt has an N-bits signed integer value. + /// Check if this APInt has an N-bits signed integer value. bool isSignedIntN(unsigned N) const { assert(N && "N == 0 ???"); return getMinSignedBits() <= N; } - /// \brief Check if this APInt's value is a power of two greater than zero. + /// Check if this APInt's value is a power of two greater than zero. /// /// \returns true if the argument APInt value is a power of two > 0. bool isPowerOf2() const { @@ -460,12 +460,12 @@ return countPopulationSlowCase() == 1; } - /// \brief Check if the APInt's value is returned by getSignMask. + /// Check if the APInt's value is returned by getSignMask. /// /// \returns true if this is the value returned by getSignMask. bool isSignMask() const { return isMinSignedValue(); } - /// \brief Convert APInt to a boolean value. + /// Convert APInt to a boolean value. /// /// This converts the APInt to a boolean value as a test against zero. bool getBoolValue() const { return !!*this; } @@ -476,7 +476,7 @@ return ugt(Limit) ? Limit : getZExtValue(); } - /// \brief Check if the APInt consists of a repeated bit pattern. + /// Check if the APInt consists of a repeated bit pattern. /// /// e.g. 0x01010101 satisfies isSplat(8). /// \param SplatSizeInBits The size of the pattern in bits. Must divide bit @@ -505,7 +505,7 @@ return (Ones > 0) && ((Ones + countLeadingZerosSlowCase()) == BitWidth); } - /// \brief Return true if this APInt value contains a sequence of ones with + /// Return true if this APInt value contains a sequence of ones with /// the remainder zero. bool isShiftedMask() const { if (isSingleWord()) @@ -519,29 +519,29 @@ /// \name Value Generators /// @{ - /// \brief Gets maximum unsigned value of APInt for specific bit width. + /// Gets maximum unsigned value of APInt for specific bit width. static APInt getMaxValue(unsigned numBits) { return getAllOnesValue(numBits); } - /// \brief Gets maximum signed value of APInt for a specific bit width. + /// Gets maximum signed value of APInt for a specific bit width. static APInt getSignedMaxValue(unsigned numBits) { APInt API = getAllOnesValue(numBits); API.clearBit(numBits - 1); return API; } - /// \brief Gets minimum unsigned value of APInt for a specific bit width. + /// Gets minimum unsigned value of APInt for a specific bit width. static APInt getMinValue(unsigned numBits) { return APInt(numBits, 0); } - /// \brief Gets minimum signed value of APInt for a specific bit width. + /// Gets minimum signed value of APInt for a specific bit width. static APInt getSignedMinValue(unsigned numBits) { APInt API(numBits, 0); API.setBit(numBits - 1); return API; } - /// \brief Get the SignMask for a specific bit width. + /// Get the SignMask for a specific bit width. /// /// This is just a wrapper function of getSignedMinValue(), and it helps code /// readability when we want to get a SignMask. @@ -549,19 +549,19 @@ return getSignedMinValue(BitWidth); } - /// \brief Get the all-ones value. + /// Get the all-ones value. /// /// \returns the all-ones value for an APInt of the specified bit-width. static APInt getAllOnesValue(unsigned numBits) { return APInt(numBits, WORD_MAX, true); } - /// \brief Get the '0' value. + /// Get the '0' value. /// /// \returns the '0' value for an APInt of the specified bit-width. static APInt getNullValue(unsigned numBits) { return APInt(numBits, 0); } - /// \brief Compute an APInt containing numBits highbits from this APInt. + /// Compute an APInt containing numBits highbits from this APInt. /// /// Get an APInt with the same BitWidth as this APInt, just zero mask /// the low bits and right shift to the least significant bit. @@ -569,7 +569,7 @@ /// \returns the high "numBits" bits of this APInt. APInt getHiBits(unsigned numBits) const; - /// \brief Compute an APInt containing numBits lowbits from this APInt. + /// Compute an APInt containing numBits lowbits from this APInt. /// /// Get an APInt with the same BitWidth as this APInt, just zero mask /// the high bits. @@ -577,14 +577,14 @@ /// \returns the low "numBits" bits of this APInt. APInt getLoBits(unsigned numBits) const; - /// \brief Return an APInt with exactly one bit set in the result. + /// Return an APInt with exactly one bit set in the result. static APInt getOneBitSet(unsigned numBits, unsigned BitNo) { APInt Res(numBits, 0); Res.setBit(BitNo); return Res; } - /// \brief Get a value with a block of bits set. + /// Get a value with a block of bits set. /// /// Constructs an APInt value that has a contiguous range of bits set. The /// bits from loBit (inclusive) to hiBit (exclusive) will be set. All other @@ -603,7 +603,7 @@ return Res; } - /// \brief Get a value with upper bits starting at loBit set. + /// Get a value with upper bits starting at loBit set. /// /// Constructs an APInt value that has a contiguous range of bits set. The /// bits from loBit (inclusive) to numBits (exclusive) will be set. All other @@ -620,7 +620,7 @@ return Res; } - /// \brief Get a value with high bits set + /// Get a value with high bits set /// /// Constructs an APInt value that has the top hiBitsSet bits set. /// @@ -632,7 +632,7 @@ return Res; } - /// \brief Get a value with low bits set + /// Get a value with low bits set /// /// Constructs an APInt value that has the bottom loBitsSet bits set. /// @@ -644,10 +644,10 @@ return Res; } - /// \brief Return a value containing V broadcasted over NewLen bits. + /// Return a value containing V broadcasted over NewLen bits. static APInt getSplat(unsigned NewLen, const APInt &V); - /// \brief Determine if two APInts have the same value, after zero-extending + /// Determine if two APInts have the same value, after zero-extending /// one of them (if needed!) to ensure that the bit-widths match. static bool isSameValue(const APInt &I1, const APInt &I2) { if (I1.getBitWidth() == I2.getBitWidth()) @@ -659,7 +659,7 @@ return I1.zext(I2.getBitWidth()) == I2; } - /// \brief Overload to compute a hash_code for an APInt value. + /// Overload to compute a hash_code for an APInt value. friend hash_code hash_value(const APInt &Arg); /// This function returns a pointer to the internal storage of the APInt. @@ -675,7 +675,7 @@ /// \name Unary Operators /// @{ - /// \brief Postfix increment operator. + /// Postfix increment operator. /// /// Increments *this by 1. /// @@ -686,12 +686,12 @@ return API; } - /// \brief Prefix increment operator. + /// Prefix increment operator. /// /// \returns *this incremented by one APInt &operator++(); - /// \brief Postfix decrement operator. + /// Postfix decrement operator. /// /// Decrements *this by 1. /// @@ -702,12 +702,12 @@ return API; } - /// \brief Prefix decrement operator. + /// Prefix decrement operator. /// /// \returns *this decremented by one. APInt &operator--(); - /// \brief Logical negation operator. + /// Logical negation operator. /// /// Performs logical negation operation on this APInt. /// @@ -722,7 +722,7 @@ /// \name Assignment Operators /// @{ - /// \brief Copy assignment operator. + /// Copy assignment operator. /// /// \returns *this after assignment of RHS. APInt &operator=(const APInt &RHS) { @@ -758,7 +758,7 @@ return *this; } - /// \brief Assignment operator. + /// Assignment operator. /// /// The RHS value is assigned to *this. If the significant bits in RHS exceed /// the bit width, the excess bits are truncated. If the bit width is larger @@ -776,7 +776,7 @@ return *this; } - /// \brief Bitwise AND assignment operator. + /// Bitwise AND assignment operator. /// /// Performs a bitwise AND operation on this APInt and RHS. The result is /// assigned to *this. @@ -791,7 +791,7 @@ return *this; } - /// \brief Bitwise AND assignment operator. + /// Bitwise AND assignment operator. /// /// Performs a bitwise AND operation on this APInt and RHS. RHS is /// logically zero-extended or truncated to match the bit-width of @@ -806,7 +806,7 @@ return *this; } - /// \brief Bitwise OR assignment operator. + /// Bitwise OR assignment operator. /// /// Performs a bitwise OR operation on this APInt and RHS. The result is /// assigned *this; @@ -821,7 +821,7 @@ return *this; } - /// \brief Bitwise OR assignment operator. + /// Bitwise OR assignment operator. /// /// Performs a bitwise OR operation on this APInt and RHS. RHS is /// logically zero-extended or truncated to match the bit-width of @@ -836,7 +836,7 @@ return *this; } - /// \brief Bitwise XOR assignment operator. + /// Bitwise XOR assignment operator. /// /// Performs a bitwise XOR operation on this APInt and RHS. The result is /// assigned to *this. @@ -851,7 +851,7 @@ return *this; } - /// \brief Bitwise XOR assignment operator. + /// Bitwise XOR assignment operator. /// /// Performs a bitwise XOR operation on this APInt and RHS. RHS is /// logically zero-extended or truncated to match the bit-width of @@ -866,7 +866,7 @@ return *this; } - /// \brief Multiplication assignment operator. + /// Multiplication assignment operator. /// /// Multiplies this APInt by RHS and assigns the result to *this. /// @@ -874,7 +874,7 @@ APInt &operator*=(const APInt &RHS); APInt &operator*=(uint64_t RHS); - /// \brief Addition assignment operator. + /// Addition assignment operator. /// /// Adds RHS to *this and assigns the result to *this. /// @@ -882,7 +882,7 @@ APInt &operator+=(const APInt &RHS); APInt &operator+=(uint64_t RHS); - /// \brief Subtraction assignment operator. + /// Subtraction assignment operator. /// /// Subtracts RHS from *this and assigns the result to *this. /// @@ -890,7 +890,7 @@ APInt &operator-=(const APInt &RHS); APInt &operator-=(uint64_t RHS); - /// \brief Left-shift assignment function. + /// Left-shift assignment function. /// /// Shifts *this left by shiftAmt and assigns the result to *this. /// @@ -908,7 +908,7 @@ return *this; } - /// \brief Left-shift assignment function. + /// Left-shift assignment function. /// /// Shifts *this left by shiftAmt and assigns the result to *this. /// @@ -919,22 +919,22 @@ /// \name Binary Operators /// @{ - /// \brief Multiplication operator. + /// Multiplication operator. /// /// Multiplies this APInt by RHS and returns the result. APInt operator*(const APInt &RHS) const; - /// \brief Left logical shift operator. + /// Left logical shift operator. /// /// Shifts this APInt left by \p Bits and returns the result. APInt operator<<(unsigned Bits) const { return shl(Bits); } - /// \brief Left logical shift operator. + /// Left logical shift operator. /// /// Shifts this APInt left by \p Bits and returns the result. APInt operator<<(const APInt &Bits) const { return shl(Bits); } - /// \brief Arithmetic right-shift function. + /// Arithmetic right-shift function. /// /// Arithmetic right-shift this APInt by shiftAmt. APInt ashr(unsigned ShiftAmt) const { @@ -958,7 +958,7 @@ ashrSlowCase(ShiftAmt); } - /// \brief Logical right-shift function. + /// Logical right-shift function. /// /// Logical right-shift this APInt by shiftAmt. APInt lshr(unsigned shiftAmt) const { @@ -980,7 +980,7 @@ lshrSlowCase(ShiftAmt); } - /// \brief Left-shift function. + /// Left-shift function. /// /// Left-shift this APInt by shiftAmt. APInt shl(unsigned shiftAmt) const { @@ -989,13 +989,13 @@ return R; } - /// \brief Rotate left by rotateAmt. + /// Rotate left by rotateAmt. APInt rotl(unsigned rotateAmt) const; - /// \brief Rotate right by rotateAmt. + /// Rotate right by rotateAmt. APInt rotr(unsigned rotateAmt) const; - /// \brief Arithmetic right-shift function. + /// Arithmetic right-shift function. /// /// Arithmetic right-shift this APInt by shiftAmt. APInt ashr(const APInt &ShiftAmt) const { @@ -1007,7 +1007,7 @@ /// Arithmetic right-shift this APInt by shiftAmt in place. void ashrInPlace(const APInt &shiftAmt); - /// \brief Logical right-shift function. + /// Logical right-shift function. /// /// Logical right-shift this APInt by shiftAmt. APInt lshr(const APInt &ShiftAmt) const { @@ -1019,7 +1019,7 @@ /// Logical right-shift this APInt by ShiftAmt in place. void lshrInPlace(const APInt &ShiftAmt); - /// \brief Left-shift function. + /// Left-shift function. /// /// Left-shift this APInt by shiftAmt. APInt shl(const APInt &ShiftAmt) const { @@ -1028,13 +1028,13 @@ return R; } - /// \brief Rotate left by rotateAmt. + /// Rotate left by rotateAmt. APInt rotl(const APInt &rotateAmt) const; - /// \brief Rotate right by rotateAmt. + /// Rotate right by rotateAmt. APInt rotr(const APInt &rotateAmt) const; - /// \brief Unsigned division operation. + /// Unsigned division operation. /// /// Perform an unsigned divide operation on this APInt by RHS. Both this and /// RHS are treated as unsigned quantities for purposes of this division. @@ -1043,13 +1043,13 @@ APInt udiv(const APInt &RHS) const; APInt udiv(uint64_t RHS) const; - /// \brief Signed division function for APInt. + /// Signed division function for APInt. /// /// Signed divide this APInt by APInt RHS. APInt sdiv(const APInt &RHS) const; APInt sdiv(int64_t RHS) const; - /// \brief Unsigned remainder operation. + /// Unsigned remainder operation. /// /// Perform an unsigned remainder operation on this APInt with RHS being the /// divisor. Both this and RHS are treated as unsigned quantities for purposes @@ -1061,13 +1061,13 @@ APInt urem(const APInt &RHS) const; uint64_t urem(uint64_t RHS) const; - /// \brief Function for signed remainder operation. + /// Function for signed remainder operation. /// /// Signed remainder operation on APInt. APInt srem(const APInt &RHS) const; int64_t srem(int64_t RHS) const; - /// \brief Dual division/remainder interface. + /// Dual division/remainder interface. /// /// Sometimes it is convenient to divide two APInt values and obtain both the /// quotient and remainder. This function does both operations in the same @@ -1095,7 +1095,7 @@ APInt sshl_ov(const APInt &Amt, bool &Overflow) const; APInt ushl_ov(const APInt &Amt, bool &Overflow) const; - /// \brief Array-indexing support. + /// Array-indexing support. /// /// \returns the bit value at bitPosition bool operator[](unsigned bitPosition) const { @@ -1107,7 +1107,7 @@ /// \name Comparison Operators /// @{ - /// \brief Equality operator. + /// Equality operator. /// /// Compares this APInt with RHS for the validity of the equality /// relationship. @@ -1118,7 +1118,7 @@ return EqualSlowCase(RHS); } - /// \brief Equality operator. + /// Equality operator. /// /// Compares this APInt with a uint64_t for the validity of the equality /// relationship. @@ -1128,7 +1128,7 @@ return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() == Val; } - /// \brief Equality comparison. + /// Equality comparison. /// /// Compares this APInt with RHS for the validity of the equality /// relationship. @@ -1136,7 +1136,7 @@ /// \returns true if *this == Val bool eq(const APInt &RHS) const { return (*this) == RHS; } - /// \brief Inequality operator. + /// Inequality operator. /// /// Compares this APInt with RHS for the validity of the inequality /// relationship. @@ -1144,7 +1144,7 @@ /// \returns true if *this != Val bool operator!=(const APInt &RHS) const { return !((*this) == RHS); } - /// \brief Inequality operator. + /// Inequality operator. /// /// Compares this APInt with a uint64_t for the validity of the inequality /// relationship. @@ -1152,7 +1152,7 @@ /// \returns true if *this != Val bool operator!=(uint64_t Val) const { return !((*this) == Val); } - /// \brief Inequality comparison + /// Inequality comparison /// /// Compares this APInt with RHS for the validity of the inequality /// relationship. @@ -1160,7 +1160,7 @@ /// \returns true if *this != Val bool ne(const APInt &RHS) const { return !((*this) == RHS); } - /// \brief Unsigned less than comparison + /// Unsigned less than comparison /// /// Regards both *this and RHS as unsigned quantities and compares them for /// the validity of the less-than relationship. @@ -1168,7 +1168,7 @@ /// \returns true if *this < RHS when both are considered unsigned. bool ult(const APInt &RHS) const { return compare(RHS) < 0; } - /// \brief Unsigned less than comparison + /// Unsigned less than comparison /// /// Regards both *this as an unsigned quantity and compares it with RHS for /// the validity of the less-than relationship. @@ -1179,7 +1179,7 @@ return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() < RHS; } - /// \brief Signed less than comparison + /// Signed less than comparison /// /// Regards both *this and RHS as signed quantities and compares them for /// validity of the less-than relationship. @@ -1187,7 +1187,7 @@ /// \returns true if *this < RHS when both are considered signed. bool slt(const APInt &RHS) const { return compareSigned(RHS) < 0; } - /// \brief Signed less than comparison + /// Signed less than comparison /// /// Regards both *this as a signed quantity and compares it with RHS for /// the validity of the less-than relationship. @@ -1198,7 +1198,7 @@ : getSExtValue() < RHS; } - /// \brief Unsigned less or equal comparison + /// Unsigned less or equal comparison /// /// Regards both *this and RHS as unsigned quantities and compares them for /// validity of the less-or-equal relationship. @@ -1206,7 +1206,7 @@ /// \returns true if *this <= RHS when both are considered unsigned. bool ule(const APInt &RHS) const { return compare(RHS) <= 0; } - /// \brief Unsigned less or equal comparison + /// Unsigned less or equal comparison /// /// Regards both *this as an unsigned quantity and compares it with RHS for /// the validity of the less-or-equal relationship. @@ -1214,7 +1214,7 @@ /// \returns true if *this <= RHS when considered unsigned. bool ule(uint64_t RHS) const { return !ugt(RHS); } - /// \brief Signed less or equal comparison + /// Signed less or equal comparison /// /// Regards both *this and RHS as signed quantities and compares them for /// validity of the less-or-equal relationship. @@ -1222,7 +1222,7 @@ /// \returns true if *this <= RHS when both are considered signed. bool sle(const APInt &RHS) const { return compareSigned(RHS) <= 0; } - /// \brief Signed less or equal comparison + /// Signed less or equal comparison /// /// Regards both *this as a signed quantity and compares it with RHS for the /// validity of the less-or-equal relationship. @@ -1230,7 +1230,7 @@ /// \returns true if *this <= RHS when considered signed. bool sle(uint64_t RHS) const { return !sgt(RHS); } - /// \brief Unsigned greather than comparison + /// Unsigned greather than comparison /// /// Regards both *this and RHS as unsigned quantities and compares them for /// the validity of the greater-than relationship. @@ -1238,7 +1238,7 @@ /// \returns true if *this > RHS when both are considered unsigned. bool ugt(const APInt &RHS) const { return !ule(RHS); } - /// \brief Unsigned greater than comparison + /// Unsigned greater than comparison /// /// Regards both *this as an unsigned quantity and compares it with RHS for /// the validity of the greater-than relationship. @@ -1249,7 +1249,7 @@ return (!isSingleWord() && getActiveBits() > 64) || getZExtValue() > RHS; } - /// \brief Signed greather than comparison + /// Signed greather than comparison /// /// Regards both *this and RHS as signed quantities and compares them for the /// validity of the greater-than relationship. @@ -1257,7 +1257,7 @@ /// \returns true if *this > RHS when both are considered signed. bool sgt(const APInt &RHS) const { return !sle(RHS); } - /// \brief Signed greater than comparison + /// Signed greater than comparison /// /// Regards both *this as a signed quantity and compares it with RHS for /// the validity of the greater-than relationship. @@ -1268,7 +1268,7 @@ : getSExtValue() > RHS; } - /// \brief Unsigned greater or equal comparison + /// Unsigned greater or equal comparison /// /// Regards both *this and RHS as unsigned quantities and compares them for /// validity of the greater-or-equal relationship. @@ -1276,7 +1276,7 @@ /// \returns true if *this >= RHS when both are considered unsigned. bool uge(const APInt &RHS) const { return !ult(RHS); } - /// \brief Unsigned greater or equal comparison + /// Unsigned greater or equal comparison /// /// Regards both *this as an unsigned quantity and compares it with RHS for /// the validity of the greater-or-equal relationship. @@ -1284,7 +1284,7 @@ /// \returns true if *this >= RHS when considered unsigned. bool uge(uint64_t RHS) const { return !ult(RHS); } - /// \brief Signed greater or equal comparison + /// Signed greater or equal comparison /// /// Regards both *this and RHS as signed quantities and compares them for /// validity of the greater-or-equal relationship. @@ -1292,7 +1292,7 @@ /// \returns true if *this >= RHS when both are considered signed. bool sge(const APInt &RHS) const { return !slt(RHS); } - /// \brief Signed greater or equal comparison + /// Signed greater or equal comparison /// /// Regards both *this as a signed quantity and compares it with RHS for /// the validity of the greater-or-equal relationship. @@ -1321,13 +1321,13 @@ /// \name Resizing Operators /// @{ - /// \brief Truncate to new width. + /// Truncate to new width. /// /// Truncate the APInt to a specified width. It is an error to specify a width /// that is greater than or equal to the current width. APInt trunc(unsigned width) const; - /// \brief Sign extend to a new width. + /// Sign extend to a new width. /// /// This operation sign extends the APInt to a new width. If the high order /// bit is set, the fill on the left will be done with 1 bits, otherwise zero. @@ -1335,32 +1335,32 @@ /// current width. APInt sext(unsigned width) const; - /// \brief Zero extend to a new width. + /// Zero extend to a new width. /// /// This operation zero extends the APInt to a new width. The high order bits /// are filled with 0 bits. It is an error to specify a width that is less /// than or equal to the current width. APInt zext(unsigned width) const; - /// \brief Sign extend or truncate to width + /// Sign extend or truncate to width /// /// Make this APInt have the bit width given by \p width. The value is sign /// extended, truncated, or left alone to make it that width. APInt sextOrTrunc(unsigned width) const; - /// \brief Zero extend or truncate to width + /// Zero extend or truncate to width /// /// Make this APInt have the bit width given by \p width. The value is zero /// extended, truncated, or left alone to make it that width. APInt zextOrTrunc(unsigned width) const; - /// \brief Sign extend or truncate to width + /// Sign extend or truncate to width /// /// Make this APInt have the bit width given by \p width. The value is sign /// extended, or left alone to make it that width. APInt sextOrSelf(unsigned width) const; - /// \brief Zero extend or truncate to width + /// Zero extend or truncate to width /// /// Make this APInt have the bit width given by \p width. The value is zero /// extended, or left alone to make it that width. @@ -1370,7 +1370,7 @@ /// \name Bit Manipulation Operators /// @{ - /// \brief Set every bit to 1. + /// Set every bit to 1. void setAllBits() { if (isSingleWord()) U.VAL = WORD_MAX; @@ -1381,7 +1381,7 @@ clearUnusedBits(); } - /// \brief Set a given bit to 1. + /// Set a given bit to 1. /// /// Set the given bit to 1 whose position is given as "bitPosition". void setBit(unsigned BitPosition) { @@ -1432,7 +1432,7 @@ return setBits(BitWidth - hiBits, BitWidth); } - /// \brief Set every bit to 0. + /// Set every bit to 0. void clearAllBits() { if (isSingleWord()) U.VAL = 0; @@ -1440,7 +1440,7 @@ memset(U.pVal, 0, getNumWords() * APINT_WORD_SIZE); } - /// \brief Set a given bit to 0. + /// Set a given bit to 0. /// /// Set the given bit to 0 whose position is given as "bitPosition". void clearBit(unsigned BitPosition) { @@ -1457,7 +1457,7 @@ clearBit(BitWidth - 1); } - /// \brief Toggle every bit to its opposite value. + /// Toggle every bit to its opposite value. void flipAllBits() { if (isSingleWord()) { U.VAL ^= WORD_MAX; @@ -1467,7 +1467,7 @@ } } - /// \brief Toggles a given bit to its opposite value. + /// Toggles a given bit to its opposite value. /// /// Toggle a given bit to its opposite value whose position is given /// as "bitPosition". @@ -1489,17 +1489,17 @@ /// \name Value Characterization Functions /// @{ - /// \brief Return the number of bits in the APInt. + /// Return the number of bits in the APInt. unsigned getBitWidth() const { return BitWidth; } - /// \brief Get the number of words. + /// Get the number of words. /// /// Here one word's bitwidth equals to that of uint64_t. /// /// \returns the number of words to hold the integer value of this APInt. unsigned getNumWords() const { return getNumWords(BitWidth); } - /// \brief Get the number of words. + /// Get the number of words. /// /// *NOTE* Here one word's bitwidth equals to that of uint64_t. /// @@ -1509,14 +1509,14 @@ return ((uint64_t)BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD; } - /// \brief Compute the number of active bits in the value + /// Compute the number of active bits in the value /// /// This function returns the number of active bits which is defined as the /// bit width minus the number of leading zeros. This is used in several /// computations to see how "wide" the value is. unsigned getActiveBits() const { return BitWidth - countLeadingZeros(); } - /// \brief Compute the number of active words in the value of this APInt. + /// Compute the number of active words in the value of this APInt. /// /// This is used in conjunction with getActiveData to extract the raw value of /// the APInt. @@ -1525,7 +1525,7 @@ return numActiveBits ? whichWord(numActiveBits - 1) + 1 : 1; } - /// \brief Get the minimum bit size for this signed APInt + /// Get the minimum bit size for this signed APInt /// /// Computes the minimum bit width for this APInt while considering it to be a /// signed (and probably negative) value. If the value is not negative, this @@ -1539,7 +1539,7 @@ return getActiveBits() + 1; } - /// \brief Get zero extended value + /// Get zero extended value /// /// This method attempts to return the value of this APInt as a zero extended /// uint64_t. The bitwidth must be <= 64 or the value must fit within a @@ -1551,7 +1551,7 @@ return U.pVal[0]; } - /// \brief Get sign extended value + /// Get sign extended value /// /// This method attempts to return the value of this APInt as a sign extended /// int64_t. The bit width must be <= 64 or the value must fit within an @@ -1563,13 +1563,13 @@ return int64_t(U.pVal[0]); } - /// \brief Get bits required for string value. + /// Get bits required for string value. /// /// This method determines how many bits are required to hold the APInt /// equivalent of the string given by \p str. static unsigned getBitsNeeded(StringRef str, uint8_t radix); - /// \brief The APInt version of the countLeadingZeros functions in + /// The APInt version of the countLeadingZeros functions in /// MathExtras.h. /// /// It counts the number of zeros from the most significant bit to the first @@ -1585,7 +1585,7 @@ return countLeadingZerosSlowCase(); } - /// \brief Count the number of leading one bits. + /// Count the number of leading one bits. /// /// This function is an APInt version of the countLeadingOnes /// functions in MathExtras.h. It counts the number of ones from the most @@ -1605,7 +1605,7 @@ return isNegative() ? countLeadingOnes() : countLeadingZeros(); } - /// \brief Count the number of trailing zero bits. + /// Count the number of trailing zero bits. /// /// This function is an APInt version of the countTrailingZeros /// functions in MathExtras.h. It counts the number of zeros from the least @@ -1619,7 +1619,7 @@ return countTrailingZerosSlowCase(); } - /// \brief Count the number of trailing one bits. + /// Count the number of trailing one bits. /// /// This function is an APInt version of the countTrailingOnes /// functions in MathExtras.h. It counts the number of ones from the least @@ -1633,7 +1633,7 @@ return countTrailingOnesSlowCase(); } - /// \brief Count the number of bits set. + /// Count the number of bits set. /// /// This function is an APInt version of the countPopulation functions /// in MathExtras.h. It counts the number of 1 bits in the APInt value. @@ -1667,7 +1667,7 @@ toString(Str, Radix, true, false); } - /// \brief Return the APInt as a std::string. + /// Return the APInt as a std::string. /// /// Note that this is an inefficient method. It is better to pass in a /// SmallVector/SmallString to the methods above to avoid thrashing the heap @@ -1681,16 +1681,16 @@ /// Value. APInt reverseBits() const; - /// \brief Converts this APInt to a double value. + /// Converts this APInt to a double value. double roundToDouble(bool isSigned) const; - /// \brief Converts this unsigned APInt to a double value. + /// Converts this unsigned APInt to a double value. double roundToDouble() const { return roundToDouble(false); } - /// \brief Converts this signed APInt to a double value. + /// Converts this signed APInt to a double value. double signedRoundToDouble() const { return roundToDouble(true); } - /// \brief Converts APInt bits to a double + /// Converts APInt bits to a double /// /// The conversion does not do a translation from integer to double, it just /// re-interprets the bits as a double. Note that it is valid to do this on @@ -1699,7 +1699,7 @@ return BitsToDouble(getWord(0)); } - /// \brief Converts APInt bits to a double + /// Converts APInt bits to a double /// /// The conversion does not do a translation from integer to float, it just /// re-interprets the bits as a float. Note that it is valid to do this on @@ -1708,7 +1708,7 @@ return BitsToFloat(getWord(0)); } - /// \brief Converts a double to APInt bits. + /// Converts a double to APInt bits. /// /// The conversion does not do a translation from double to integer, it just /// re-interprets the bits of the double. @@ -1716,7 +1716,7 @@ return APInt(sizeof(double) * CHAR_BIT, DoubleToBits(V)); } - /// \brief Converts a float to APInt bits. + /// Converts a float to APInt bits. /// /// The conversion does not do a translation from float to integer, it just /// re-interprets the bits of the float. @@ -1775,10 +1775,10 @@ return logBase2(); } - /// \brief Compute the square root + /// Compute the square root APInt sqrt() const; - /// \brief Get the absolute value; + /// Get the absolute value; /// /// If *this is < 0 then return -(*this), otherwise *this; APInt abs() const { @@ -1929,7 +1929,7 @@ /// Set the least significant BITS and clear the rest. static void tcSetLeastSignificantBits(WordType *, unsigned, unsigned bits); - /// \brief debug method + /// debug method void dump() const; /// @} @@ -1952,7 +1952,7 @@ inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; } -/// \brief Unary bitwise complement operator. +/// Unary bitwise complement operator. /// /// \returns an APInt that is the bitwise complement of \p v. inline APInt operator~(APInt v) { @@ -2085,27 +2085,27 @@ namespace APIntOps { -/// \brief Determine the smaller of two APInts considered to be signed. +/// Determine the smaller of two APInts considered to be signed. inline const APInt &smin(const APInt &A, const APInt &B) { return A.slt(B) ? A : B; } -/// \brief Determine the larger of two APInts considered to be signed. +/// Determine the larger of two APInts considered to be signed. inline const APInt &smax(const APInt &A, const APInt &B) { return A.sgt(B) ? A : B; } -/// \brief Determine the smaller of two APInts considered to be signed. +/// Determine the smaller of two APInts considered to be signed. inline const APInt &umin(const APInt &A, const APInt &B) { return A.ult(B) ? A : B; } -/// \brief Determine the larger of two APInts considered to be unsigned. +/// Determine the larger of two APInts considered to be unsigned. inline const APInt &umax(const APInt &A, const APInt &B) { return A.ugt(B) ? A : B; } -/// \brief Compute GCD of two unsigned APInt values. +/// Compute GCD of two unsigned APInt values. /// /// This function returns the greatest common divisor of the two APInt values /// using Stein's algorithm. @@ -2113,38 +2113,38 @@ /// \returns the greatest common divisor of A and B. APInt GreatestCommonDivisor(APInt A, APInt B); -/// \brief Converts the given APInt to a double value. +/// Converts the given APInt to a double value. /// /// Treats the APInt as an unsigned value for conversion purposes. inline double RoundAPIntToDouble(const APInt &APIVal) { return APIVal.roundToDouble(); } -/// \brief Converts the given APInt to a double value. +/// Converts the given APInt to a double value. /// /// Treats the APInt as a signed value for conversion purposes. inline double RoundSignedAPIntToDouble(const APInt &APIVal) { return APIVal.signedRoundToDouble(); } -/// \brief Converts the given APInt to a float vlalue. +/// Converts the given APInt to a float vlalue. inline float RoundAPIntToFloat(const APInt &APIVal) { return float(RoundAPIntToDouble(APIVal)); } -/// \brief Converts the given APInt to a float value. +/// Converts the given APInt to a float value. /// /// Treast the APInt as a signed value for conversion purposes. inline float RoundSignedAPIntToFloat(const APInt &APIVal) { return float(APIVal.signedRoundToDouble()); } -/// \brief Converts the given double value into a APInt. +/// Converts the given double value into a APInt. /// /// This function convert a double value to an APInt value. APInt RoundDoubleToAPInt(double Double, unsigned width); -/// \brief Converts a float value into a APInt. +/// Converts a float value into a APInt. /// /// Converts a float value into an APInt value. inline APInt RoundFloatToAPInt(float Float, unsigned width) { Index: llvm/trunk/include/llvm/ADT/APSInt.h =================================================================== --- llvm/trunk/include/llvm/ADT/APSInt.h +++ llvm/trunk/include/llvm/ADT/APSInt.h @@ -72,7 +72,7 @@ } using APInt::toString; - /// \brief Get the correctly-extended \c int64_t value. + /// Get the correctly-extended \c int64_t value. int64_t getExtValue() const { assert(getMinSignedBits() <= 64 && "Too many bits for int64_t"); return isSigned() ? getSExtValue() : getZExtValue(); @@ -279,13 +279,13 @@ : APInt::getSignedMinValue(numBits), Unsigned); } - /// \brief Determine if two APSInts have the same value, zero- or + /// Determine if two APSInts have the same value, zero- or /// sign-extending as needed. static bool isSameValue(const APSInt &I1, const APSInt &I2) { return !compareValues(I1, I2); } - /// \brief Compare underlying values of two numbers. + /// Compare underlying values of two numbers. static int compareValues(const APSInt &I1, const APSInt &I2) { if (I1.getBitWidth() == I2.getBitWidth() && I1.isSigned() == I2.isSigned()) return I1.IsUnsigned ? I1.compare(I2) : I1.compareSigned(I2); Index: llvm/trunk/include/llvm/ADT/ArrayRef.h =================================================================== --- llvm/trunk/include/llvm/ADT/ArrayRef.h +++ llvm/trunk/include/llvm/ADT/ArrayRef.h @@ -184,51 +184,51 @@ /// slice(n) - Chop off the first N elements of the array. ArrayRef slice(size_t N) const { return slice(N, size() - N); } - /// \brief Drop the first \p N elements of the array. + /// Drop the first \p N elements of the array. ArrayRef drop_front(size_t N = 1) const { assert(size() >= N && "Dropping more elements than exist"); return slice(N, size() - N); } - /// \brief Drop the last \p N elements of the array. + /// Drop the last \p N elements of the array. ArrayRef drop_back(size_t N = 1) const { assert(size() >= N && "Dropping more elements than exist"); return slice(0, size() - N); } - /// \brief Return a copy of *this with the first N elements satisfying the + /// Return a copy of *this with the first N elements satisfying the /// given predicate removed. template ArrayRef drop_while(PredicateT Pred) const { return ArrayRef(find_if_not(*this, Pred), end()); } - /// \brief Return a copy of *this with the first N elements not satisfying + /// Return a copy of *this with the first N elements not satisfying /// the given predicate removed. template ArrayRef drop_until(PredicateT Pred) const { return ArrayRef(find_if(*this, Pred), end()); } - /// \brief Return a copy of *this with only the first \p N elements. + /// Return a copy of *this with only the first \p N elements. ArrayRef take_front(size_t N = 1) const { if (N >= size()) return *this; return drop_back(size() - N); } - /// \brief Return a copy of *this with only the last \p N elements. + /// Return a copy of *this with only the last \p N elements. ArrayRef take_back(size_t N = 1) const { if (N >= size()) return *this; return drop_front(size() - N); } - /// \brief Return the first N elements of this Array that satisfy the given + /// Return the first N elements of this Array that satisfy the given /// predicate. template ArrayRef take_while(PredicateT Pred) const { return ArrayRef(begin(), find_if_not(*this, Pred)); } - /// \brief Return the first N elements of this Array that don't satisfy the + /// Return the first N elements of this Array that don't satisfy the /// given predicate. template ArrayRef take_until(PredicateT Pred) const { return ArrayRef(begin(), find_if(*this, Pred)); @@ -358,7 +358,7 @@ return slice(N, this->size() - N); } - /// \brief Drop the first \p N elements of the array. + /// Drop the first \p N elements of the array. MutableArrayRef drop_front(size_t N = 1) const { assert(this->size() >= N && "Dropping more elements than exist"); return slice(N, this->size() - N); @@ -369,42 +369,42 @@ return slice(0, this->size() - N); } - /// \brief Return a copy of *this with the first N elements satisfying the + /// Return a copy of *this with the first N elements satisfying the /// given predicate removed. template MutableArrayRef drop_while(PredicateT Pred) const { return MutableArrayRef(find_if_not(*this, Pred), end()); } - /// \brief Return a copy of *this with the first N elements not satisfying + /// Return a copy of *this with the first N elements not satisfying /// the given predicate removed. template MutableArrayRef drop_until(PredicateT Pred) const { return MutableArrayRef(find_if(*this, Pred), end()); } - /// \brief Return a copy of *this with only the first \p N elements. + /// Return a copy of *this with only the first \p N elements. MutableArrayRef take_front(size_t N = 1) const { if (N >= this->size()) return *this; return drop_back(this->size() - N); } - /// \brief Return a copy of *this with only the last \p N elements. + /// Return a copy of *this with only the last \p N elements. MutableArrayRef take_back(size_t N = 1) const { if (N >= this->size()) return *this; return drop_front(this->size() - N); } - /// \brief Return the first N elements of this Array that satisfy the given + /// Return the first N elements of this Array that satisfy the given /// predicate. template MutableArrayRef take_while(PredicateT Pred) const { return MutableArrayRef(begin(), find_if_not(*this, Pred)); } - /// \brief Return the first N elements of this Array that don't satisfy the + /// Return the first N elements of this Array that don't satisfy the /// given predicate. template MutableArrayRef take_until(PredicateT Pred) const { Index: llvm/trunk/include/llvm/ADT/BitVector.h =================================================================== --- llvm/trunk/include/llvm/ADT/BitVector.h +++ llvm/trunk/include/llvm/ADT/BitVector.h @@ -779,7 +779,7 @@ } private: - /// \brief Perform a logical left shift of \p Count words by moving everything + /// Perform a logical left shift of \p Count words by moving everything /// \p Count words to the right in memory. /// /// While confusing, words are stored from least significant at Bits[0] to @@ -810,7 +810,7 @@ clear_unused_bits(); } - /// \brief Perform a logical right shift of \p Count words by moving those + /// Perform a logical right shift of \p Count words by moving those /// words to the left in memory. See wordShl for more information. /// void wordShr(uint32_t Count) { Index: llvm/trunk/include/llvm/ADT/DepthFirstIterator.h =================================================================== --- llvm/trunk/include/llvm/ADT/DepthFirstIterator.h +++ llvm/trunk/include/llvm/ADT/DepthFirstIterator.h @@ -177,7 +177,7 @@ return *this; } - /// \brief Skips all children of the current node and traverses to next node + /// Skips all children of the current node and traverses to next node /// /// Note: This function takes care of incrementing the iterator. If you /// always increment and call this function, you risk walking off the end. Index: llvm/trunk/include/llvm/ADT/EpochTracker.h =================================================================== --- llvm/trunk/include/llvm/ADT/EpochTracker.h +++ llvm/trunk/include/llvm/ADT/EpochTracker.h @@ -24,7 +24,7 @@ #if LLVM_ENABLE_ABI_BREAKING_CHECKS -/// \brief A base class for data structure classes wishing to make iterators +/// A base class for data structure classes wishing to make iterators /// ("handles") pointing into themselves fail-fast. When building without /// asserts, this class is empty and does nothing. /// @@ -39,15 +39,15 @@ public: DebugEpochBase() : Epoch(0) {} - /// \brief Calling incrementEpoch invalidates all handles pointing into the + /// Calling incrementEpoch invalidates all handles pointing into the /// calling instance. void incrementEpoch() { ++Epoch; } - /// \brief The destructor calls incrementEpoch to make use-after-free bugs + /// The destructor calls incrementEpoch to make use-after-free bugs /// more likely to crash deterministically. ~DebugEpochBase() { incrementEpoch(); } - /// \brief A base class for iterator classes ("handles") that wish to poll for + /// A base class for iterator classes ("handles") that wish to poll for /// iterator invalidating modifications in the underlying data structure. /// When LLVM is built without asserts, this class is empty and does nothing. /// @@ -65,12 +65,12 @@ explicit HandleBase(const DebugEpochBase *Parent) : EpochAddress(&Parent->Epoch), EpochAtCreation(Parent->Epoch) {} - /// \brief Returns true if the DebugEpochBase this Handle is linked to has + /// Returns true if the DebugEpochBase this Handle is linked to has /// not called incrementEpoch on itself since the creation of this /// HandleBase instance. bool isHandleInSync() const { return *EpochAddress == EpochAtCreation; } - /// \brief Returns a pointer to the epoch word stored in the data structure + /// Returns a pointer to the epoch word stored in the data structure /// this handle points into. Can be used to check if two iterators point /// into the same data structure. const void *getEpochAddress() const { return EpochAddress; } Index: llvm/trunk/include/llvm/ADT/Hashing.h =================================================================== --- llvm/trunk/include/llvm/ADT/Hashing.h +++ llvm/trunk/include/llvm/ADT/Hashing.h @@ -57,7 +57,7 @@ namespace llvm { -/// \brief An opaque object representing a hash code. +/// An opaque object representing a hash code. /// /// This object represents the result of hashing some entity. It is intended to /// be used to implement hashtables or other hashing-based data structures. @@ -73,14 +73,14 @@ size_t value; public: - /// \brief Default construct a hash_code. + /// Default construct a hash_code. /// Note that this leaves the value uninitialized. hash_code() = default; - /// \brief Form a hash code directly from a numerical value. + /// Form a hash code directly from a numerical value. hash_code(size_t value) : value(value) {} - /// \brief Convert the hash code to its numerical value for use. + /// Convert the hash code to its numerical value for use. /*explicit*/ operator size_t() const { return value; } friend bool operator==(const hash_code &lhs, const hash_code &rhs) { @@ -90,11 +90,11 @@ return lhs.value != rhs.value; } - /// \brief Allow a hash_code to be directly run through hash_value. + /// Allow a hash_code to be directly run through hash_value. friend size_t hash_value(const hash_code &code) { return code.value; } }; -/// \brief Compute a hash_code for any integer value. +/// Compute a hash_code for any integer value. /// /// Note that this function is intended to compute the same hash_code for /// a particular value without regard to the pre-promotion type. This is in @@ -105,21 +105,21 @@ typename std::enable_if::value, hash_code>::type hash_value(T value); -/// \brief Compute a hash_code for a pointer's address. +/// Compute a hash_code for a pointer's address. /// /// N.B.: This hashes the *address*. Not the value and not the type. template hash_code hash_value(const T *ptr); -/// \brief Compute a hash_code for a pair of objects. +/// Compute a hash_code for a pair of objects. template hash_code hash_value(const std::pair &arg); -/// \brief Compute a hash_code for a standard string. +/// Compute a hash_code for a standard string. template hash_code hash_value(const std::basic_string &arg); -/// \brief Override the execution seed with a fixed value. +/// Override the execution seed with a fixed value. /// /// This hashing library uses a per-execution seed designed to change on each /// run with high probability in order to ensure that the hash codes are not @@ -164,7 +164,7 @@ static const uint64_t k2 = 0x9ae16a3b2f90404fULL; static const uint64_t k3 = 0xc949d7c7509e6557ULL; -/// \brief Bitwise right rotate. +/// Bitwise right rotate. /// Normally this will compile to a single instruction, especially if the /// shift is a manifest constant. inline uint64_t rotate(uint64_t val, size_t shift) { @@ -254,13 +254,13 @@ return k2 ^ seed; } -/// \brief The intermediate state used during hashing. +/// The intermediate state used during hashing. /// Currently, the algorithm for computing hash codes is based on CityHash and /// keeps 56 bytes of arbitrary state. struct hash_state { uint64_t h0, h1, h2, h3, h4, h5, h6; - /// \brief Create a new hash_state structure and initialize it based on the + /// Create a new hash_state structure and initialize it based on the /// seed and the first 64-byte chunk. /// This effectively performs the initial mix. static hash_state create(const char *s, uint64_t seed) { @@ -272,7 +272,7 @@ return state; } - /// \brief Mix 32-bytes from the input sequence into the 16-bytes of 'a' + /// Mix 32-bytes from the input sequence into the 16-bytes of 'a' /// and 'b', including whatever is already in 'a' and 'b'. static void mix_32_bytes(const char *s, uint64_t &a, uint64_t &b) { a += fetch64(s); @@ -284,7 +284,7 @@ a += c; } - /// \brief Mix in a 64-byte buffer of data. + /// Mix in a 64-byte buffer of data. /// We mix all 64 bytes even when the chunk length is smaller, but we /// record the actual length. void mix(const char *s) { @@ -302,7 +302,7 @@ std::swap(h2, h0); } - /// \brief Compute the final 64-bit hash code value based on the current + /// Compute the final 64-bit hash code value based on the current /// state and the length of bytes hashed. uint64_t finalize(size_t length) { return hash_16_bytes(hash_16_bytes(h3, h5) + shift_mix(h1) * k1 + h2, @@ -311,7 +311,7 @@ }; -/// \brief A global, fixed seed-override variable. +/// A global, fixed seed-override variable. /// /// This variable can be set using the \see llvm::set_fixed_execution_seed /// function. See that function for details. Do not, under any circumstances, @@ -332,7 +332,7 @@ } -/// \brief Trait to indicate whether a type's bits can be hashed directly. +/// Trait to indicate whether a type's bits can be hashed directly. /// /// A type trait which is true if we want to combine values for hashing by /// reading the underlying data. It is false if values of this type must @@ -359,14 +359,14 @@ (sizeof(T) + sizeof(U)) == sizeof(std::pair))> {}; -/// \brief Helper to get the hashable data representation for a type. +/// Helper to get the hashable data representation for a type. /// This variant is enabled when the type itself can be used. template typename std::enable_if::value, T>::type get_hashable_data(const T &value) { return value; } -/// \brief Helper to get the hashable data representation for a type. +/// Helper to get the hashable data representation for a type. /// This variant is enabled when we must first call hash_value and use the /// result as our data. template @@ -376,7 +376,7 @@ return hash_value(value); } -/// \brief Helper to store data from a value into a buffer and advance the +/// Helper to store data from a value into a buffer and advance the /// pointer into that buffer. /// /// This routine first checks whether there is enough space in the provided @@ -395,7 +395,7 @@ return true; } -/// \brief Implement the combining of integral values into a hash_code. +/// Implement the combining of integral values into a hash_code. /// /// This overload is selected when the value type of the iterator is /// integral. Rather than computing a hash_code for each object and then @@ -435,7 +435,7 @@ return state.finalize(length); } -/// \brief Implement the combining of integral values into a hash_code. +/// Implement the combining of integral values into a hash_code. /// /// This overload is selected when the value type of the iterator is integral /// and when the input iterator is actually a pointer. Rather than computing @@ -470,7 +470,7 @@ } // namespace hashing -/// \brief Compute a hash_code for a sequence of values. +/// Compute a hash_code for a sequence of values. /// /// This hashes a sequence of values. It produces the same hash_code as /// 'hash_combine(a, b, c, ...)', but can run over arbitrary sized sequences @@ -486,7 +486,7 @@ namespace hashing { namespace detail { -/// \brief Helper class to manage the recursive combining of hash_combine +/// Helper class to manage the recursive combining of hash_combine /// arguments. /// /// This class exists to manage the state and various calls involved in the @@ -499,14 +499,14 @@ const size_t seed; public: - /// \brief Construct a recursive hash combining helper. + /// Construct a recursive hash combining helper. /// /// This sets up the state for a recursive hash combine, including getting /// the seed and buffer setup. hash_combine_recursive_helper() : seed(get_execution_seed()) {} - /// \brief Combine one chunk of data into the current in-flight hash. + /// Combine one chunk of data into the current in-flight hash. /// /// This merges one chunk of data into the hash. First it tries to buffer /// the data. If the buffer is full, it hashes the buffer into its @@ -547,7 +547,7 @@ return buffer_ptr; } - /// \brief Recursive, variadic combining method. + /// Recursive, variadic combining method. /// /// This function recurses through each argument, combining that argument /// into a single hash. @@ -560,7 +560,7 @@ return combine(length, buffer_ptr, buffer_end, args...); } - /// \brief Base case for recursive, variadic combining. + /// Base case for recursive, variadic combining. /// /// The base case when combining arguments recursively is reached when all /// arguments have been handled. It flushes the remaining buffer and @@ -588,7 +588,7 @@ } // namespace detail } // namespace hashing -/// \brief Combine values into a single hash_code. +/// Combine values into a single hash_code. /// /// This routine accepts a varying number of arguments of any type. It will /// attempt to combine them into a single hash_code. For user-defined types it @@ -610,7 +610,7 @@ namespace hashing { namespace detail { -/// \brief Helper to hash the value of a single integer. +/// Helper to hash the value of a single integer. /// /// Overloads for smaller integer types are not provided to ensure consistent /// behavior in the presence of integral promotions. Essentially, Index: llvm/trunk/include/llvm/ADT/MapVector.h =================================================================== --- llvm/trunk/include/llvm/ADT/MapVector.h +++ llvm/trunk/include/llvm/ADT/MapVector.h @@ -157,14 +157,14 @@ (Vector.begin() + Pos->second); } - /// \brief Remove the last element from the vector. + /// Remove the last element from the vector. void pop_back() { typename MapType::iterator Pos = Map.find(Vector.back().first); Map.erase(Pos); Vector.pop_back(); } - /// \brief Remove the element given by Iterator. + /// Remove the element given by Iterator. /// /// Returns an iterator to the element following the one which was removed, /// which may be end(). @@ -187,7 +187,7 @@ return Next; } - /// \brief Remove all elements with the key value Key. + /// Remove all elements with the key value Key. /// /// Returns the number of elements removed. size_type erase(const KeyT &Key) { @@ -198,7 +198,7 @@ return 1; } - /// \brief Remove the elements that match the predicate. + /// Remove the elements that match the predicate. /// /// Erase all elements that match \c Pred in a single pass. Takes linear /// time. @@ -227,7 +227,7 @@ Vector.erase(O, Vector.end()); } -/// \brief A MapVector that performs no allocations if smaller than a certain +/// A MapVector that performs no allocations if smaller than a certain /// size. template struct SmallMapVector Index: llvm/trunk/include/llvm/ADT/None.h =================================================================== --- llvm/trunk/include/llvm/ADT/None.h +++ llvm/trunk/include/llvm/ADT/None.h @@ -17,7 +17,7 @@ #define LLVM_ADT_NONE_H namespace llvm { -/// \brief A simple null object to allow implicit construction of Optional +/// A simple null object to allow implicit construction of Optional /// and similar types without having to spell out the specialization's name. // (constant value 1 in an attempt to workaround MSVC build issue... ) enum class NoneType { None = 1 }; Index: llvm/trunk/include/llvm/ADT/PackedVector.h =================================================================== --- llvm/trunk/include/llvm/ADT/PackedVector.h +++ llvm/trunk/include/llvm/ADT/PackedVector.h @@ -65,7 +65,7 @@ } }; -/// \brief Store a vector of values using a specific number of bits for each +/// Store a vector of values using a specific number of bits for each /// value. Both signed and unsigned types can be used, e.g /// @code /// PackedVector vec; Index: llvm/trunk/include/llvm/ADT/SCCIterator.h =================================================================== --- llvm/trunk/include/llvm/ADT/SCCIterator.h +++ llvm/trunk/include/llvm/ADT/SCCIterator.h @@ -33,7 +33,7 @@ namespace llvm { -/// \brief Enumerate the SCCs of a directed graph in reverse topological order +/// Enumerate the SCCs of a directed graph in reverse topological order /// of the SCC DAG. /// /// This is implemented using Tarjan's DFS algorithm using an internal stack to @@ -104,7 +104,7 @@ } static scc_iterator end(const GraphT &) { return scc_iterator(); } - /// \brief Direct loop termination test which is more efficient than + /// Direct loop termination test which is more efficient than /// comparison with \c end(). bool isAtEnd() const { assert(!CurrentSCC.empty() || VisitStack.empty()); @@ -125,7 +125,7 @@ return CurrentSCC; } - /// \brief Test if the current SCC has a loop. + /// Test if the current SCC has a loop. /// /// If the SCC has more than one node, this is trivially true. If not, it may /// still contain a loop if the node has an edge back to itself. @@ -222,12 +222,12 @@ return false; } -/// \brief Construct the begin iterator for a deduced graph type T. +/// Construct the begin iterator for a deduced graph type T. template scc_iterator scc_begin(const T &G) { return scc_iterator::begin(G); } -/// \brief Construct the end iterator for a deduced graph type T. +/// Construct the end iterator for a deduced graph type T. template scc_iterator scc_end(const T &G) { return scc_iterator::end(G); } Index: llvm/trunk/include/llvm/ADT/STLExtras.h =================================================================== --- llvm/trunk/include/llvm/ADT/STLExtras.h +++ llvm/trunk/include/llvm/ADT/STLExtras.h @@ -711,7 +711,7 @@ // Extra additions to //===----------------------------------------------------------------------===// -/// \brief Function object to check whether the first component of a std::pair +/// Function object to check whether the first component of a std::pair /// compares less than the first component of another std::pair. struct less_first { template bool operator()(const T &lhs, const T &rhs) const { @@ -719,7 +719,7 @@ } }; -/// \brief Function object to check whether the second component of a std::pair +/// Function object to check whether the second component of a std::pair /// compares less than the second component of another std::pair. struct less_second { template bool operator()(const T &lhs, const T &rhs) const { @@ -729,14 +729,14 @@ // A subset of N3658. More stuff can be added as-needed. -/// \brief Represents a compile-time sequence of integers. +/// Represents a compile-time sequence of integers. template struct integer_sequence { using value_type = T; static constexpr size_t size() { return sizeof...(I); } }; -/// \brief Alias for the common case of a sequence of size_ts. +/// Alias for the common case of a sequence of size_ts. template struct index_sequence : integer_sequence {}; @@ -745,7 +745,7 @@ template struct build_index_impl<0, I...> : index_sequence {}; -/// \brief Creates a compile-time integer sequence for a parameter pack. +/// Creates a compile-time integer sequence for a parameter pack. template struct index_sequence_for : build_index_impl {}; @@ -754,7 +754,7 @@ template struct rank : rank {}; template <> struct rank<0> {}; -/// \brief traits class for checking whether type T is one of any of the given +/// traits class for checking whether type T is one of any of the given /// types in the variadic list. template struct is_one_of { static const bool value = false; @@ -766,7 +766,7 @@ std::is_same::value || is_one_of::value; }; -/// \brief traits class for checking whether type T is a base class for all +/// traits class for checking whether type T is a base class for all /// the given types in the variadic list. template struct are_base_of { static const bool value = true; @@ -1005,7 +1005,7 @@ return std::lower_bound(adl_begin(Range), adl_end(Range), I); } -/// \brief Given a range of type R, iterate the entire range and return a +/// Given a range of type R, iterate the entire range and return a /// SmallVector with elements of the vector. This is useful, for example, /// when you want to iterate a range and then sort the results. template @@ -1032,7 +1032,7 @@ // Implement make_unique according to N3656. -/// \brief Constructs a `new T()` with the given args and returns a +/// Constructs a `new T()` with the given args and returns a /// `unique_ptr` which owns the object. /// /// Example: @@ -1045,7 +1045,7 @@ return std::unique_ptr(new T(std::forward(args)...)); } -/// \brief Constructs a `new T[n]` with the given args and returns a +/// Constructs a `new T[n]` with the given args and returns a /// `unique_ptr` which owns the object. /// /// \param n size of the new array. Index: llvm/trunk/include/llvm/ADT/SetVector.h =================================================================== --- llvm/trunk/include/llvm/ADT/SetVector.h +++ llvm/trunk/include/llvm/ADT/SetVector.h @@ -31,7 +31,7 @@ namespace llvm { -/// \brief A vector that has set insertion semantics. +/// A vector that has set insertion semantics. /// /// This adapter class provides a way to keep a set of things that also has the /// property of a deterministic iteration order. The order of iteration is the @@ -52,10 +52,10 @@ using const_reverse_iterator = typename vector_type::const_reverse_iterator; using size_type = typename vector_type::size_type; - /// \brief Construct an empty SetVector + /// Construct an empty SetVector SetVector() = default; - /// \brief Initialize a SetVector with a range of elements + /// Initialize a SetVector with a range of elements template SetVector(It Start, It End) { insert(Start, End); @@ -69,75 +69,75 @@ return std::move(vector_); } - /// \brief Determine if the SetVector is empty or not. + /// Determine if the SetVector is empty or not. bool empty() const { return vector_.empty(); } - /// \brief Determine the number of elements in the SetVector. + /// Determine the number of elements in the SetVector. size_type size() const { return vector_.size(); } - /// \brief Get an iterator to the beginning of the SetVector. + /// Get an iterator to the beginning of the SetVector. iterator begin() { return vector_.begin(); } - /// \brief Get a const_iterator to the beginning of the SetVector. + /// Get a const_iterator to the beginning of the SetVector. const_iterator begin() const { return vector_.begin(); } - /// \brief Get an iterator to the end of the SetVector. + /// Get an iterator to the end of the SetVector. iterator end() { return vector_.end(); } - /// \brief Get a const_iterator to the end of the SetVector. + /// Get a const_iterator to the end of the SetVector. const_iterator end() const { return vector_.end(); } - /// \brief Get an reverse_iterator to the end of the SetVector. + /// Get an reverse_iterator to the end of the SetVector. reverse_iterator rbegin() { return vector_.rbegin(); } - /// \brief Get a const_reverse_iterator to the end of the SetVector. + /// Get a const_reverse_iterator to the end of the SetVector. const_reverse_iterator rbegin() const { return vector_.rbegin(); } - /// \brief Get a reverse_iterator to the beginning of the SetVector. + /// Get a reverse_iterator to the beginning of the SetVector. reverse_iterator rend() { return vector_.rend(); } - /// \brief Get a const_reverse_iterator to the beginning of the SetVector. + /// Get a const_reverse_iterator to the beginning of the SetVector. const_reverse_iterator rend() const { return vector_.rend(); } - /// \brief Return the first element of the SetVector. + /// Return the first element of the SetVector. const T &front() const { assert(!empty() && "Cannot call front() on empty SetVector!"); return vector_.front(); } - /// \brief Return the last element of the SetVector. + /// Return the last element of the SetVector. const T &back() const { assert(!empty() && "Cannot call back() on empty SetVector!"); return vector_.back(); } - /// \brief Index into the SetVector. + /// Index into the SetVector. const_reference operator[](size_type n) const { assert(n < vector_.size() && "SetVector access out of range!"); return vector_[n]; } - /// \brief Insert a new element into the SetVector. + /// Insert a new element into the SetVector. /// \returns true if the element was inserted into the SetVector. bool insert(const value_type &X) { bool result = set_.insert(X).second; @@ -146,7 +146,7 @@ return result; } - /// \brief Insert a range of elements into the SetVector. + /// Insert a range of elements into the SetVector. template void insert(It Start, It End) { for (; Start != End; ++Start) @@ -154,7 +154,7 @@ vector_.push_back(*Start); } - /// \brief Remove an item from the set vector. + /// Remove an item from the set vector. bool remove(const value_type& X) { if (set_.erase(X)) { typename vector_type::iterator I = find(vector_, X); @@ -183,7 +183,7 @@ return vector_.erase(NI); } - /// \brief Remove items from the set vector based on a predicate function. + /// Remove items from the set vector based on a predicate function. /// /// This is intended to be equivalent to the following code, if we could /// write it: @@ -206,19 +206,19 @@ return true; } - /// \brief Count the number of elements of a given key in the SetVector. + /// Count the number of elements of a given key in the SetVector. /// \returns 0 if the element is not in the SetVector, 1 if it is. size_type count(const key_type &key) const { return set_.count(key); } - /// \brief Completely clear the SetVector + /// Completely clear the SetVector void clear() { set_.clear(); vector_.clear(); } - /// \brief Remove the last element of the SetVector. + /// Remove the last element of the SetVector. void pop_back() { assert(!empty() && "Cannot remove an element from an empty SetVector!"); set_.erase(back()); @@ -239,7 +239,7 @@ return vector_ != that.vector_; } - /// \brief Compute This := This u S, return whether 'This' changed. + /// Compute This := This u S, return whether 'This' changed. /// TODO: We should be able to use set_union from SetOperations.h, but /// SetVector interface is inconsistent with DenseSet. template @@ -254,7 +254,7 @@ return Changed; } - /// \brief Compute This := This - B + /// Compute This := This - B /// TODO: We should be able to use set_subtract from SetOperations.h, but /// SetVector interface is inconsistent with DenseSet. template @@ -265,7 +265,7 @@ } private: - /// \brief A wrapper predicate designed for use with std::remove_if. + /// A wrapper predicate designed for use with std::remove_if. /// /// This predicate wraps a predicate suitable for use with std::remove_if to /// call set_.erase(x) on each element which is slated for removal. @@ -292,7 +292,7 @@ vector_type vector_; ///< The vector. }; -/// \brief A SetVector that performs no allocations if smaller than +/// A SetVector that performs no allocations if smaller than /// a certain size. template class SmallSetVector @@ -300,7 +300,7 @@ public: SmallSetVector() = default; - /// \brief Initialize a SmallSetVector with a range of elements + /// Initialize a SmallSetVector with a range of elements template SmallSetVector(It Start, It End) { this->insert(Start, End); Index: llvm/trunk/include/llvm/ADT/SmallPtrSet.h =================================================================== --- llvm/trunk/include/llvm/ADT/SmallPtrSet.h +++ llvm/trunk/include/llvm/ADT/SmallPtrSet.h @@ -335,7 +335,7 @@ enum { Val = RoundUpToPowerOfTwoH::Val }; }; -/// \brief A templated base class for \c SmallPtrSet which provides the +/// A templated base class for \c SmallPtrSet which provides the /// typesafe interface that is common across all small sizes. /// /// This is particularly useful for passing around between interface boundaries Index: llvm/trunk/include/llvm/ADT/Statistic.h =================================================================== --- llvm/trunk/include/llvm/ADT/Statistic.h +++ llvm/trunk/include/llvm/ADT/Statistic.h @@ -169,19 +169,19 @@ #define STATISTIC(VARNAME, DESC) \ static llvm::Statistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC, {0}, {false}} -/// \brief Enable the collection and printing of statistics. +/// Enable the collection and printing of statistics. void EnableStatistics(bool PrintOnExit = true); -/// \brief Check if statistics are enabled. +/// Check if statistics are enabled. bool AreStatisticsEnabled(); -/// \brief Return a file stream to print our output on. +/// Return a file stream to print our output on. std::unique_ptr CreateInfoOutputFile(); -/// \brief Print statistics to the file returned by CreateInfoOutputFile(). +/// Print statistics to the file returned by CreateInfoOutputFile(). void PrintStatistics(); -/// \brief Print statistics to the given output stream. +/// Print statistics to the given output stream. void PrintStatistics(raw_ostream &OS); /// Print statistics in JSON format. This does include all global timers (\see @@ -190,7 +190,7 @@ /// PrintStatisticsJSON(). void PrintStatisticsJSON(raw_ostream &OS); -/// \brief Get the statistics. This can be used to look up the value of +/// Get the statistics. This can be used to look up the value of /// statistics without needing to parse JSON. /// /// This function does not prevent statistics being updated by other threads @@ -199,7 +199,7 @@ /// completes. const std::vector> GetStatistics(); -/// \brief Reset the statistics. This can be used to zero and de-register the +/// Reset the statistics. This can be used to zero and de-register the /// statistics in order to measure a compilation. /// /// When this function begins to call destructors prior to returning, all Index: llvm/trunk/include/llvm/ADT/StringExtras.h =================================================================== --- llvm/trunk/include/llvm/ADT/StringExtras.h +++ llvm/trunk/include/llvm/ADT/StringExtras.h @@ -157,7 +157,7 @@ return Output; } -/// \brief Convert the string \p S to an integer of the specified type using +/// Convert the string \p S to an integer of the specified type using /// the radix \p Base. If \p Base is 0, auto-detects the radix. /// Returns true if the number was successfully converted, false otherwise. template bool to_integer(StringRef S, N &Num, unsigned Base = 0) { Index: llvm/trunk/include/llvm/ADT/StringRef.h =================================================================== --- llvm/trunk/include/llvm/ADT/StringRef.h +++ llvm/trunk/include/llvm/ADT/StringRef.h @@ -201,7 +201,7 @@ LLVM_NODISCARD int compare_numeric(StringRef RHS) const; - /// \brief Determine the edit distance between this string and another + /// Determine the edit distance between this string and another /// string. /// /// \param Other the string to compare this string against. @@ -912,7 +912,7 @@ /// @} - /// \brief Compute a hash_code for a StringRef. + /// Compute a hash_code for a StringRef. LLVM_NODISCARD hash_code hash_value(StringRef S); Index: llvm/trunk/include/llvm/ADT/StringSwitch.h =================================================================== --- llvm/trunk/include/llvm/ADT/StringSwitch.h +++ llvm/trunk/include/llvm/ADT/StringSwitch.h @@ -20,7 +20,7 @@ namespace llvm { -/// \brief A switch()-like statement whose cases are string literals. +/// A switch()-like statement whose cases are string literals. /// /// The StringSwitch class is a simple form of a switch() statement that /// determines whether the given string matches one of the given string @@ -41,10 +41,10 @@ /// \endcode template class StringSwitch { - /// \brief The string we are matching. + /// The string we are matching. const StringRef Str; - /// \brief The pointer to the result of this switch statement, once known, + /// The pointer to the result of this switch statement, once known, /// null before that. Optional Result; Index: llvm/trunk/include/llvm/ADT/UniqueVector.h =================================================================== --- llvm/trunk/include/llvm/ADT/UniqueVector.h +++ llvm/trunk/include/llvm/ADT/UniqueVector.h @@ -72,16 +72,16 @@ return Vector[ID - 1]; } - /// \brief Return an iterator to the start of the vector. + /// Return an iterator to the start of the vector. iterator begin() { return Vector.begin(); } - /// \brief Return an iterator to the start of the vector. + /// Return an iterator to the start of the vector. const_iterator begin() const { return Vector.begin(); } - /// \brief Return an iterator to the end of the vector. + /// Return an iterator to the end of the vector. iterator end() { return Vector.end(); } - /// \brief Return an iterator to the end of the vector. + /// Return an iterator to the end of the vector. const_iterator end() const { return Vector.end(); } /// size - Returns the number of entries in the vector. Index: llvm/trunk/include/llvm/ADT/VariadicFunction.h =================================================================== --- llvm/trunk/include/llvm/ADT/VariadicFunction.h +++ llvm/trunk/include/llvm/ADT/VariadicFunction.h @@ -53,7 +53,7 @@ #define LLVM_COMMA_JOIN31(x) LLVM_COMMA_JOIN30(x), x ## 30 #define LLVM_COMMA_JOIN32(x) LLVM_COMMA_JOIN31(x), x ## 31 -/// \brief Class which can simulate a type-safe variadic function. +/// Class which can simulate a type-safe variadic function. /// /// The VariadicFunction class template makes it easy to define /// type-safe variadic functions where all arguments have the same Index: llvm/trunk/include/llvm/ADT/edit_distance.h =================================================================== --- llvm/trunk/include/llvm/ADT/edit_distance.h +++ llvm/trunk/include/llvm/ADT/edit_distance.h @@ -22,7 +22,7 @@ namespace llvm { -/// \brief Determine the edit distance between two sequences. +/// Determine the edit distance between two sequences. /// /// \param FromArray the first sequence to compare. /// Index: llvm/trunk/include/llvm/ADT/ilist.h =================================================================== --- llvm/trunk/include/llvm/ADT/ilist.h +++ llvm/trunk/include/llvm/ADT/ilist.h @@ -356,26 +356,26 @@ using base_list_type::sort; - /// \brief Get the previous node, or \c nullptr for the list head. + /// Get the previous node, or \c nullptr for the list head. pointer getPrevNode(reference N) const { auto I = N.getIterator(); if (I == begin()) return nullptr; return &*std::prev(I); } - /// \brief Get the previous node, or \c nullptr for the list head. + /// Get the previous node, or \c nullptr for the list head. const_pointer getPrevNode(const_reference N) const { return getPrevNode(const_cast(N)); } - /// \brief Get the next node, or \c nullptr for the list tail. + /// Get the next node, or \c nullptr for the list tail. pointer getNextNode(reference N) const { auto Next = std::next(N.getIterator()); if (Next == end()) return nullptr; return &*Next; } - /// \brief Get the next node, or \c nullptr for the list tail. + /// Get the next node, or \c nullptr for the list tail. const_pointer getNextNode(const_reference N) const { return getNextNode(const_cast(N)); } Index: llvm/trunk/include/llvm/ADT/ilist_node.h =================================================================== --- llvm/trunk/include/llvm/ADT/ilist_node.h +++ llvm/trunk/include/llvm/ADT/ilist_node.h @@ -271,7 +271,7 @@ public: /// @name Adjacent Node Accessors /// @{ - /// \brief Get the previous node, or \c nullptr for the list head. + /// Get the previous node, or \c nullptr for the list head. NodeTy *getPrevNode() { // Should be separated to a reused function, but then we couldn't use auto // (and would need the type of the list). @@ -280,12 +280,12 @@ return List.getPrevNode(*static_cast(this)); } - /// \brief Get the previous node, or \c nullptr for the list head. + /// Get the previous node, or \c nullptr for the list head. const NodeTy *getPrevNode() const { return const_cast(this)->getPrevNode(); } - /// \brief Get the next node, or \c nullptr for the list tail. + /// Get the next node, or \c nullptr for the list tail. NodeTy *getNextNode() { // Should be separated to a reused function, but then we couldn't use auto // (and would need the type of the list). @@ -294,7 +294,7 @@ return List.getNextNode(*static_cast(this)); } - /// \brief Get the next node, or \c nullptr for the list tail. + /// Get the next node, or \c nullptr for the list tail. const NodeTy *getNextNode() const { return const_cast(this)->getNextNode(); } Index: llvm/trunk/include/llvm/ADT/iterator.h =================================================================== --- llvm/trunk/include/llvm/ADT/iterator.h +++ llvm/trunk/include/llvm/ADT/iterator.h @@ -19,7 +19,7 @@ namespace llvm { -/// \brief CRTP base class which implements the entire standard iterator facade +/// CRTP base class which implements the entire standard iterator facade /// in terms of a minimal subset of the interface. /// /// Use this when it is reasonable to implement most of the iterator @@ -183,7 +183,7 @@ } }; -/// \brief CRTP base class for adapting an iterator to a different type. +/// CRTP base class for adapting an iterator to a different type. /// /// This class can be used through CRTP to adapt one iterator into another. /// Typically this is done through providing in the derived class a custom \c @@ -274,7 +274,7 @@ ReferenceT operator*() const { return *I; } }; -/// \brief An iterator type that allows iterating over the pointees via some +/// An iterator type that allows iterating over the pointees via some /// other iterator. /// /// The typical usage of this is to expose a type that iterates over Ts, but Index: llvm/trunk/include/llvm/ADT/iterator_range.h =================================================================== --- llvm/trunk/include/llvm/ADT/iterator_range.h +++ llvm/trunk/include/llvm/ADT/iterator_range.h @@ -24,7 +24,7 @@ namespace llvm { -/// \brief A range adaptor for a pair of iterators. +/// A range adaptor for a pair of iterators. /// /// This just wraps two iterators into a range-compatible interface. Nothing /// fancy at all. @@ -47,7 +47,7 @@ IteratorT end() const { return end_iterator; } }; -/// \brief Convenience function for iterating over sub-ranges. +/// Convenience function for iterating over sub-ranges. /// /// This provides a bit of syntactic sugar to make using sub-ranges /// in for loops a bit easier. Analogous to std::make_pair(). Index: llvm/trunk/include/llvm/Analysis/AliasAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/AliasAnalysis.h +++ llvm/trunk/include/llvm/Analysis/AliasAnalysis.h @@ -659,7 +659,7 @@ /// http://llvm.org/docs/AliasAnalysis.html#ModRefInfo ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2); - /// \brief Return information about whether a particular call site modifies + /// Return information about whether a particular call site modifies /// or reads the specified memory location \p MemLoc before instruction \p I /// in a BasicBlock. An ordered basic block \p OBB can be used to speed up /// instruction ordering queries inside the BasicBlock containing \p I. @@ -669,7 +669,7 @@ const MemoryLocation &MemLoc, DominatorTree *DT, OrderedBasicBlock *OBB = nullptr); - /// \brief A convenience wrapper to synthesize a memory location. + /// A convenience wrapper to synthesize a memory location. ModRefInfo callCapturesBefore(const Instruction *I, const Value *P, uint64_t Size, DominatorTree *DT, OrderedBasicBlock *OBB = nullptr) { Index: llvm/trunk/include/llvm/Analysis/AliasAnalysisEvaluator.h =================================================================== --- llvm/trunk/include/llvm/Analysis/AliasAnalysisEvaluator.h +++ llvm/trunk/include/llvm/Analysis/AliasAnalysisEvaluator.h @@ -56,7 +56,7 @@ } ~AAEvaluator(); - /// \brief Run the pass over the function. + /// Run the pass over the function. PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); private: Index: llvm/trunk/include/llvm/Analysis/AssumptionCache.h =================================================================== --- llvm/trunk/include/llvm/Analysis/AssumptionCache.h +++ llvm/trunk/include/llvm/Analysis/AssumptionCache.h @@ -32,7 +32,7 @@ class raw_ostream; class Value; -/// \brief A cache of \@llvm.assume calls within a function. +/// A cache of \@llvm.assume calls within a function. /// /// This cache provides fast lookup of assumptions within a function by caching /// them and amortizing the cost of scanning for them across all queries. Passes @@ -40,12 +40,12 @@ /// register any new \@llvm.assume calls that they create. Deletions of /// \@llvm.assume calls do not require special handling. class AssumptionCache { - /// \brief The function for which this cache is handling assumptions. + /// The function for which this cache is handling assumptions. /// /// We track this to lazily populate our assumptions. Function &F; - /// \brief Vector of weak value handles to calls of the \@llvm.assume + /// Vector of weak value handles to calls of the \@llvm.assume /// intrinsic. SmallVector AssumeHandles; @@ -64,7 +64,7 @@ friend AffectedValueCallbackVH; - /// \brief A map of values about which an assumption might be providing + /// A map of values about which an assumption might be providing /// information to the relevant set of assumptions. using AffectedValuesMap = DenseMap, @@ -77,17 +77,17 @@ /// Copy affected values in the cache for OV to be affected values for NV. void copyAffectedValuesInCache(Value *OV, Value *NV); - /// \brief Flag tracking whether we have scanned the function yet. + /// Flag tracking whether we have scanned the function yet. /// /// We want to be as lazy about this as possible, and so we scan the function /// at the last moment. bool Scanned = false; - /// \brief Scan the function for assumptions and add them to the cache. + /// Scan the function for assumptions and add them to the cache. void scanFunction(); public: - /// \brief Construct an AssumptionCache from a function by scanning all of + /// Construct an AssumptionCache from a function by scanning all of /// its instructions. AssumptionCache(Function &F) : F(F) {} @@ -98,17 +98,17 @@ return false; } - /// \brief Add an \@llvm.assume intrinsic to this function's cache. + /// Add an \@llvm.assume intrinsic to this function's cache. /// /// The call passed in must be an instruction within this function and must /// not already be in the cache. void registerAssumption(CallInst *CI); - /// \brief Update the cache of values being affected by this assumption (i.e. + /// Update the cache of values being affected by this assumption (i.e. /// the values about which this assumption provides information). void updateAffectedValues(CallInst *CI); - /// \brief Clear the cache of \@llvm.assume intrinsics for a function. + /// Clear the cache of \@llvm.assume intrinsics for a function. /// /// It will be re-scanned the next time it is requested. void clear() { @@ -117,7 +117,7 @@ Scanned = false; } - /// \brief Access the list of assumption handles currently tracked for this + /// Access the list of assumption handles currently tracked for this /// function. /// /// Note that these produce weak handles that may be null. The caller must @@ -131,7 +131,7 @@ return AssumeHandles; } - /// \brief Access the list of assumptions which affect this value. + /// Access the list of assumptions which affect this value. MutableArrayRef assumptionsFor(const Value *V) { if (!Scanned) scanFunction(); @@ -144,7 +144,7 @@ } }; -/// \brief A function analysis which provides an \c AssumptionCache. +/// A function analysis which provides an \c AssumptionCache. /// /// This analysis is intended for use with the new pass manager and will vend /// assumption caches for a given function. @@ -161,7 +161,7 @@ } }; -/// \brief Printer pass for the \c AssumptionAnalysis results. +/// Printer pass for the \c AssumptionAnalysis results. class AssumptionPrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -171,7 +171,7 @@ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief An immutable pass that tracks lazily created \c AssumptionCache +/// An immutable pass that tracks lazily created \c AssumptionCache /// objects. /// /// This is essentially a workaround for the legacy pass manager's weaknesses @@ -203,7 +203,7 @@ FunctionCallsMap AssumptionCaches; public: - /// \brief Get the cached assumptions for a function. + /// Get the cached assumptions for a function. /// /// If no assumptions are cached, this will scan the function. Otherwise, the /// existing cache will be returned. Index: llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h +++ llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h @@ -173,7 +173,7 @@ const DecomposedGEP &DecompGEP, const DecomposedGEP &DecompObject, uint64_t ObjectAccessSize); - /// \brief A Heuristic for aliasGEP that searches for a constant offset + /// A Heuristic for aliasGEP that searches for a constant offset /// between the variables. /// /// GetLinearExpression has some limitations, as generally zext(%x + 1) Index: llvm/trunk/include/llvm/Analysis/BlockFrequencyInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/BlockFrequencyInfo.h +++ llvm/trunk/include/llvm/Analysis/BlockFrequencyInfo.h @@ -65,17 +65,17 @@ /// floating points. BlockFrequency getBlockFreq(const BasicBlock *BB) const; - /// \brief Returns the estimated profile count of \p BB. + /// Returns the estimated profile count of \p BB. /// This computes the relative block frequency of \p BB and multiplies it by /// the enclosing function's count (if available) and returns the value. Optional getBlockProfileCount(const BasicBlock *BB) const; - /// \brief Returns the estimated profile count of \p Freq. + /// Returns the estimated profile count of \p Freq. /// This uses the frequency \p Freq and multiplies it by /// the enclosing function's count (if available) and returns the value. Optional getProfileCountFromFreq(uint64_t Freq) const; - /// \brief Returns true if \p BB is an irreducible loop header + /// Returns true if \p BB is an irreducible loop header /// block. Otherwise false. bool isIrrLoopHeader(const BasicBlock *BB); @@ -105,7 +105,7 @@ void print(raw_ostream &OS) const; }; -/// \brief Analysis pass which computes \c BlockFrequencyInfo. +/// Analysis pass which computes \c BlockFrequencyInfo. class BlockFrequencyAnalysis : public AnalysisInfoMixin { friend AnalysisInfoMixin; @@ -113,14 +113,14 @@ static AnalysisKey Key; public: - /// \brief Provide the result type for this analysis pass. + /// Provide the result type for this analysis pass. using Result = BlockFrequencyInfo; - /// \brief Run the analysis pass over a function and produce BFI. + /// Run the analysis pass over a function and produce BFI. Result run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Printer pass for the \c BlockFrequencyInfo results. +/// Printer pass for the \c BlockFrequencyInfo results. class BlockFrequencyPrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -131,7 +131,7 @@ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Legacy analysis pass which computes \c BlockFrequencyInfo. +/// Legacy analysis pass which computes \c BlockFrequencyInfo. class BlockFrequencyInfoWrapperPass : public FunctionPass { BlockFrequencyInfo BFI; Index: llvm/trunk/include/llvm/Analysis/BlockFrequencyInfoImpl.h =================================================================== --- llvm/trunk/include/llvm/Analysis/BlockFrequencyInfoImpl.h +++ llvm/trunk/include/llvm/Analysis/BlockFrequencyInfoImpl.h @@ -66,7 +66,7 @@ // This is part of a workaround for a GCC 4.7 crash on lambdas. template struct BlockEdgesAdder; -/// \brief Mass of a block. +/// Mass of a block. /// /// This class implements a sort of fixed-point fraction always between 0.0 and /// 1.0. getMass() == std::numeric_limits::max() indicates a value of @@ -100,7 +100,7 @@ bool operator!() const { return isEmpty(); } - /// \brief Add another mass. + /// Add another mass. /// /// Adds another mass, saturating at \a isFull() rather than overflowing. BlockMass &operator+=(BlockMass X) { @@ -109,7 +109,7 @@ return *this; } - /// \brief Subtract another mass. + /// Subtract another mass. /// /// Subtracts another mass, saturating at \a isEmpty() rather than /// undeflowing. @@ -131,7 +131,7 @@ bool operator<(BlockMass X) const { return Mass < X.Mass; } bool operator>(BlockMass X) const { return Mass > X.Mass; } - /// \brief Convert to scaled number. + /// Convert to scaled number. /// /// Convert to \a ScaledNumber. \a isFull() gives 1.0, while \a isEmpty() /// gives slightly above 0.0. @@ -164,7 +164,7 @@ static const bool value = true; }; -/// \brief Base class for BlockFrequencyInfoImpl +/// Base class for BlockFrequencyInfoImpl /// /// BlockFrequencyInfoImplBase has supporting data structures and some /// algorithms for BlockFrequencyInfoImplBase. Only algorithms that depend on @@ -177,7 +177,7 @@ using Scaled64 = ScaledNumber; using BlockMass = bfi_detail::BlockMass; - /// \brief Representative of a block. + /// Representative of a block. /// /// This is a simple wrapper around an index into the reverse-post-order /// traversal of the blocks. @@ -206,13 +206,13 @@ } }; - /// \brief Stats about a block itself. + /// Stats about a block itself. struct FrequencyData { Scaled64 Scaled; uint64_t Integer; }; - /// \brief Data about a loop. + /// Data about a loop. /// /// Contains the data necessary to represent a loop as a pseudo-node once it's /// packaged. @@ -270,7 +270,7 @@ } }; - /// \brief Index of loop information. + /// Index of loop information. struct WorkingData { BlockNode Node; ///< This node. LoopData *Loop = nullptr; ///< The loop this block is inside. @@ -293,7 +293,7 @@ return Loop->Parent->Parent; } - /// \brief Resolve a node to its representative. + /// Resolve a node to its representative. /// /// Get the node currently representing Node, which could be a containing /// loop. @@ -320,7 +320,7 @@ return L; } - /// \brief Get the appropriate mass for a node. + /// Get the appropriate mass for a node. /// /// Get appropriate mass for Node. If Node is a loop-header (whose loop /// has been packaged), returns the mass of its pseudo-node. If it's a @@ -333,19 +333,19 @@ return Loop->Parent->Mass; } - /// \brief Has ContainingLoop been packaged up? + /// Has ContainingLoop been packaged up? bool isPackaged() const { return getResolvedNode() != Node; } - /// \brief Has Loop been packaged up? + /// Has Loop been packaged up? bool isAPackage() const { return isLoopHeader() && Loop->IsPackaged; } - /// \brief Has Loop been packaged up twice? + /// Has Loop been packaged up twice? bool isADoublePackage() const { return isDoubleLoopHeader() && Loop->Parent->IsPackaged; } }; - /// \brief Unscaled probability weight. + /// Unscaled probability weight. /// /// Probability weight for an edge in the graph (including the /// successor/target node). @@ -369,7 +369,7 @@ : Type(Type), TargetNode(TargetNode), Amount(Amount) {} }; - /// \brief Distribution of unscaled probability weight. + /// Distribution of unscaled probability weight. /// /// Distribution of unscaled probability weight to a set of successors. /// @@ -398,7 +398,7 @@ add(Node, Amount, Weight::Backedge); } - /// \brief Normalize the distribution. + /// Normalize the distribution. /// /// Combines multiple edges to the same \a Weight::TargetNode and scales /// down so that \a Total fits into 32-bits. @@ -413,26 +413,26 @@ void add(const BlockNode &Node, uint64_t Amount, Weight::DistType Type); }; - /// \brief Data about each block. This is used downstream. + /// Data about each block. This is used downstream. std::vector Freqs; - /// \brief Whether each block is an irreducible loop header. + /// Whether each block is an irreducible loop header. /// This is used downstream. SparseBitVector<> IsIrrLoopHeader; - /// \brief Loop data: see initializeLoops(). + /// Loop data: see initializeLoops(). std::vector Working; - /// \brief Indexed information about loops. + /// Indexed information about loops. std::list Loops; - /// \brief Virtual destructor. + /// Virtual destructor. /// /// Need a virtual destructor to mask the compiler warning about /// getBlockName(). virtual ~BlockFrequencyInfoImplBase() = default; - /// \brief Add all edges out of a packaged loop to the distribution. + /// Add all edges out of a packaged loop to the distribution. /// /// Adds all edges from LocalLoopHead to Dist. Calls addToDist() to add each /// successor edge. @@ -441,7 +441,7 @@ bool addLoopSuccessorsToDist(const LoopData *OuterLoop, LoopData &Loop, Distribution &Dist); - /// \brief Add an edge to the distribution. + /// Add an edge to the distribution. /// /// Adds an edge to Succ to Dist. If \c LoopHead.isValid(), then whether the /// edge is local/exit/backedge is in the context of LoopHead. Otherwise, @@ -457,7 +457,7 @@ return *Working[Head.Index].Loop; } - /// \brief Analyze irreducible SCCs. + /// Analyze irreducible SCCs. /// /// Separate irreducible SCCs from \c G, which is an explict graph of \c /// OuterLoop (or the top-level function, if \c OuterLoop is \c nullptr). @@ -468,7 +468,7 @@ analyzeIrreducible(const bfi_detail::IrreducibleGraph &G, LoopData *OuterLoop, std::list::iterator Insert); - /// \brief Update a loop after packaging irreducible SCCs inside of it. + /// Update a loop after packaging irreducible SCCs inside of it. /// /// Update \c OuterLoop. Before finding irreducible control flow, it was /// partway through \a computeMassInLoop(), so \a LoopData::Exits and \a @@ -476,7 +476,7 @@ /// up need to be removed from \a OuterLoop::Nodes. void updateLoopWithIrreducible(LoopData &OuterLoop); - /// \brief Distribute mass according to a distribution. + /// Distribute mass according to a distribution. /// /// Distributes the mass in Source according to Dist. If LoopHead.isValid(), /// backedges and exits are stored in its entry in Loops. @@ -485,7 +485,7 @@ void distributeMass(const BlockNode &Source, LoopData *OuterLoop, Distribution &Dist); - /// \brief Compute the loop scale for a loop. + /// Compute the loop scale for a loop. void computeLoopScale(LoopData &Loop); /// Adjust the mass of all headers in an irreducible loop. @@ -500,19 +500,19 @@ void distributeIrrLoopHeaderMass(Distribution &Dist); - /// \brief Package up a loop. + /// Package up a loop. void packageLoop(LoopData &Loop); - /// \brief Unwrap loops. + /// Unwrap loops. void unwrapLoops(); - /// \brief Finalize frequency metrics. + /// Finalize frequency metrics. /// /// Calculates final frequencies and cleans up no-longer-needed data /// structures. void finalizeMetrics(); - /// \brief Clear all memory. + /// Clear all memory. void clear(); virtual std::string getBlockName(const BlockNode &Node) const; @@ -560,7 +560,7 @@ using LoopInfoT = MachineLoopInfo; }; -/// \brief Get the name of a MachineBasicBlock. +/// Get the name of a MachineBasicBlock. /// /// Get the name of a MachineBasicBlock. It's templated so that including from /// CodeGen is unnecessary (that would be a layering issue). @@ -574,13 +574,13 @@ return (MachineName + "[" + BB->getName() + "]").str(); return MachineName.str(); } -/// \brief Get the name of a BasicBlock. +/// Get the name of a BasicBlock. template <> inline std::string getBlockName(const BasicBlock *BB) { assert(BB && "Unexpected nullptr"); return BB->getName().str(); } -/// \brief Graph of irreducible control flow. +/// Graph of irreducible control flow. /// /// This graph is used for determining the SCCs in a loop (or top-level /// function) that has irreducible control flow. @@ -619,7 +619,7 @@ std::vector Nodes; SmallDenseMap Lookup; - /// \brief Construct an explicit graph containing irreducible control flow. + /// Construct an explicit graph containing irreducible control flow. /// /// Construct an explicit graph of the control flow in \c OuterLoop (or the /// top-level function, if \c OuterLoop is \c nullptr). Uses \c @@ -687,7 +687,7 @@ } // end namespace bfi_detail -/// \brief Shared implementation for block frequency analysis. +/// Shared implementation for block frequency analysis. /// /// This is a shared implementation of BlockFrequencyInfo and /// MachineBlockFrequencyInfo, and calculates the relative frequencies of @@ -878,12 +878,12 @@ return RPOT[Node.Index]; } - /// \brief Run (and save) a post-order traversal. + /// Run (and save) a post-order traversal. /// /// Saves a reverse post-order traversal of all the nodes in \a F. void initializeRPOT(); - /// \brief Initialize loop data. + /// Initialize loop data. /// /// Build up \a Loops using \a LoopInfo. \a LoopInfo gives us a mapping from /// each block to the deepest loop it's in, but we need the inverse. For each @@ -892,7 +892,7 @@ /// the loop that are not in sub-loops. void initializeLoops(); - /// \brief Propagate to a block's successors. + /// Propagate to a block's successors. /// /// In the context of distributing mass through \c OuterLoop, divide the mass /// currently assigned to \c Node between its successors. @@ -900,7 +900,7 @@ /// \return \c true unless there's an irreducible backedge. bool propagateMassToSuccessors(LoopData *OuterLoop, const BlockNode &Node); - /// \brief Compute mass in a particular loop. + /// Compute mass in a particular loop. /// /// Assign mass to \c Loop's header, and then for each block in \c Loop in /// reverse post-order, distribute mass to its successors. Only visits nodes @@ -910,7 +910,7 @@ /// \return \c true unless there's an irreducible backedge. bool computeMassInLoop(LoopData &Loop); - /// \brief Try to compute mass in the top-level function. + /// Try to compute mass in the top-level function. /// /// Assign mass to the entry block, and then for each block in reverse /// post-order, distribute mass to its successors. Skips nodes that have @@ -920,7 +920,7 @@ /// \return \c true unless there's an irreducible backedge. bool tryToComputeMassInFunction(); - /// \brief Compute mass in (and package up) irreducible SCCs. + /// Compute mass in (and package up) irreducible SCCs. /// /// Find the irreducible SCCs in \c OuterLoop, add them to \a Loops (in front /// of \c Insert), and call \a computeMassInLoop() on each of them. @@ -935,7 +935,7 @@ void computeIrreducibleMass(LoopData *OuterLoop, std::list::iterator Insert); - /// \brief Compute mass in all loops. + /// Compute mass in all loops. /// /// For each loop bottom-up, call \a computeMassInLoop(). /// @@ -946,7 +946,7 @@ /// \post \a computeMassInLoop() has returned \c true for every loop. void computeMassInLoops(); - /// \brief Compute mass in the top-level function. + /// Compute mass in the top-level function. /// /// Uses \a tryToComputeMassInFunction() and \a computeIrreducibleMass() to /// compute mass in the top-level function. @@ -994,7 +994,7 @@ const BranchProbabilityInfoT &getBPI() const { return *BPI; } - /// \brief Print the frequencies for the current function. + /// Print the frequencies for the current function. /// /// Prints the frequencies for the blocks in the current function. /// Index: llvm/trunk/include/llvm/Analysis/BranchProbabilityInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/BranchProbabilityInfo.h +++ llvm/trunk/include/llvm/Analysis/BranchProbabilityInfo.h @@ -38,7 +38,7 @@ class TargetLibraryInfo; class Value; -/// \brief Analysis providing branch probability information. +/// Analysis providing branch probability information. /// /// This is a function analysis which provides information on the relative /// probabilities of each "edge" in the function's CFG where such an edge is @@ -79,7 +79,7 @@ void print(raw_ostream &OS) const; - /// \brief Get an edge's probability, relative to other out-edges of the Src. + /// Get an edge's probability, relative to other out-edges of the Src. /// /// This routine provides access to the fractional probability between zero /// (0%) and one (100%) of this edge executing, relative to other edges @@ -88,7 +88,7 @@ BranchProbability getEdgeProbability(const BasicBlock *Src, unsigned IndexInSuccessors) const; - /// \brief Get the probability of going from Src to Dst. + /// Get the probability of going from Src to Dst. /// /// It returns the sum of all probabilities for edges from Src to Dst. BranchProbability getEdgeProbability(const BasicBlock *Src, @@ -97,19 +97,19 @@ BranchProbability getEdgeProbability(const BasicBlock *Src, succ_const_iterator Dst) const; - /// \brief Test if an edge is hot relative to other out-edges of the Src. + /// Test if an edge is hot relative to other out-edges of the Src. /// /// Check whether this edge out of the source block is 'hot'. We define hot /// as having a relative probability >= 80%. bool isEdgeHot(const BasicBlock *Src, const BasicBlock *Dst) const; - /// \brief Retrieve the hot successor of a block if one exists. + /// Retrieve the hot successor of a block if one exists. /// /// Given a basic block, look through its successors and if one exists for /// which \see isEdgeHot would return true, return that successor block. const BasicBlock *getHotSucc(const BasicBlock *BB) const; - /// \brief Print an edge's probability. + /// Print an edge's probability. /// /// Retrieves an edge's probability similarly to \see getEdgeProbability, but /// then prints that probability to the provided stream. That stream is then @@ -117,7 +117,7 @@ raw_ostream &printEdgeProbability(raw_ostream &OS, const BasicBlock *Src, const BasicBlock *Dst) const; - /// \brief Set the raw edge probability for the given edge. + /// Set the raw edge probability for the given edge. /// /// This allows a pass to explicitly set the edge probability for an edge. It /// can be used when updating the CFG to update and preserve the branch @@ -179,13 +179,13 @@ DenseMap Probs; - /// \brief Track the last function we run over for printing. + /// Track the last function we run over for printing. const Function *LastF; - /// \brief Track the set of blocks directly succeeded by a returning block. + /// Track the set of blocks directly succeeded by a returning block. SmallPtrSet PostDominatedByUnreachable; - /// \brief Track the set of blocks that always lead to a cold call. + /// Track the set of blocks that always lead to a cold call. SmallPtrSet PostDominatedByColdCall; void updatePostDominatedByUnreachable(const BasicBlock *BB); @@ -201,7 +201,7 @@ bool calcInvokeHeuristics(const BasicBlock *BB); }; -/// \brief Analysis pass which computes \c BranchProbabilityInfo. +/// Analysis pass which computes \c BranchProbabilityInfo. class BranchProbabilityAnalysis : public AnalysisInfoMixin { friend AnalysisInfoMixin; @@ -209,14 +209,14 @@ static AnalysisKey Key; public: - /// \brief Provide the result type for this analysis pass. + /// Provide the result type for this analysis pass. using Result = BranchProbabilityInfo; - /// \brief Run the analysis pass over a function and produce BPI. + /// Run the analysis pass over a function and produce BPI. BranchProbabilityInfo run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Printer pass for the \c BranchProbabilityAnalysis results. +/// Printer pass for the \c BranchProbabilityAnalysis results. class BranchProbabilityPrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -227,7 +227,7 @@ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Legacy analysis pass which computes \c BranchProbabilityInfo. +/// Legacy analysis pass which computes \c BranchProbabilityInfo. class BranchProbabilityInfoWrapperPass : public FunctionPass { BranchProbabilityInfo BPI; Index: llvm/trunk/include/llvm/Analysis/CFG.h =================================================================== --- llvm/trunk/include/llvm/Analysis/CFG.h +++ llvm/trunk/include/llvm/Analysis/CFG.h @@ -49,7 +49,7 @@ bool isCriticalEdge(const TerminatorInst *TI, unsigned SuccNum, bool AllowIdenticalEdges = false); -/// \brief Determine whether instruction 'To' is reachable from 'From', +/// Determine whether instruction 'To' is reachable from 'From', /// returning true if uncertain. /// /// Determine whether there is a path from From to To within a single function. @@ -68,7 +68,7 @@ const DominatorTree *DT = nullptr, const LoopInfo *LI = nullptr); -/// \brief Determine whether block 'To' is reachable from 'From', returning +/// Determine whether block 'To' is reachable from 'From', returning /// true if uncertain. /// /// Determine whether there is a path from From to To within a single function. @@ -78,7 +78,7 @@ const DominatorTree *DT = nullptr, const LoopInfo *LI = nullptr); -/// \brief Determine whether there is at least one path from a block in +/// Determine whether there is at least one path from a block in /// 'Worklist' to 'StopBB', returning true if uncertain. /// /// Determine whether there is a path from at least one block in Worklist to @@ -90,7 +90,7 @@ const DominatorTree *DT = nullptr, const LoopInfo *LI = nullptr); -/// \brief Return true if the control flow in \p RPOTraversal is irreducible. +/// Return true if the control flow in \p RPOTraversal is irreducible. /// /// This is a generic implementation to detect CFG irreducibility based on loop /// info analysis. It can be used for any kind of CFG (Loop, MachineLoop, Index: llvm/trunk/include/llvm/Analysis/CFLAndersAliasAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/CFLAndersAliasAnalysis.h +++ llvm/trunk/include/llvm/Analysis/CFLAndersAliasAnalysis.h @@ -56,7 +56,7 @@ /// Evict the given function from cache void evict(const Function *Fn); - /// \brief Get the alias summary for the given function + /// Get the alias summary for the given function /// Return nullptr if the summary is not found or not available const cflaa::AliasSummary *getAliasSummary(const Function &); @@ -64,19 +64,19 @@ AliasResult alias(const MemoryLocation &, const MemoryLocation &); private: - /// \brief Ensures that the given function is available in the cache. + /// Ensures that the given function is available in the cache. /// Returns the appropriate entry from the cache. const Optional &ensureCached(const Function &); - /// \brief Inserts the given Function into the cache. + /// Inserts the given Function into the cache. void scan(const Function &); - /// \brief Build summary for a given function + /// Build summary for a given function FunctionInfo buildInfoFrom(const Function &); const TargetLibraryInfo &TLI; - /// \brief Cached mapping of Functions to their StratifiedSets. + /// Cached mapping of Functions to their StratifiedSets. /// If a function's sets are currently being built, it is marked /// in the cache as an Optional without a value. This way, if we /// have any kind of recursion, it is discernable from a function Index: llvm/trunk/include/llvm/Analysis/CFLSteensAliasAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/CFLSteensAliasAnalysis.h +++ llvm/trunk/include/llvm/Analysis/CFLSteensAliasAnalysis.h @@ -55,16 +55,16 @@ return false; } - /// \brief Inserts the given Function into the cache. + /// Inserts the given Function into the cache. void scan(Function *Fn); void evict(Function *Fn); - /// \brief Ensures that the given function is available in the cache. + /// Ensures that the given function is available in the cache. /// Returns the appropriate entry from the cache. const Optional &ensureCached(Function *Fn); - /// \brief Get the alias summary for the given function + /// Get the alias summary for the given function /// Return nullptr if the summary is not found or not available const cflaa::AliasSummary *getAliasSummary(Function &Fn); @@ -92,7 +92,7 @@ private: const TargetLibraryInfo &TLI; - /// \brief Cached mapping of Functions to their StratifiedSets. + /// Cached mapping of Functions to their StratifiedSets. /// If a function's sets are currently being built, it is marked /// in the cache as an Optional without a value. This way, if we /// have any kind of recursion, it is discernable from a function Index: llvm/trunk/include/llvm/Analysis/CGSCCPassManager.h =================================================================== --- llvm/trunk/include/llvm/Analysis/CGSCCPassManager.h +++ llvm/trunk/include/llvm/Analysis/CGSCCPassManager.h @@ -119,7 +119,7 @@ extern template class AnalysisManager; -/// \brief The CGSCC analysis manager. +/// The CGSCC analysis manager. /// /// See the documentation for the AnalysisManager template for detail /// documentation. This type serves as a convenient way to refer to this @@ -140,7 +140,7 @@ extern template class PassManager; -/// \brief The CGSCC pass manager. +/// The CGSCC pass manager. /// /// See the documentation for the PassManager template for details. It runs /// a sequence of SCC passes over each SCC that the manager is run over. This @@ -175,10 +175,10 @@ explicit Result(CGSCCAnalysisManager &InnerAM, LazyCallGraph &G) : InnerAM(&InnerAM), G(&G) {} - /// \brief Accessor for the analysis manager. + /// Accessor for the analysis manager. CGSCCAnalysisManager &getManager() { return *InnerAM; } - /// \brief Handler for invalidation of the Module. + /// Handler for invalidation of the Module. /// /// If the proxy analysis itself is preserved, then we assume that the set of /// SCCs in the Module hasn't changed. Thus any pointers to SCCs in the @@ -302,7 +302,7 @@ &InlinedInternalEdges; }; -/// \brief The core module pass which does a post-order walk of the SCCs and +/// The core module pass which does a post-order walk of the SCCs and /// runs a CGSCC pass over each one. /// /// Designed to allow composition of a CGSCCPass(Manager) and @@ -338,7 +338,7 @@ return *this; } - /// \brief Runs the CGSCC pass across every SCC in the module. + /// Runs the CGSCC pass across every SCC in the module. PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { // Setup the CGSCC analysis manager from its proxy. CGSCCAnalysisManager &CGAM = @@ -494,7 +494,7 @@ CGSCCPassT Pass; }; -/// \brief A function to deduce a function pass type and wrap it in the +/// A function to deduce a function pass type and wrap it in the /// templated adaptor. template ModuleToPostOrderCGSCCPassAdaptor @@ -517,7 +517,7 @@ public: explicit Result(FunctionAnalysisManager &FAM) : FAM(&FAM) {} - /// \brief Accessor for the analysis manager. + /// Accessor for the analysis manager. FunctionAnalysisManager &getManager() { return *FAM; } bool invalidate(LazyCallGraph::SCC &C, const PreservedAnalyses &PA, @@ -552,7 +552,7 @@ LazyCallGraph &G, LazyCallGraph::SCC &C, LazyCallGraph::Node &N, CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR); -/// \brief Adaptor that maps from a SCC to its functions. +/// Adaptor that maps from a SCC to its functions. /// /// Designed to allow composition of a FunctionPass(Manager) and /// a CGSCCPassManager. Note that if this pass is constructed with a pointer @@ -585,7 +585,7 @@ return *this; } - /// \brief Runs the function pass across every function in the module. + /// Runs the function pass across every function in the module. PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR) { // Setup the function analysis manager from its proxy. @@ -652,7 +652,7 @@ FunctionPassT Pass; }; -/// \brief A function to deduce a function pass type and wrap it in the +/// A function to deduce a function pass type and wrap it in the /// templated adaptor. template CGSCCToFunctionPassAdaptor @@ -824,7 +824,7 @@ int MaxIterations; }; -/// \brief A function to deduce a function pass type and wrap it in the +/// A function to deduce a function pass type and wrap it in the /// templated adaptor. template DevirtSCCRepeatedPass createDevirtSCCRepeatedPass(PassT Pass, Index: llvm/trunk/include/llvm/Analysis/CallGraph.h =================================================================== --- llvm/trunk/include/llvm/Analysis/CallGraph.h +++ llvm/trunk/include/llvm/Analysis/CallGraph.h @@ -66,7 +66,7 @@ class Module; class raw_ostream; -/// \brief The basic data container for the call graph of a \c Module of IR. +/// The basic data container for the call graph of a \c Module of IR. /// /// This class exposes both the interface to the call graph for a module of IR. /// @@ -77,25 +77,25 @@ using FunctionMapTy = std::map>; - /// \brief A map from \c Function* to \c CallGraphNode*. + /// A map from \c Function* to \c CallGraphNode*. FunctionMapTy FunctionMap; - /// \brief This node has edges to all external functions and those internal + /// This node has edges to all external functions and those internal /// functions that have their address taken. CallGraphNode *ExternalCallingNode; - /// \brief This node has edges to it from all functions making indirect calls + /// This node has edges to it from all functions making indirect calls /// or calling an external function. std::unique_ptr CallsExternalNode; - /// \brief Replace the function represented by this node by another. + /// Replace the function represented by this node by another. /// /// This does not rescan the body of the function, so it is suitable when /// splicing the body of one function to another while also updating all /// callers from the old function to the new. void spliceFunction(const Function *From, const Function *To); - /// \brief Add a function to the call graph, and link the node to all of the + /// Add a function to the call graph, and link the node to all of the /// functions that it calls. void addToCallGraph(Function *F); @@ -110,7 +110,7 @@ using iterator = FunctionMapTy::iterator; using const_iterator = FunctionMapTy::const_iterator; - /// \brief Returns the module the call graph corresponds to. + /// Returns the module the call graph corresponds to. Module &getModule() const { return M; } inline iterator begin() { return FunctionMap.begin(); } @@ -118,21 +118,21 @@ inline const_iterator begin() const { return FunctionMap.begin(); } inline const_iterator end() const { return FunctionMap.end(); } - /// \brief Returns the call graph node for the provided function. + /// Returns the call graph node for the provided function. inline const CallGraphNode *operator[](const Function *F) const { const_iterator I = FunctionMap.find(F); assert(I != FunctionMap.end() && "Function not in callgraph!"); return I->second.get(); } - /// \brief Returns the call graph node for the provided function. + /// Returns the call graph node for the provided function. inline CallGraphNode *operator[](const Function *F) { const_iterator I = FunctionMap.find(F); assert(I != FunctionMap.end() && "Function not in callgraph!"); return I->second.get(); } - /// \brief Returns the \c CallGraphNode which is used to represent + /// Returns the \c CallGraphNode which is used to represent /// undetermined calls into the callgraph. CallGraphNode *getExternalCallingNode() const { return ExternalCallingNode; } @@ -145,7 +145,7 @@ // modified. // - /// \brief Unlink the function from this module, returning it. + /// Unlink the function from this module, returning it. /// /// Because this removes the function from the module, the call graph node is /// destroyed. This is only valid if the function does not call any other @@ -153,25 +153,25 @@ /// this is to dropAllReferences before calling this. Function *removeFunctionFromModule(CallGraphNode *CGN); - /// \brief Similar to operator[], but this will insert a new CallGraphNode for + /// Similar to operator[], but this will insert a new CallGraphNode for /// \c F if one does not already exist. CallGraphNode *getOrInsertFunction(const Function *F); }; -/// \brief A node in the call graph for a module. +/// A node in the call graph for a module. /// /// Typically represents a function in the call graph. There are also special /// "null" nodes used to represent theoretical entries in the call graph. class CallGraphNode { public: - /// \brief A pair of the calling instruction (a call or invoke) + /// A pair of the calling instruction (a call or invoke) /// and the call graph node being called. using CallRecord = std::pair; public: using CalledFunctionsVector = std::vector; - /// \brief Creates a node for the specified function. + /// Creates a node for the specified function. inline CallGraphNode(Function *F) : F(F) {} CallGraphNode(const CallGraphNode &) = delete; @@ -184,7 +184,7 @@ using iterator = std::vector::iterator; using const_iterator = std::vector::const_iterator; - /// \brief Returns the function that this call graph node represents. + /// Returns the function that this call graph node represents. Function *getFunction() const { return F; } inline iterator begin() { return CalledFunctions.begin(); } @@ -194,17 +194,17 @@ inline bool empty() const { return CalledFunctions.empty(); } inline unsigned size() const { return (unsigned)CalledFunctions.size(); } - /// \brief Returns the number of other CallGraphNodes in this CallGraph that + /// Returns the number of other CallGraphNodes in this CallGraph that /// reference this node in their callee list. unsigned getNumReferences() const { return NumReferences; } - /// \brief Returns the i'th called function. + /// Returns the i'th called function. CallGraphNode *operator[](unsigned i) const { assert(i < CalledFunctions.size() && "Invalid index"); return CalledFunctions[i].second; } - /// \brief Print out this call graph node. + /// Print out this call graph node. void dump() const; void print(raw_ostream &OS) const; @@ -213,7 +213,7 @@ // modified // - /// \brief Removes all edges from this CallGraphNode to any functions it + /// Removes all edges from this CallGraphNode to any functions it /// calls. void removeAllCalledFunctions() { while (!CalledFunctions.empty()) { @@ -222,14 +222,14 @@ } } - /// \brief Moves all the callee information from N to this node. + /// Moves all the callee information from N to this node. void stealCalledFunctionsFrom(CallGraphNode *N) { assert(CalledFunctions.empty() && "Cannot steal callsite information if I already have some"); std::swap(CalledFunctions, N->CalledFunctions); } - /// \brief Adds a function to the list of functions called by this one. + /// Adds a function to the list of functions called by this one. void addCalledFunction(CallSite CS, CallGraphNode *M) { assert(!CS.getInstruction() || !CS.getCalledFunction() || !CS.getCalledFunction()->isIntrinsic() || @@ -244,23 +244,23 @@ CalledFunctions.pop_back(); } - /// \brief Removes the edge in the node for the specified call site. + /// Removes the edge in the node for the specified call site. /// /// Note that this method takes linear time, so it should be used sparingly. void removeCallEdgeFor(CallSite CS); - /// \brief Removes all call edges from this node to the specified callee + /// Removes all call edges from this node to the specified callee /// function. /// /// This takes more time to execute than removeCallEdgeTo, so it should not /// be used unless necessary. void removeAnyCallEdgeTo(CallGraphNode *Callee); - /// \brief Removes one edge associated with a null callsite from this node to + /// Removes one edge associated with a null callsite from this node to /// the specified callee function. void removeOneAbstractEdgeTo(CallGraphNode *Callee); - /// \brief Replaces the edge in the node for the specified call site with a + /// Replaces the edge in the node for the specified call site with a /// new one. /// /// Note that this method takes linear time, so it should be used sparingly. @@ -273,18 +273,18 @@ std::vector CalledFunctions; - /// \brief The number of times that this CallGraphNode occurs in the + /// The number of times that this CallGraphNode occurs in the /// CalledFunctions array of this or other CallGraphNodes. unsigned NumReferences = 0; void DropRef() { --NumReferences; } void AddRef() { ++NumReferences; } - /// \brief A special function that should only be used by the CallGraph class. + /// A special function that should only be used by the CallGraph class. void allReferencesDropped() { NumReferences = 0; } }; -/// \brief An analysis pass to compute the \c CallGraph for a \c Module. +/// An analysis pass to compute the \c CallGraph for a \c Module. /// /// This class implements the concept of an analysis pass used by the \c /// ModuleAnalysisManager to run an analysis over a module and cache the @@ -295,16 +295,16 @@ static AnalysisKey Key; public: - /// \brief A formulaic type to inform clients of the result type. + /// A formulaic type to inform clients of the result type. using Result = CallGraph; - /// \brief Compute the \c CallGraph for the module \c M. + /// Compute the \c CallGraph for the module \c M. /// /// The real work here is done in the \c CallGraph constructor. CallGraph run(Module &M, ModuleAnalysisManager &) { return CallGraph(M); } }; -/// \brief Printer pass for the \c CallGraphAnalysis results. +/// Printer pass for the \c CallGraphAnalysis results. class CallGraphPrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -314,7 +314,7 @@ PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); }; -/// \brief The \c ModulePass which wraps up a \c CallGraph and the logic to +/// The \c ModulePass which wraps up a \c CallGraph and the logic to /// build it. /// /// This class exposes both the interface to the call graph container and the @@ -330,7 +330,7 @@ CallGraphWrapperPass(); ~CallGraphWrapperPass() override; - /// \brief The internal \c CallGraph around which the rest of this interface + /// The internal \c CallGraph around which the rest of this interface /// is wrapped. const CallGraph &getCallGraph() const { return *G; } CallGraph &getCallGraph() { return *G; } @@ -338,7 +338,7 @@ using iterator = CallGraph::iterator; using const_iterator = CallGraph::const_iterator; - /// \brief Returns the module the call graph corresponds to. + /// Returns the module the call graph corresponds to. Module &getModule() const { return G->getModule(); } inline iterator begin() { return G->begin(); } @@ -346,15 +346,15 @@ inline const_iterator begin() const { return G->begin(); } inline const_iterator end() const { return G->end(); } - /// \brief Returns the call graph node for the provided function. + /// Returns the call graph node for the provided function. inline const CallGraphNode *operator[](const Function *F) const { return (*G)[F]; } - /// \brief Returns the call graph node for the provided function. + /// Returns the call graph node for the provided function. inline CallGraphNode *operator[](const Function *F) { return (*G)[F]; } - /// \brief Returns the \c CallGraphNode which is used to represent + /// Returns the \c CallGraphNode which is used to represent /// undetermined calls into the callgraph. CallGraphNode *getExternalCallingNode() const { return G->getExternalCallingNode(); @@ -369,7 +369,7 @@ // modified. // - /// \brief Unlink the function from this module, returning it. + /// Unlink the function from this module, returning it. /// /// Because this removes the function from the module, the call graph node is /// destroyed. This is only valid if the function does not call any other @@ -379,7 +379,7 @@ return G->removeFunctionFromModule(CGN); } - /// \brief Similar to operator[], but this will insert a new CallGraphNode for + /// Similar to operator[], but this will insert a new CallGraphNode for /// \c F if one does not already exist. CallGraphNode *getOrInsertFunction(const Function *F) { return G->getOrInsertFunction(F); Index: llvm/trunk/include/llvm/Analysis/CodeMetrics.h =================================================================== --- llvm/trunk/include/llvm/Analysis/CodeMetrics.h +++ llvm/trunk/include/llvm/Analysis/CodeMetrics.h @@ -29,7 +29,7 @@ class TargetTransformInfo; class Value; -/// \brief Check whether a call will lower to something small. +/// Check whether a call will lower to something small. /// /// This tests checks whether this callsite will lower to something /// significantly cheaper than a traditional call, often a single @@ -37,64 +37,64 @@ /// return true, so will this function. bool callIsSmall(ImmutableCallSite CS); -/// \brief Utility to calculate the size and a few similar metrics for a set +/// Utility to calculate the size and a few similar metrics for a set /// of basic blocks. struct CodeMetrics { - /// \brief True if this function contains a call to setjmp or other functions + /// True if this function contains a call to setjmp or other functions /// with attribute "returns twice" without having the attribute itself. bool exposesReturnsTwice = false; - /// \brief True if this function calls itself. + /// True if this function calls itself. bool isRecursive = false; - /// \brief True if this function cannot be duplicated. + /// True if this function cannot be duplicated. /// /// True if this function contains one or more indirect branches, or it contains /// one or more 'noduplicate' instructions. bool notDuplicatable = false; - /// \brief True if this function contains a call to a convergent function. + /// True if this function contains a call to a convergent function. bool convergent = false; - /// \brief True if this function calls alloca (in the C sense). + /// True if this function calls alloca (in the C sense). bool usesDynamicAlloca = false; - /// \brief Number of instructions in the analyzed blocks. + /// Number of instructions in the analyzed blocks. unsigned NumInsts = false; - /// \brief Number of analyzed blocks. + /// Number of analyzed blocks. unsigned NumBlocks = false; - /// \brief Keeps track of basic block code size estimates. + /// Keeps track of basic block code size estimates. DenseMap NumBBInsts; - /// \brief Keep track of the number of calls to 'big' functions. + /// Keep track of the number of calls to 'big' functions. unsigned NumCalls = false; - /// \brief The number of calls to internal functions with a single caller. + /// The number of calls to internal functions with a single caller. /// /// These are likely targets for future inlining, likely exposed by /// interleaved devirtualization. unsigned NumInlineCandidates = 0; - /// \brief How many instructions produce vector values. + /// How many instructions produce vector values. /// /// The inliner is more aggressive with inlining vector kernels. unsigned NumVectorInsts = 0; - /// \brief How many 'ret' instructions the blocks contain. + /// How many 'ret' instructions the blocks contain. unsigned NumRets = 0; - /// \brief Add information about a block to the current state. + /// Add information about a block to the current state. void analyzeBasicBlock(const BasicBlock *BB, const TargetTransformInfo &TTI, const SmallPtrSetImpl &EphValues); - /// \brief Collect a loop's ephemeral values (those used only by an assume + /// Collect a loop's ephemeral values (those used only by an assume /// or similar intrinsics in the loop). static void collectEphemeralValues(const Loop *L, AssumptionCache *AC, SmallPtrSetImpl &EphValues); - /// \brief Collect a functions's ephemeral values (those used only by an + /// Collect a functions's ephemeral values (those used only by an /// assume or similar intrinsics in the function). static void collectEphemeralValues(const Function *L, AssumptionCache *AC, SmallPtrSetImpl &EphValues); Index: llvm/trunk/include/llvm/Analysis/ConstantFolding.h =================================================================== --- llvm/trunk/include/llvm/Analysis/ConstantFolding.h +++ llvm/trunk/include/llvm/Analysis/ConstantFolding.h @@ -73,19 +73,19 @@ Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI = nullptr); -/// \brief Attempt to constant fold a binary operation with the specified +/// Attempt to constant fold a binary operation with the specified /// operands. If it fails, it returns a constant expression of the specified /// operands. Constant *ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL); -/// \brief Attempt to constant fold a select instruction with the specified +/// Attempt to constant fold a select instruction with the specified /// operands. The constant result is returned if successful; if not, null is /// returned. Constant *ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2); -/// \brief Attempt to constant fold a cast with the specified operand. If it +/// Attempt to constant fold a cast with the specified operand. If it /// fails, it returns a constant expression of the specified operand. Constant *ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL); @@ -96,25 +96,25 @@ Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef Idxs); -/// \brief Attempt to constant fold an extractvalue instruction with the +/// Attempt to constant fold an extractvalue instruction with the /// specified operands and indices. The constant result is returned if /// successful; if not, null is returned. Constant *ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef Idxs); -/// \brief Attempt to constant fold an insertelement instruction with the +/// Attempt to constant fold an insertelement instruction with the /// specified operands and indices. The constant result is returned if /// successful; if not, null is returned. Constant *ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx); -/// \brief Attempt to constant fold an extractelement instruction with the +/// Attempt to constant fold an extractelement instruction with the /// specified operands and indices. The constant result is returned if /// successful; if not, null is returned. Constant *ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx); -/// \brief Attempt to constant fold a shufflevector instruction with the +/// Attempt to constant fold a shufflevector instruction with the /// specified operands and indices. The constant result is returned if /// successful; if not, null is returned. Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, @@ -153,7 +153,7 @@ Constant *ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy, const DataLayout &DL); -/// \brief Check whether the given call has no side-effects. +/// Check whether the given call has no side-effects. /// Specifically checks for math routimes which sometimes set errno. bool isMathLibCallNoop(CallSite CS, const TargetLibraryInfo *TLI); } Index: llvm/trunk/include/llvm/Analysis/DOTGraphTraitsPass.h =================================================================== --- llvm/trunk/include/llvm/Analysis/DOTGraphTraitsPass.h +++ llvm/trunk/include/llvm/Analysis/DOTGraphTraitsPass.h @@ -20,7 +20,7 @@ namespace llvm { -/// \brief Default traits class for extracting a graph from an analysis pass. +/// Default traits class for extracting a graph from an analysis pass. /// /// This assumes that 'GraphT' is 'AnalysisT *' and so just passes it through. template Index: llvm/trunk/include/llvm/Analysis/DemandedBits.h =================================================================== --- llvm/trunk/include/llvm/Analysis/DemandedBits.h +++ llvm/trunk/include/llvm/Analysis/DemandedBits.h @@ -96,15 +96,15 @@ static AnalysisKey Key; public: - /// \brief Provide the result type for this analysis pass. + /// Provide the result type for this analysis pass. using Result = DemandedBits; - /// \brief Run the analysis pass over a function and produce demanded bits + /// Run the analysis pass over a function and produce demanded bits /// information. DemandedBits run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Printer pass for DemandedBits +/// Printer pass for DemandedBits class DemandedBitsPrinterPass : public PassInfoMixin { raw_ostream &OS; Index: llvm/trunk/include/llvm/Analysis/DependenceAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/DependenceAnalysis.h +++ llvm/trunk/include/llvm/Analysis/DependenceAnalysis.h @@ -914,7 +914,7 @@ SmallVectorImpl &Pair); }; // class DependenceInfo - /// \brief AnalysisPass to compute dependence information in a function + /// AnalysisPass to compute dependence information in a function class DependenceAnalysis : public AnalysisInfoMixin { public: typedef DependenceInfo Result; @@ -925,7 +925,7 @@ friend struct AnalysisInfoMixin; }; // class DependenceAnalysis - /// \brief Legacy pass manager pass to access dependence information + /// Legacy pass manager pass to access dependence information class DependenceAnalysisWrapperPass : public FunctionPass { public: static char ID; // Class identification, replacement for typeinfo Index: llvm/trunk/include/llvm/Analysis/DominanceFrontier.h =================================================================== --- llvm/trunk/include/llvm/Analysis/DominanceFrontier.h +++ llvm/trunk/include/llvm/Analysis/DominanceFrontier.h @@ -180,7 +180,7 @@ extern template class DominanceFrontierBase; extern template class ForwardDominanceFrontierBase; -/// \brief Analysis pass which computes a \c DominanceFrontier. +/// Analysis pass which computes a \c DominanceFrontier. class DominanceFrontierAnalysis : public AnalysisInfoMixin { friend AnalysisInfoMixin; @@ -188,14 +188,14 @@ static AnalysisKey Key; public: - /// \brief Provide the result type for this analysis pass. + /// Provide the result type for this analysis pass. using Result = DominanceFrontier; - /// \brief Run the analysis pass over a function and produce a dominator tree. + /// Run the analysis pass over a function and produce a dominator tree. DominanceFrontier run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Printer pass for the \c DominanceFrontier. +/// Printer pass for the \c DominanceFrontier. class DominanceFrontierPrinterPass : public PassInfoMixin { raw_ostream &OS; Index: llvm/trunk/include/llvm/Analysis/EHPersonalities.h =================================================================== --- llvm/trunk/include/llvm/Analysis/EHPersonalities.h +++ llvm/trunk/include/llvm/Analysis/EHPersonalities.h @@ -35,7 +35,7 @@ Rust }; -/// \brief See if the given exception handling personality function is one +/// See if the given exception handling personality function is one /// that we understand. If so, return a description of it; otherwise return /// Unknown. EHPersonality classifyEHPersonality(const Value *Pers); @@ -44,7 +44,7 @@ EHPersonality getDefaultEHPersonality(const Triple &T); -/// \brief Returns true if this personality function catches asynchronous +/// Returns true if this personality function catches asynchronous /// exceptions. inline bool isAsynchronousEHPersonality(EHPersonality Pers) { // The two SEH personality functions can catch asynch exceptions. We assume @@ -59,7 +59,7 @@ llvm_unreachable("invalid enum"); } -/// \brief Returns true if this is a personality function that invokes +/// Returns true if this is a personality function that invokes /// handler funclets (which must return to it). inline bool isFuncletEHPersonality(EHPersonality Pers) { switch (Pers) { @@ -74,7 +74,7 @@ llvm_unreachable("invalid enum"); } -/// \brief Return true if this personality may be safely removed if there +/// Return true if this personality may be safely removed if there /// are no invoke instructions remaining in the current function. inline bool isNoOpWithoutInvoke(EHPersonality Pers) { switch (Pers) { @@ -91,7 +91,7 @@ typedef TinyPtrVector ColorVector; -/// \brief If an EH funclet personality is in use (see isFuncletEHPersonality), +/// If an EH funclet personality is in use (see isFuncletEHPersonality), /// this will recompute which blocks are in which funclet. It is possible that /// some blocks are in multiple funclets. Consider this analysis to be /// expensive. Index: llvm/trunk/include/llvm/Analysis/IndirectCallPromotionAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/IndirectCallPromotionAnalysis.h +++ llvm/trunk/include/llvm/Analysis/IndirectCallPromotionAnalysis.h @@ -48,7 +48,7 @@ public: ICallPromotionAnalysis(); - /// \brief Returns reference to array of InstrProfValueData for the given + /// Returns reference to array of InstrProfValueData for the given /// instruction \p I. /// /// The \p NumVals, \p TotalCount and \p NumCandidates Index: llvm/trunk/include/llvm/Analysis/InlineCost.h =================================================================== --- llvm/trunk/include/llvm/Analysis/InlineCost.h +++ llvm/trunk/include/llvm/Analysis/InlineCost.h @@ -52,7 +52,7 @@ const unsigned TotalAllocaSizeRecursiveCaller = 1024; } -/// \brief Represents the cost of inlining a function. +/// Represents the cost of inlining a function. /// /// This supports special values for functions which should "always" or /// "never" be inlined. Otherwise, the cost represents a unitless amount; @@ -68,10 +68,10 @@ NeverInlineCost = INT_MAX }; - /// \brief The estimated cost of inlining this callsite. + /// The estimated cost of inlining this callsite. const int Cost; - /// \brief The adjusted threshold against which this cost was computed. + /// The adjusted threshold against which this cost was computed. const int Threshold; // Trivial constructor, interesting logic in the factory functions below. @@ -90,7 +90,7 @@ return InlineCost(NeverInlineCost, 0); } - /// \brief Test whether the inline cost is low enough for inlining. + /// Test whether the inline cost is low enough for inlining. explicit operator bool() const { return Cost < Threshold; } @@ -99,20 +99,20 @@ bool isNever() const { return Cost == NeverInlineCost; } bool isVariable() const { return !isAlways() && !isNever(); } - /// \brief Get the inline cost estimate. + /// Get the inline cost estimate. /// It is an error to call this on an "always" or "never" InlineCost. int getCost() const { assert(isVariable() && "Invalid access of InlineCost"); return Cost; } - /// \brief Get the threshold against which the cost was computed + /// Get the threshold against which the cost was computed int getThreshold() const { assert(isVariable() && "Invalid access of InlineCost"); return Threshold; } - /// \brief Get the cost delta from the threshold for inlining. + /// Get the cost delta from the threshold for inlining. /// Only valid if the cost is of the variable kind. Returns a negative /// value if the cost is too high to inline. int getCostDelta() const { return Threshold - getCost(); } @@ -178,7 +178,7 @@ /// and the call/return instruction. int getCallsiteCost(CallSite CS, const DataLayout &DL); -/// \brief Get an InlineCost object representing the cost of inlining this +/// Get an InlineCost object representing the cost of inlining this /// callsite. /// /// Note that a default threshold is passed into this function. This threshold @@ -195,7 +195,7 @@ Optional> GetBFI, ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE = nullptr); -/// \brief Get an InlineCost with the callee explicitly specified. +/// Get an InlineCost with the callee explicitly specified. /// This allows you to calculate the cost of inlining a function via a /// pointer. This behaves exactly as the version with no explicit callee /// parameter in all other respects. @@ -207,7 +207,7 @@ Optional> GetBFI, ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE); -/// \brief Minimal filter to detect invalid constructs for inlining. +/// Minimal filter to detect invalid constructs for inlining. bool isInlineViable(Function &Callee); } Index: llvm/trunk/include/llvm/Analysis/IteratedDominanceFrontier.h =================================================================== --- llvm/trunk/include/llvm/Analysis/IteratedDominanceFrontier.h +++ llvm/trunk/include/llvm/Analysis/IteratedDominanceFrontier.h @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -/// \brief Compute iterated dominance frontiers using a linear time algorithm. +/// Compute iterated dominance frontiers using a linear time algorithm. /// /// The algorithm used here is based on: /// @@ -32,7 +32,7 @@ namespace llvm { -/// \brief Determine the iterated dominance frontier, given a set of defining +/// Determine the iterated dominance frontier, given a set of defining /// blocks, and optionally, a set of live-in blocks. /// /// In turn, the results can be used to place phi nodes. @@ -48,7 +48,7 @@ IDFCalculator(DominatorTreeBase &DT) : DT(DT), useLiveIn(false) {} - /// \brief Give the IDF calculator the set of blocks in which the value is + /// Give the IDF calculator the set of blocks in which the value is /// defined. This is equivalent to the set of starting blocks it should be /// calculating the IDF for (though later gets pruned based on liveness). /// @@ -57,7 +57,7 @@ DefBlocks = &Blocks; } - /// \brief Give the IDF calculator the set of blocks in which the value is + /// Give the IDF calculator the set of blocks in which the value is /// live on entry to the block. This is used to prune the IDF calculation to /// not include blocks where any phi insertion would be dead. /// @@ -68,14 +68,14 @@ useLiveIn = true; } - /// \brief Reset the live-in block set to be empty, and tell the IDF + /// Reset the live-in block set to be empty, and tell the IDF /// calculator to not use liveness anymore. void resetLiveInBlocks() { LiveInBlocks = nullptr; useLiveIn = false; } - /// \brief Calculate iterated dominance frontiers + /// Calculate iterated dominance frontiers /// /// This uses the linear-time phi algorithm based on DJ-graphs mentioned in /// the file-level comment. It performs DF->IDF pruning using the live-in Index: llvm/trunk/include/llvm/Analysis/LazyBlockFrequencyInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/LazyBlockFrequencyInfo.h +++ llvm/trunk/include/llvm/Analysis/LazyBlockFrequencyInfo.h @@ -75,7 +75,7 @@ const LoopInfoT *LI; }; -/// \brief This is an alternative analysis pass to +/// This is an alternative analysis pass to /// BlockFrequencyInfoWrapperPass. The difference is that with this pass the /// block frequencies are not computed when the analysis pass is executed but /// rather when the BFI result is explicitly requested by the analysis client. @@ -109,10 +109,10 @@ LazyBlockFrequencyInfoPass(); - /// \brief Compute and return the block frequencies. + /// Compute and return the block frequencies. BlockFrequencyInfo &getBFI() { return LBFI.getCalculated(); } - /// \brief Compute and return the block frequencies. + /// Compute and return the block frequencies. const BlockFrequencyInfo &getBFI() const { return LBFI.getCalculated(); } void getAnalysisUsage(AnalysisUsage &AU) const override; @@ -126,7 +126,7 @@ void print(raw_ostream &OS, const Module *M) const override; }; -/// \brief Helper for client passes to initialize dependent passes for LBFI. +/// Helper for client passes to initialize dependent passes for LBFI. void initializeLazyBFIPassPass(PassRegistry &Registry); } #endif Index: llvm/trunk/include/llvm/Analysis/LazyBranchProbabilityInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/LazyBranchProbabilityInfo.h +++ llvm/trunk/include/llvm/Analysis/LazyBranchProbabilityInfo.h @@ -26,7 +26,7 @@ class LoopInfo; class TargetLibraryInfo; -/// \brief This is an alternative analysis pass to +/// This is an alternative analysis pass to /// BranchProbabilityInfoWrapperPass. The difference is that with this pass the /// branch probabilities are not computed when the analysis pass is executed but /// rather when the BPI results is explicitly requested by the analysis client. @@ -89,10 +89,10 @@ LazyBranchProbabilityInfoPass(); - /// \brief Compute and return the branch probabilities. + /// Compute and return the branch probabilities. BranchProbabilityInfo &getBPI() { return LBPI->getCalculated(); } - /// \brief Compute and return the branch probabilities. + /// Compute and return the branch probabilities. const BranchProbabilityInfo &getBPI() const { return LBPI->getCalculated(); } void getAnalysisUsage(AnalysisUsage &AU) const override; @@ -106,10 +106,10 @@ void print(raw_ostream &OS, const Module *M) const override; }; -/// \brief Helper for client passes to initialize dependent passes for LBPI. +/// Helper for client passes to initialize dependent passes for LBPI. void initializeLazyBPIPassPass(PassRegistry &Registry); -/// \brief Simple trait class that provides a mapping between BPI passes and the +/// Simple trait class that provides a mapping between BPI passes and the /// corresponding BPInfo. template struct BPIPassTrait { static PassT &getBPI(PassT *P) { return *P; } Index: llvm/trunk/include/llvm/Analysis/LazyValueInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/LazyValueInfo.h +++ llvm/trunk/include/llvm/Analysis/LazyValueInfo.h @@ -128,7 +128,7 @@ FunctionAnalysisManager::Invalidator &Inv); }; -/// \brief Analysis to compute lazy value information. +/// Analysis to compute lazy value information. class LazyValueAnalysis : public AnalysisInfoMixin { public: typedef LazyValueInfo Result; Index: llvm/trunk/include/llvm/Analysis/LoopAccessAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/LoopAccessAnalysis.h +++ llvm/trunk/include/llvm/Analysis/LoopAccessAnalysis.h @@ -38,25 +38,25 @@ class LoopAccessInfo; class OptimizationRemarkEmitter; -/// \brief Collection of parameters shared beetween the Loop Vectorizer and the +/// Collection of parameters shared beetween the Loop Vectorizer and the /// Loop Access Analysis. struct VectorizerParams { - /// \brief Maximum SIMD width. + /// Maximum SIMD width. static const unsigned MaxVectorWidth; - /// \brief VF as overridden by the user. + /// VF as overridden by the user. static unsigned VectorizationFactor; - /// \brief Interleave factor as overridden by the user. + /// Interleave factor as overridden by the user. static unsigned VectorizationInterleave; - /// \brief True if force-vector-interleave was specified by the user. + /// True if force-vector-interleave was specified by the user. static bool isInterleaveForced(); - /// \\brief When performing memory disambiguation checks at runtime do not + /// \When performing memory disambiguation checks at runtime do not /// make more than this number of comparisons. static unsigned RuntimeMemoryCheckThreshold; }; -/// \brief Checks memory dependences among accesses to the same underlying +/// Checks memory dependences among accesses to the same underlying /// object to determine whether there vectorization is legal or not (and at /// which vectorization factor). /// @@ -94,12 +94,12 @@ public: typedef PointerIntPair MemAccessInfo; typedef SmallVector MemAccessInfoList; - /// \brief Set of potential dependent memory accesses. + /// Set of potential dependent memory accesses. typedef EquivalenceClasses DepCandidates; - /// \brief Dependece between memory access instructions. + /// Dependece between memory access instructions. struct Dependence { - /// \brief The type of the dependence. + /// The type of the dependence. enum DepType { // No dependence. NoDep, @@ -127,36 +127,36 @@ BackwardVectorizableButPreventsForwarding }; - /// \brief String version of the types. + /// String version of the types. static const char *DepName[]; - /// \brief Index of the source of the dependence in the InstMap vector. + /// Index of the source of the dependence in the InstMap vector. unsigned Source; - /// \brief Index of the destination of the dependence in the InstMap vector. + /// Index of the destination of the dependence in the InstMap vector. unsigned Destination; - /// \brief The type of the dependence. + /// The type of the dependence. DepType Type; Dependence(unsigned Source, unsigned Destination, DepType Type) : Source(Source), Destination(Destination), Type(Type) {} - /// \brief Return the source instruction of the dependence. + /// Return the source instruction of the dependence. Instruction *getSource(const LoopAccessInfo &LAI) const; - /// \brief Return the destination instruction of the dependence. + /// Return the destination instruction of the dependence. Instruction *getDestination(const LoopAccessInfo &LAI) const; - /// \brief Dependence types that don't prevent vectorization. + /// Dependence types that don't prevent vectorization. static bool isSafeForVectorization(DepType Type); - /// \brief Lexically forward dependence. + /// Lexically forward dependence. bool isForward() const; - /// \brief Lexically backward dependence. + /// Lexically backward dependence. bool isBackward() const; - /// \brief May be a lexically backward dependence type (includes Unknown). + /// May be a lexically backward dependence type (includes Unknown). bool isPossiblyBackward() const; - /// \brief Print the dependence. \p Instr is used to map the instruction + /// Print the dependence. \p Instr is used to map the instruction /// indices to instructions. void print(raw_ostream &OS, unsigned Depth, const SmallVectorImpl &Instrs) const; @@ -167,7 +167,7 @@ ShouldRetryWithRuntimeCheck(false), SafeForVectorization(true), RecordDependences(true) {} - /// \brief Register the location (instructions are given increasing numbers) + /// Register the location (instructions are given increasing numbers) /// of a write access. void addAccess(StoreInst *SI) { Value *Ptr = SI->getPointerOperand(); @@ -176,7 +176,7 @@ ++AccessIdx; } - /// \brief Register the location (instructions are given increasing numbers) + /// Register the location (instructions are given increasing numbers) /// of a write access. void addAccess(LoadInst *LI) { Value *Ptr = LI->getPointerOperand(); @@ -185,29 +185,29 @@ ++AccessIdx; } - /// \brief Check whether the dependencies between the accesses are safe. + /// Check whether the dependencies between the accesses are safe. /// /// Only checks sets with elements in \p CheckDeps. bool areDepsSafe(DepCandidates &AccessSets, MemAccessInfoList &CheckDeps, const ValueToValueMap &Strides); - /// \brief No memory dependence was encountered that would inhibit + /// No memory dependence was encountered that would inhibit /// vectorization. bool isSafeForVectorization() const { return SafeForVectorization; } - /// \brief The maximum number of bytes of a vector register we can vectorize + /// The maximum number of bytes of a vector register we can vectorize /// the accesses safely with. uint64_t getMaxSafeDepDistBytes() { return MaxSafeDepDistBytes; } - /// \brief Return the number of elements that are safe to operate on + /// Return the number of elements that are safe to operate on /// simultaneously, multiplied by the size of the element in bits. uint64_t getMaxSafeRegisterWidth() const { return MaxSafeRegisterWidth; } - /// \brief In same cases when the dependency check fails we can still + /// In same cases when the dependency check fails we can still /// vectorize the loop with a dynamic array access check. bool shouldRetryWithRuntimeCheck() { return ShouldRetryWithRuntimeCheck; } - /// \brief Returns the memory dependences. If null is returned we exceeded + /// Returns the memory dependences. If null is returned we exceeded /// the MaxDependences threshold and this information is not /// available. const SmallVectorImpl *getDependences() const { @@ -216,13 +216,13 @@ void clearDependences() { Dependences.clear(); } - /// \brief The vector of memory access instructions. The indices are used as + /// The vector of memory access instructions. The indices are used as /// instruction identifiers in the Dependence class. const SmallVectorImpl &getMemoryInstructions() const { return InstMap; } - /// \brief Generate a mapping between the memory instructions and their + /// Generate a mapping between the memory instructions and their /// indices according to program order. DenseMap generateInstructionOrderMap() const { DenseMap OrderMap; @@ -233,7 +233,7 @@ return OrderMap; } - /// \brief Find the set of instructions that read or write via \p Ptr. + /// Find the set of instructions that read or write via \p Ptr. SmallVector getInstructionsForAccess(Value *Ptr, bool isWrite) const; @@ -247,42 +247,42 @@ PredicatedScalarEvolution &PSE; const Loop *InnermostLoop; - /// \brief Maps access locations (ptr, read/write) to program order. + /// Maps access locations (ptr, read/write) to program order. DenseMap > Accesses; - /// \brief Memory access instructions in program order. + /// Memory access instructions in program order. SmallVector InstMap; - /// \brief The program order index to be used for the next instruction. + /// The program order index to be used for the next instruction. unsigned AccessIdx; // We can access this many bytes in parallel safely. uint64_t MaxSafeDepDistBytes; - /// \brief Number of elements (from consecutive iterations) that are safe to + /// Number of elements (from consecutive iterations) that are safe to /// operate on simultaneously, multiplied by the size of the element in bits. /// The size of the element is taken from the memory access that is most /// restrictive. uint64_t MaxSafeRegisterWidth; - /// \brief If we see a non-constant dependence distance we can still try to + /// If we see a non-constant dependence distance we can still try to /// vectorize this loop with runtime checks. bool ShouldRetryWithRuntimeCheck; - /// \brief No memory dependence was encountered that would inhibit + /// No memory dependence was encountered that would inhibit /// vectorization. bool SafeForVectorization; - //// \brief True if Dependences reflects the dependences in the + //// True if Dependences reflects the dependences in the //// loop. If false we exceeded MaxDependences and //// Dependences is invalid. bool RecordDependences; - /// \brief Memory dependences collected during the analysis. Only valid if + /// Memory dependences collected during the analysis. Only valid if /// RecordDependences is true. SmallVector Dependences; - /// \brief Check whether there is a plausible dependence between the two + /// Check whether there is a plausible dependence between the two /// accesses. /// /// Access \p A must happen before \p B in program order. The two indices @@ -298,7 +298,7 @@ const MemAccessInfo &B, unsigned BIdx, const ValueToValueMap &Strides); - /// \brief Check whether the data dependence could prevent store-load + /// Check whether the data dependence could prevent store-load /// forwarding. /// /// \return false if we shouldn't vectorize at all or avoid larger @@ -306,7 +306,7 @@ bool couldPreventStoreLoadForward(uint64_t Distance, uint64_t TypeByteSize); }; -/// \brief Holds information about the memory runtime legality checks to verify +/// Holds information about the memory runtime legality checks to verify /// that a group of pointers do not overlap. class RuntimePointerChecking { public: @@ -355,13 +355,13 @@ unsigned ASId, const ValueToValueMap &Strides, PredicatedScalarEvolution &PSE); - /// \brief No run-time memory checking is necessary. + /// No run-time memory checking is necessary. bool empty() const { return Pointers.empty(); } /// A grouping of pointers. A single memcheck is required between /// two groups. struct CheckingPtrGroup { - /// \brief Create a new pointer checking group containing a single + /// Create a new pointer checking group containing a single /// pointer, with index \p Index in RtCheck. CheckingPtrGroup(unsigned Index, RuntimePointerChecking &RtCheck) : RtCheck(RtCheck), High(RtCheck.Pointers[Index].End), @@ -369,7 +369,7 @@ Members.push_back(Index); } - /// \brief Tries to add the pointer recorded in RtCheck at index + /// Tries to add the pointer recorded in RtCheck at index /// \p Index to this pointer checking group. We can only add a pointer /// to a checking group if we will still be able to get /// the upper and lower bounds of the check. Returns true in case @@ -390,7 +390,7 @@ SmallVector Members; }; - /// \brief A memcheck which made up of a pair of grouped pointers. + /// A memcheck which made up of a pair of grouped pointers. /// /// These *have* to be const for now, since checks are generated from /// CheckingPtrGroups in LAI::addRuntimeChecks which is a const member @@ -399,24 +399,24 @@ typedef std::pair PointerCheck; - /// \brief Generate the checks and store it. This also performs the grouping + /// Generate the checks and store it. This also performs the grouping /// of pointers to reduce the number of memchecks necessary. void generateChecks(MemoryDepChecker::DepCandidates &DepCands, bool UseDependencies); - /// \brief Returns the checks that generateChecks created. + /// Returns the checks that generateChecks created. const SmallVector &getChecks() const { return Checks; } - /// \brief Decide if we need to add a check between two groups of pointers, + /// Decide if we need to add a check between two groups of pointers, /// according to needsChecking. bool needsChecking(const CheckingPtrGroup &M, const CheckingPtrGroup &N) const; - /// \brief Returns the number of run-time checks required according to + /// Returns the number of run-time checks required according to /// needsChecking. unsigned getNumberOfChecks() const { return Checks.size(); } - /// \brief Print the list run-time memory checks necessary. + /// Print the list run-time memory checks necessary. void print(raw_ostream &OS, unsigned Depth = 0) const; /// Print \p Checks. @@ -432,7 +432,7 @@ /// Holds a partitioning of pointers into "check groups". SmallVector CheckingGroups; - /// \brief Check if pointers are in the same partition + /// Check if pointers are in the same partition /// /// \p PtrToPartition contains the partition number for pointers (-1 if the /// pointer belongs to multiple partitions). @@ -440,17 +440,17 @@ arePointersInSamePartition(const SmallVectorImpl &PtrToPartition, unsigned PtrIdx1, unsigned PtrIdx2); - /// \brief Decide whether we need to issue a run-time check for pointer at + /// Decide whether we need to issue a run-time check for pointer at /// index \p I and \p J to prove their independence. bool needsChecking(unsigned I, unsigned J) const; - /// \brief Return PointerInfo for pointer at index \p PtrIdx. + /// Return PointerInfo for pointer at index \p PtrIdx. const PointerInfo &getPointerInfo(unsigned PtrIdx) const { return Pointers[PtrIdx]; } private: - /// \brief Groups pointers such that a single memcheck is required + /// Groups pointers such that a single memcheck is required /// between two different groups. This will clear the CheckingGroups vector /// and re-compute it. We will only group dependecies if \p UseDependencies /// is true, otherwise we will create a separate group for each pointer. @@ -464,12 +464,12 @@ /// Holds a pointer to the ScalarEvolution analysis. ScalarEvolution *SE; - /// \brief Set of run-time checks required to establish independence of + /// Set of run-time checks required to establish independence of /// otherwise may-aliasing pointers in the loop. SmallVector Checks; }; -/// \brief Drive the analysis of memory accesses in the loop +/// Drive the analysis of memory accesses in the loop /// /// This class is responsible for analyzing the memory accesses of a loop. It /// collects the accesses and then its main helper the AccessAnalysis class @@ -503,7 +503,7 @@ return PtrRtChecking.get(); } - /// \brief Number of memchecks required to prove independence of otherwise + /// Number of memchecks required to prove independence of otherwise /// may-alias pointers. unsigned getNumRuntimePointerChecks() const { return PtrRtChecking->getNumberOfChecks(); @@ -521,7 +521,7 @@ unsigned getNumStores() const { return NumStores; } unsigned getNumLoads() const { return NumLoads;} - /// \brief Add code that checks at runtime if the accessed arrays overlap. + /// Add code that checks at runtime if the accessed arrays overlap. /// /// Returns a pair of instructions where the first element is the first /// instruction generated in possibly a sequence of instructions and the @@ -529,7 +529,7 @@ std::pair addRuntimeChecks(Instruction *Loc) const; - /// \brief Generete the instructions for the checks in \p PointerChecks. + /// Generete the instructions for the checks in \p PointerChecks. /// /// Returns a pair of instructions where the first element is the first /// instruction generated in possibly a sequence of instructions and the @@ -539,32 +539,32 @@ const SmallVectorImpl &PointerChecks) const; - /// \brief The diagnostics report generated for the analysis. E.g. why we + /// The diagnostics report generated for the analysis. E.g. why we /// couldn't analyze the loop. const OptimizationRemarkAnalysis *getReport() const { return Report.get(); } - /// \brief the Memory Dependence Checker which can determine the + /// the Memory Dependence Checker which can determine the /// loop-independent and loop-carried dependences between memory accesses. const MemoryDepChecker &getDepChecker() const { return *DepChecker; } - /// \brief Return the list of instructions that use \p Ptr to read or write + /// Return the list of instructions that use \p Ptr to read or write /// memory. SmallVector getInstructionsForAccess(Value *Ptr, bool isWrite) const { return DepChecker->getInstructionsForAccess(Ptr, isWrite); } - /// \brief If an access has a symbolic strides, this maps the pointer value to + /// If an access has a symbolic strides, this maps the pointer value to /// the stride symbol. const ValueToValueMap &getSymbolicStrides() const { return SymbolicStrides; } - /// \brief Pointer has a symbolic stride. + /// Pointer has a symbolic stride. bool hasStride(Value *V) const { return StrideSet.count(V); } - /// \brief Print the information about the memory accesses in the loop. + /// Print the information about the memory accesses in the loop. void print(raw_ostream &OS, unsigned Depth = 0) const; - /// \brief Checks existence of store to invariant address inside loop. + /// Checks existence of store to invariant address inside loop. /// If the loop has any store to invariant address, then it returns true, /// else returns false. bool hasStoreToLoopInvariantAddress() const { @@ -579,15 +579,15 @@ const PredicatedScalarEvolution &getPSE() const { return *PSE; } private: - /// \brief Analyze the loop. + /// Analyze the loop. void analyzeLoop(AliasAnalysis *AA, LoopInfo *LI, const TargetLibraryInfo *TLI, DominatorTree *DT); - /// \brief Check if the structure of the loop allows it to be analyzed by this + /// Check if the structure of the loop allows it to be analyzed by this /// pass. bool canAnalyzeLoop(); - /// \brief Save the analysis remark. + /// Save the analysis remark. /// /// LAA does not directly emits the remarks. Instead it stores it which the /// client can retrieve and presents as its own analysis @@ -595,7 +595,7 @@ OptimizationRemarkAnalysis &recordAnalysis(StringRef RemarkName, Instruction *Instr = nullptr); - /// \brief Collect memory access with loop invariant strides. + /// Collect memory access with loop invariant strides. /// /// Looks for accesses like "a[i * StrideA]" where "StrideA" is loop /// invariant. @@ -607,7 +607,7 @@ /// at runtime. Using std::unique_ptr to make using move ctor simpler. std::unique_ptr PtrRtChecking; - /// \brief the Memory Dependence Checker which can determine the + /// the Memory Dependence Checker which can determine the /// loop-independent and loop-carried dependences between memory accesses. std::unique_ptr DepChecker; @@ -618,28 +618,28 @@ uint64_t MaxSafeDepDistBytes; - /// \brief Cache the result of analyzeLoop. + /// Cache the result of analyzeLoop. bool CanVecMem; - /// \brief Indicator for storing to uniform addresses. + /// Indicator for storing to uniform addresses. /// If a loop has write to a loop invariant address then it should be true. bool StoreToLoopInvariantAddress; - /// \brief The diagnostics report generated for the analysis. E.g. why we + /// The diagnostics report generated for the analysis. E.g. why we /// couldn't analyze the loop. std::unique_ptr Report; - /// \brief If an access has a symbolic strides, this maps the pointer value to + /// If an access has a symbolic strides, this maps the pointer value to /// the stride symbol. ValueToValueMap SymbolicStrides; - /// \brief Set of symbolic strides values. + /// Set of symbolic strides values. SmallPtrSet StrideSet; }; Value *stripIntegerCast(Value *V); -/// \brief Return the SCEV corresponding to a pointer with the symbolic stride +/// Return the SCEV corresponding to a pointer with the symbolic stride /// replaced with constant one, assuming the SCEV predicate associated with /// \p PSE is true. /// @@ -653,7 +653,7 @@ const ValueToValueMap &PtrToStride, Value *Ptr, Value *OrigPtr = nullptr); -/// \brief If the pointer has a constant stride return it in units of its +/// If the pointer has a constant stride return it in units of its /// element size. Otherwise return zero. /// /// Ensure that it does not wrap in the address space, assuming the predicate @@ -667,7 +667,7 @@ const ValueToValueMap &StridesMap = ValueToValueMap(), bool Assume = false, bool ShouldCheckWrap = true); -/// \brief Attempt to sort the pointers in \p VL and return the sorted indices +/// Attempt to sort the pointers in \p VL and return the sorted indices /// in \p SortedIndices, if reordering is required. /// /// Returns 'true' if sorting is legal, otherwise returns 'false'. @@ -681,12 +681,12 @@ ScalarEvolution &SE, SmallVectorImpl &SortedIndices); -/// \brief Returns true if the memory operations \p A and \p B are consecutive. +/// Returns true if the memory operations \p A and \p B are consecutive. /// This is a simple API that does not depend on the analysis pass. bool isConsecutiveAccess(Value *A, Value *B, const DataLayout &DL, ScalarEvolution &SE, bool CheckType = true); -/// \brief This analysis provides dependence information for the memory accesses +/// This analysis provides dependence information for the memory accesses /// of a loop. /// /// It runs the analysis for a loop on demand. This can be initiated by @@ -705,7 +705,7 @@ void getAnalysisUsage(AnalysisUsage &AU) const override; - /// \brief Query the result of the loop access information for the loop \p L. + /// Query the result of the loop access information for the loop \p L. /// /// If there is no cached result available run the analysis. const LoopAccessInfo &getInfo(Loop *L); @@ -715,11 +715,11 @@ LoopAccessInfoMap.clear(); } - /// \brief Print the result of the analysis when invoked with -analyze. + /// Print the result of the analysis when invoked with -analyze. void print(raw_ostream &OS, const Module *M = nullptr) const override; private: - /// \brief The cache. + /// The cache. DenseMap> LoopAccessInfoMap; // The used analysis passes. @@ -730,7 +730,7 @@ LoopInfo *LI; }; -/// \brief This analysis provides dependence information for the memory +/// This analysis provides dependence information for the memory /// accesses of a loop. /// /// It runs the analysis for a loop on demand. This can be initiated by Index: llvm/trunk/include/llvm/Analysis/LoopAnalysisManager.h =================================================================== --- llvm/trunk/include/llvm/Analysis/LoopAnalysisManager.h +++ llvm/trunk/include/llvm/Analysis/LoopAnalysisManager.h @@ -69,7 +69,7 @@ extern template class AllAnalysesOn; extern template class AnalysisManager; -/// \brief The loop analysis manager. +/// The loop analysis manager. /// /// See the documentation for the AnalysisManager template for detail /// documentation. This typedef serves as a convenient way to refer to this Index: llvm/trunk/include/llvm/Analysis/LoopInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/LoopInfo.h +++ llvm/trunk/include/llvm/Analysis/LoopInfo.h @@ -444,7 +444,7 @@ /// in the CFG are necessarily loops. class Loop : public LoopBase { public: - /// \brief A range representing the start and end location of a loop. + /// A range representing the start and end location of a loop. class LocRange { DebugLoc Start; DebugLoc End; @@ -458,7 +458,7 @@ const DebugLoc &getStart() const { return Start; } const DebugLoc &getEnd() const { return End; } - /// \brief Check for null. + /// Check for null. /// explicit operator bool() const { return Start && End; } }; @@ -935,7 +935,7 @@ static ChildIteratorType child_end(NodeRef N) { return N->end(); } }; -/// \brief Analysis pass that exposes the \c LoopInfo for a function. +/// Analysis pass that exposes the \c LoopInfo for a function. class LoopAnalysis : public AnalysisInfoMixin { friend AnalysisInfoMixin; static AnalysisKey Key; @@ -946,7 +946,7 @@ LoopInfo run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Printer pass for the \c LoopAnalysis results. +/// Printer pass for the \c LoopAnalysis results. class LoopPrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -955,12 +955,12 @@ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Verifier pass for the \c LoopAnalysis results. +/// Verifier pass for the \c LoopAnalysis results. struct LoopVerifierPass : public PassInfoMixin { PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief The legacy pass manager's analysis pass to compute loop information. +/// The legacy pass manager's analysis pass to compute loop information. class LoopInfoWrapperPass : public FunctionPass { LoopInfo LI; @@ -974,7 +974,7 @@ LoopInfo &getLoopInfo() { return LI; } const LoopInfo &getLoopInfo() const { return LI; } - /// \brief Calculate the natural loop information for a given function. + /// Calculate the natural loop information for a given function. bool runOnFunction(Function &F) override; void verifyAnalysis() const override; Index: llvm/trunk/include/llvm/Analysis/LoopUnrollAnalyzer.h =================================================================== --- llvm/trunk/include/llvm/Analysis/LoopUnrollAnalyzer.h +++ llvm/trunk/include/llvm/Analysis/LoopUnrollAnalyzer.h @@ -57,7 +57,7 @@ using Base::visit; private: - /// \brief A cache of pointer bases and constant-folded offsets corresponding + /// A cache of pointer bases and constant-folded offsets corresponding /// to GEP (or derived from GEP) instructions. /// /// In order to find the base pointer one needs to perform non-trivial @@ -65,11 +65,11 @@ /// results saved. DenseMap SimplifiedAddresses; - /// \brief SCEV expression corresponding to number of currently simulated + /// SCEV expression corresponding to number of currently simulated /// iteration. const SCEV *IterationNumber; - /// \brief A Value->Constant map for keeping values that we managed to + /// A Value->Constant map for keeping values that we managed to /// constant-fold on the given iteration. /// /// While we walk the loop instructions, we build up and maintain a mapping Index: llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h =================================================================== --- llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h +++ llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h @@ -53,33 +53,33 @@ class UndefValue; class Value; -/// \brief Tests if a value is a call or invoke to a library function that +/// Tests if a value is a call or invoke to a library function that /// allocates or reallocates memory (either malloc, calloc, realloc, or strdup /// like). bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast = false); -/// \brief Tests if a value is a call or invoke to a function that returns a +/// Tests if a value is a call or invoke to a function that returns a /// NoAlias pointer (including malloc/calloc/realloc/strdup-like functions). bool isNoAliasFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast = false); -/// \brief Tests if a value is a call or invoke to a library function that +/// Tests if a value is a call or invoke to a library function that /// allocates uninitialized memory (such as malloc). bool isMallocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast = false); -/// \brief Tests if a value is a call or invoke to a library function that +/// Tests if a value is a call or invoke to a library function that /// allocates zero-filled memory (such as calloc). bool isCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast = false); -/// \brief Tests if a value is a call or invoke to a library function that +/// Tests if a value is a call or invoke to a library function that /// allocates memory similar to malloc or calloc. bool isMallocOrCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast = false); -/// \brief Tests if a value is a call or invoke to a library function that +/// Tests if a value is a call or invoke to a library function that /// allocates memory (either malloc, calloc, or strdup like). bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast = false); @@ -170,7 +170,7 @@ bool NullIsUnknownSize = false; }; -/// \brief Compute the size of the object pointed by Ptr. Returns true and the +/// Compute the size of the object pointed by Ptr. Returns true and the /// object size in Size if successful, and false otherwise. In this context, by /// object we mean the region of memory starting at Ptr to the end of the /// underlying object pointed to by Ptr. @@ -189,7 +189,7 @@ using SizeOffsetType = std::pair; -/// \brief Evaluate the size and offset of an object pointed to by a Value* +/// Evaluate the size and offset of an object pointed to by a Value* /// statically. Fails if size or offset are not known at compile time. class ObjectSizeOffsetVisitor : public InstVisitor { @@ -248,7 +248,7 @@ using SizeOffsetEvalType = std::pair; -/// \brief Evaluate the size and offset of an object pointed to by a Value*. +/// Evaluate the size and offset of an object pointed to by a Value*. /// May create code to compute the result at run-time. class ObjectSizeOffsetEvaluator : public InstVisitor { Index: llvm/trunk/include/llvm/Analysis/MemorySSA.h =================================================================== --- llvm/trunk/include/llvm/Analysis/MemorySSA.h +++ llvm/trunk/include/llvm/Analysis/MemorySSA.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// // /// \file -/// \brief This file exposes an interface to building/using memory SSA to +/// This file exposes an interface to building/using memory SSA to /// walk memory instructions using a use/def graph. /// /// Memory SSA class builds an SSA form that links together memory access @@ -130,7 +130,7 @@ using const_memoryaccess_def_iterator = memoryaccess_def_iterator_base; -// \brief The base for all memory accesses. All memory accesses in a block are +// The base for all memory accesses. All memory accesses in a block are // linked together using an intrusive list. class MemoryAccess : public DerivedUser, @@ -159,11 +159,11 @@ void print(raw_ostream &OS) const; void dump() const; - /// \brief The user iterators for a memory access + /// The user iterators for a memory access using iterator = user_iterator; using const_iterator = const_user_iterator; - /// \brief This iterator walks over all of the defs in a given + /// This iterator walks over all of the defs in a given /// MemoryAccess. For MemoryPhi nodes, this walks arguments. For /// MemoryUse/MemoryDef, this walks the defining access. memoryaccess_def_iterator defs_begin(); @@ -171,7 +171,7 @@ memoryaccess_def_iterator defs_end(); const_memoryaccess_def_iterator defs_end() const; - /// \brief Get the iterators for the all access list and the defs only list + /// Get the iterators for the all access list and the defs only list /// We default to the all access list. AllAccessType::self_iterator getIterator() { return this->AllAccessType::getIterator(); @@ -205,11 +205,11 @@ friend class MemoryUse; friend class MemoryUseOrDef; - /// \brief Used by MemorySSA to change the block of a MemoryAccess when it is + /// Used by MemorySSA to change the block of a MemoryAccess when it is /// moved. void setBlock(BasicBlock *BB) { Block = BB; } - /// \brief Used for debugging and tracking things about MemoryAccesses. + /// Used for debugging and tracking things about MemoryAccesses. /// Guaranteed unique among MemoryAccesses, no guarantees otherwise. inline unsigned getID() const; @@ -235,7 +235,7 @@ return OS; } -/// \brief Class that has the common methods + fields of memory uses/defs. It's +/// Class that has the common methods + fields of memory uses/defs. It's /// a little awkward to have, but there are many cases where we want either a /// use or def, and there are many cases where uses are needed (defs aren't /// acceptable), and vice-versa. @@ -248,10 +248,10 @@ DECLARE_TRANSPARENT_OPERAND_ACCESSORS(MemoryAccess); - /// \brief Get the instruction that this MemoryUse represents. + /// Get the instruction that this MemoryUse represents. Instruction *getMemoryInst() const { return MemoryInstruction; } - /// \brief Get the access that produces the memory state used by this Use. + /// Get the access that produces the memory state used by this Use. MemoryAccess *getDefiningAccess() const { return getOperand(0); } static bool classof(const Value *MA) { @@ -270,7 +270,7 @@ return OptimizedAccessAlias; } - /// \brief Reset the ID of what this MemoryUse was optimized to, causing it to + /// Reset the ID of what this MemoryUse was optimized to, causing it to /// be rewalked by the walker if necessary. /// This really should only be called by tests. inline void resetOptimized(); @@ -313,7 +313,7 @@ : public FixedNumOperandTraits {}; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(MemoryUseOrDef, MemoryAccess) -/// \brief Represents read-only accesses to memory +/// Represents read-only accesses to memory /// /// In particular, the set of Instructions that will be represented by /// MemoryUse's is exactly the set of Instructions for which @@ -364,7 +364,7 @@ struct OperandTraits : public FixedNumOperandTraits {}; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(MemoryUse, MemoryAccess) -/// \brief Represents a read-write access to memory, whether it is a must-alias, +/// Represents a read-write access to memory, whether it is a must-alias, /// or a may-alias. /// /// In particular, the set of Instructions that will be represented by @@ -424,7 +424,7 @@ struct OperandTraits : public FixedNumOperandTraits {}; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(MemoryDef, MemoryAccess) -/// \brief Represents phi nodes for memory accesses. +/// Represents phi nodes for memory accesses. /// /// These have the same semantic as regular phi nodes, with the exception that /// only one phi will ever exist in a given basic block. @@ -504,10 +504,10 @@ const_op_range incoming_values() const { return operands(); } - /// \brief Return the number of incoming edges + /// Return the number of incoming edges unsigned getNumIncomingValues() const { return getNumOperands(); } - /// \brief Return incoming value number x + /// Return incoming value number x MemoryAccess *getIncomingValue(unsigned I) const { return getOperand(I); } void setIncomingValue(unsigned I, MemoryAccess *V) { assert(V && "PHI node got a null value!"); @@ -517,17 +517,17 @@ static unsigned getOperandNumForIncomingValue(unsigned I) { return I; } static unsigned getIncomingValueNumForOperand(unsigned I) { return I; } - /// \brief Return incoming basic block number @p i. + /// Return incoming basic block number @p i. BasicBlock *getIncomingBlock(unsigned I) const { return block_begin()[I]; } - /// \brief Return incoming basic block corresponding + /// Return incoming basic block corresponding /// to an operand of the PHI. BasicBlock *getIncomingBlock(const Use &U) const { assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?"); return getIncomingBlock(unsigned(&U - op_begin())); } - /// \brief Return incoming basic block corresponding + /// Return incoming basic block corresponding /// to value use iterator. BasicBlock *getIncomingBlock(MemoryAccess::const_user_iterator I) const { return getIncomingBlock(I.getUse()); @@ -538,7 +538,7 @@ block_begin()[I] = BB; } - /// \brief Add an incoming value to the end of the PHI list + /// Add an incoming value to the end of the PHI list void addIncoming(MemoryAccess *V, BasicBlock *BB) { if (getNumOperands() == ReservedSpace) growOperands(); // Get more space! @@ -548,7 +548,7 @@ setIncomingBlock(getNumOperands() - 1, BB); } - /// \brief Return the first index of the specified basic + /// Return the first index of the specified basic /// block in the value list for this PHI. Returns -1 if no instance. int getBasicBlockIndex(const BasicBlock *BB) const { for (unsigned I = 0, E = getNumOperands(); I != E; ++I) @@ -574,7 +574,7 @@ protected: friend class MemorySSA; - /// \brief this is more complicated than the generic + /// this is more complicated than the generic /// User::allocHungoffUses, because we have to allocate Uses for the incoming /// values and pointers to the incoming blocks, all in one allocation. void allocHungoffUses(unsigned N) { @@ -586,7 +586,7 @@ const unsigned ID; unsigned ReservedSpace; - /// \brief This grows the operand list in response to a push_back style of + /// This grows the operand list in response to a push_back style of /// operation. This grows the number of ops by 1.5 times. void growOperands() { unsigned E = getNumOperands(); @@ -635,7 +635,7 @@ template <> struct OperandTraits : public HungoffOperandTraits<2> {}; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(MemoryPhi, MemoryAccess) -/// \brief Encapsulates MemorySSA, including all data associated with memory +/// Encapsulates MemorySSA, including all data associated with memory /// accesses. class MemorySSA { public: @@ -644,7 +644,7 @@ MemorySSAWalker *getWalker(); - /// \brief Given a memory Mod/Ref'ing instruction, get the MemorySSA + /// Given a memory Mod/Ref'ing instruction, get the MemorySSA /// access associated with it. If passed a basic block gets the memory phi /// node that exists for that block, if there is one. Otherwise, this will get /// a MemoryUseOrDef. @@ -654,7 +654,7 @@ void dump() const; void print(raw_ostream &) const; - /// \brief Return true if \p MA represents the live on entry value + /// Return true if \p MA represents the live on entry value /// /// Loads and stores from pointer arguments and other global values may be /// defined by memory operations that do not occur in the current function, so @@ -678,14 +678,14 @@ using DefsList = simple_ilist>; - /// \brief Return the list of MemoryAccess's for a given basic block. + /// Return the list of MemoryAccess's for a given basic block. /// /// This list is not modifiable by the user. const AccessList *getBlockAccesses(const BasicBlock *BB) const { return getWritableBlockAccesses(BB); } - /// \brief Return the list of MemoryDef's and MemoryPhi's for a given basic + /// Return the list of MemoryDef's and MemoryPhi's for a given basic /// block. /// /// This list is not modifiable by the user. @@ -693,19 +693,19 @@ return getWritableBlockDefs(BB); } - /// \brief Given two memory accesses in the same basic block, determine + /// Given two memory accesses in the same basic block, determine /// whether MemoryAccess \p A dominates MemoryAccess \p B. bool locallyDominates(const MemoryAccess *A, const MemoryAccess *B) const; - /// \brief Given two memory accesses in potentially different blocks, + /// Given two memory accesses in potentially different blocks, /// determine whether MemoryAccess \p A dominates MemoryAccess \p B. bool dominates(const MemoryAccess *A, const MemoryAccess *B) const; - /// \brief Given a MemoryAccess and a Use, determine whether MemoryAccess \p A + /// Given a MemoryAccess and a Use, determine whether MemoryAccess \p A /// dominates Use \p B. bool dominates(const MemoryAccess *A, const Use &B) const; - /// \brief Verify that MemorySSA is self consistent (IE definitions dominate + /// Verify that MemorySSA is self consistent (IE definitions dominate /// all uses, uses appear in the right places). This is used by unit tests. void verifyMemorySSA() const; @@ -859,7 +859,7 @@ Result run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Printer pass for \c MemorySSA. +/// Printer pass for \c MemorySSA. class MemorySSAPrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -869,12 +869,12 @@ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Verifier pass for \c MemorySSA. +/// Verifier pass for \c MemorySSA. struct MemorySSAVerifierPass : PassInfoMixin { PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Legacy analysis pass which computes \c MemorySSA. +/// Legacy analysis pass which computes \c MemorySSA. class MemorySSAWrapperPass : public FunctionPass { public: MemorySSAWrapperPass(); @@ -895,7 +895,7 @@ std::unique_ptr MSSA; }; -/// \brief This is the generic walker interface for walkers of MemorySSA. +/// This is the generic walker interface for walkers of MemorySSA. /// Walkers are used to be able to further disambiguate the def-use chains /// MemorySSA gives you, or otherwise produce better info than MemorySSA gives /// you. @@ -913,7 +913,7 @@ using MemoryAccessSet = SmallVector; - /// \brief Given a memory Mod/Ref/ModRef'ing instruction, calling this + /// Given a memory Mod/Ref/ModRef'ing instruction, calling this /// will give you the nearest dominating MemoryAccess that Mod's the location /// the instruction accesses (by skipping any def which AA can prove does not /// alias the location(s) accessed by the instruction given). @@ -945,7 +945,7 @@ /// but takes a MemoryAccess instead of an Instruction. virtual MemoryAccess *getClobberingMemoryAccess(MemoryAccess *) = 0; - /// \brief Given a potentially clobbering memory access and a new location, + /// Given a potentially clobbering memory access and a new location, /// calling this will give you the nearest dominating clobbering MemoryAccess /// (by skipping non-aliasing def links). /// @@ -959,7 +959,7 @@ virtual MemoryAccess *getClobberingMemoryAccess(MemoryAccess *, const MemoryLocation &) = 0; - /// \brief Given a memory access, invalidate anything this walker knows about + /// Given a memory access, invalidate anything this walker knows about /// that access. /// This API is used by walkers that store information to perform basic cache /// invalidation. This will be called by MemorySSA at appropriate times for @@ -974,7 +974,7 @@ MemorySSA *MSSA; }; -/// \brief A MemorySSAWalker that does no alias queries, or anything else. It +/// A MemorySSAWalker that does no alias queries, or anything else. It /// simply returns the links as they were constructed by the builder. class DoNothingMemorySSAWalker final : public MemorySSAWalker { public: @@ -990,7 +990,7 @@ using MemoryAccessPair = std::pair; using ConstMemoryAccessPair = std::pair; -/// \brief Iterator base class used to implement const and non-const iterators +/// Iterator base class used to implement const and non-const iterators /// over the defining accesses of a MemoryAccess. template class memoryaccess_def_iterator_base @@ -1063,7 +1063,7 @@ return const_memoryaccess_def_iterator(); } -/// \brief GraphTraits for a MemoryAccess, which walks defs in the normal case, +/// GraphTraits for a MemoryAccess, which walks defs in the normal case, /// and uses in the inverse case. template <> struct GraphTraits { using NodeRef = MemoryAccess *; @@ -1083,7 +1083,7 @@ static ChildIteratorType child_end(NodeRef N) { return N->user_end(); } }; -/// \brief Provide an iterator that walks defs, giving both the memory access, +/// Provide an iterator that walks defs, giving both the memory access, /// and the current pointer location, updating the pointer location as it /// changes due to phi node translation. /// Index: llvm/trunk/include/llvm/Analysis/MemorySSAUpdater.h =================================================================== --- llvm/trunk/include/llvm/Analysis/MemorySSAUpdater.h +++ llvm/trunk/include/llvm/Analysis/MemorySSAUpdater.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// // // \file -// \brief An automatic updater for MemorySSA that handles arbitrary insertion, +// An automatic updater for MemorySSA that handles arbitrary insertion, // deletion, and moves. It performs phi insertion where necessary, and // automatically updates the MemorySSA IR to be correct. // While updating loads or removing instructions is often easy enough to not @@ -96,7 +96,7 @@ // the edge cases right, and the above calls already operate in near-optimal // time bounds. - /// \brief Create a MemoryAccess in MemorySSA at a specified point in a block, + /// Create a MemoryAccess in MemorySSA at a specified point in a block, /// with a specified clobbering definition. /// /// Returns the new MemoryAccess. @@ -113,7 +113,7 @@ const BasicBlock *BB, MemorySSA::InsertionPlace Point); - /// \brief Create a MemoryAccess in MemorySSA before or after an existing + /// Create a MemoryAccess in MemorySSA before or after an existing /// MemoryAccess. /// /// Returns the new MemoryAccess. @@ -130,7 +130,7 @@ MemoryAccess *Definition, MemoryAccess *InsertPt); - /// \brief Remove a MemoryAccess from MemorySSA, including updating all + /// Remove a MemoryAccess from MemorySSA, including updating all /// definitions and uses. /// This should be called when a memory instruction that has a MemoryAccess /// associated with it is erased from the program. For example, if a store or Index: llvm/trunk/include/llvm/Analysis/MustExecute.h =================================================================== --- llvm/trunk/include/llvm/Analysis/MustExecute.h +++ llvm/trunk/include/llvm/Analysis/MustExecute.h @@ -30,7 +30,7 @@ class DominatorTree; class Loop; -/// \brief Captures loop safety information. +/// Captures loop safety information. /// It keep information for loop & its header may throw exception or otherwise /// exit abnormaly on any iteration of the loop which might actually execute /// at runtime. The primary way to consume this infromation is via @@ -46,7 +46,7 @@ LoopSafetyInfo() = default; }; -/// \brief Computes safety information for a loop checks loop body & header for +/// Computes safety information for a loop checks loop body & header for /// the possibility of may throw exception, it takes LoopSafetyInfo and loop as /// argument. Updates safety information in LoopSafetyInfo argument. /// Note: This is defined to clear and reinitialize an already initialized Index: llvm/trunk/include/llvm/Analysis/ObjCARCAliasAnalysis.h =================================================================== --- llvm/trunk/include/llvm/Analysis/ObjCARCAliasAnalysis.h +++ llvm/trunk/include/llvm/Analysis/ObjCARCAliasAnalysis.h @@ -29,7 +29,7 @@ namespace llvm { namespace objcarc { -/// \brief This is a simple alias analysis implementation that uses knowledge +/// This is a simple alias analysis implementation that uses knowledge /// of ARC constructs to answer queries. /// /// TODO: This class could be generalized to know about other ObjC-specific Index: llvm/trunk/include/llvm/Analysis/ObjCARCAnalysisUtils.h =================================================================== --- llvm/trunk/include/llvm/Analysis/ObjCARCAnalysisUtils.h +++ llvm/trunk/include/llvm/Analysis/ObjCARCAnalysisUtils.h @@ -43,10 +43,10 @@ namespace llvm { namespace objcarc { -/// \brief A handy option to enable/disable all ARC Optimizations. +/// A handy option to enable/disable all ARC Optimizations. extern bool EnableARCOpts; -/// \brief Test if the given module looks interesting to run ARC optimization +/// Test if the given module looks interesting to run ARC optimization /// on. inline bool ModuleHasARC(const Module &M) { return @@ -71,7 +71,7 @@ M.getNamedValue("clang.arc.use"); } -/// \brief This is a wrapper around getUnderlyingObject which also knows how to +/// This is a wrapper around getUnderlyingObject which also knows how to /// look through objc_retain and objc_autorelease calls, which we know to return /// their argument verbatim. inline const Value *GetUnderlyingObjCPtr(const Value *V, @@ -129,7 +129,7 @@ return const_cast(GetRCIdentityRoot((const Value *)V)); } -/// \brief Assuming the given instruction is one of the special calls such as +/// Assuming the given instruction is one of the special calls such as /// objc_retain or objc_release, return the RCIdentity root of the argument of /// the call. inline Value *GetArgRCIdentityRoot(Value *Inst) { @@ -146,7 +146,7 @@ cast(I)->hasAllZeroIndices()); } -/// \brief Test whether the given value is possible a retainable object pointer. +/// Test whether the given value is possible a retainable object pointer. inline bool IsPotentialRetainableObjPtr(const Value *Op) { // Pointers to static or stack storage are not valid retainable object // pointers. @@ -191,7 +191,7 @@ return true; } -/// \brief Helper for GetARCInstKind. Determines what kind of construct CS +/// Helper for GetARCInstKind. Determines what kind of construct CS /// is. inline ARCInstKind GetCallSiteClass(ImmutableCallSite CS) { for (ImmutableCallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); @@ -202,7 +202,7 @@ return CS.onlyReadsMemory() ? ARCInstKind::None : ARCInstKind::Call; } -/// \brief Return true if this value refers to a distinct and identifiable +/// Return true if this value refers to a distinct and identifiable /// object. /// /// This is similar to AliasAnalysis's isIdentifiedObject, except that it uses Index: llvm/trunk/include/llvm/Analysis/ObjCARCInstKind.h =================================================================== --- llvm/trunk/include/llvm/Analysis/ObjCARCInstKind.h +++ llvm/trunk/include/llvm/Analysis/ObjCARCInstKind.h @@ -18,7 +18,7 @@ /// \enum ARCInstKind /// -/// \brief Equivalence classes of instructions in the ARC Model. +/// Equivalence classes of instructions in the ARC Model. /// /// Since we do not have "instructions" to represent ARC concepts in LLVM IR, /// we instead operate on equivalence classes of instructions. @@ -57,32 +57,32 @@ raw_ostream &operator<<(raw_ostream &OS, const ARCInstKind Class); -/// \brief Test if the given class is a kind of user. +/// Test if the given class is a kind of user. bool IsUser(ARCInstKind Class); -/// \brief Test if the given class is objc_retain or equivalent. +/// Test if the given class is objc_retain or equivalent. bool IsRetain(ARCInstKind Class); -/// \brief Test if the given class is objc_autorelease or equivalent. +/// Test if the given class is objc_autorelease or equivalent. bool IsAutorelease(ARCInstKind Class); -/// \brief Test if the given class represents instructions which return their +/// Test if the given class represents instructions which return their /// argument verbatim. bool IsForwarding(ARCInstKind Class); -/// \brief Test if the given class represents instructions which do nothing if +/// Test if the given class represents instructions which do nothing if /// passed a null pointer. bool IsNoopOnNull(ARCInstKind Class); -/// \brief Test if the given class represents instructions which are always safe +/// Test if the given class represents instructions which are always safe /// to mark with the "tail" keyword. bool IsAlwaysTail(ARCInstKind Class); -/// \brief Test if the given class represents instructions which are never safe +/// Test if the given class represents instructions which are never safe /// to mark with the "tail" keyword. bool IsNeverTail(ARCInstKind Class); -/// \brief Test if the given class represents instructions which are always safe +/// Test if the given class represents instructions which are always safe /// to mark with the nounwind attribute. bool IsNoThrow(ARCInstKind Class); @@ -90,11 +90,11 @@ /// autoreleasepool pop. bool CanInterruptRV(ARCInstKind Class); -/// \brief Determine if F is one of the special known Functions. If it isn't, +/// Determine if F is one of the special known Functions. If it isn't, /// return ARCInstKind::CallOrUser. ARCInstKind GetFunctionClass(const Function *F); -/// \brief Determine which objc runtime call instruction class V belongs to. +/// Determine which objc runtime call instruction class V belongs to. /// /// This is similar to GetARCInstKind except that it only detects objc /// runtime calls. This allows it to be faster. Index: llvm/trunk/include/llvm/Analysis/OptimizationRemarkEmitter.h =================================================================== --- llvm/trunk/include/llvm/Analysis/OptimizationRemarkEmitter.h +++ llvm/trunk/include/llvm/Analysis/OptimizationRemarkEmitter.h @@ -40,7 +40,7 @@ OptimizationRemarkEmitter(const Function *F, BlockFrequencyInfo *BFI) : F(F), BFI(BFI) {} - /// \brief This variant can be used to generate ORE on demand (without the + /// This variant can be used to generate ORE on demand (without the /// analysis pass). /// /// Note that this ctor has a very different cost depending on whether @@ -66,11 +66,11 @@ bool invalidate(Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &Inv); - /// \brief Output the remark via the diagnostic handler and to the + /// Output the remark via the diagnostic handler and to the /// optimization record file. void emit(DiagnosticInfoOptimizationBase &OptDiag); - /// \brief Take a lambda that returns a remark which will be emitted. Second + /// Take a lambda that returns a remark which will be emitted. Second /// argument is only used to restrict this to functions. template void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) { @@ -85,7 +85,7 @@ } } - /// \brief Whether we allow for extra compile-time budget to perform more + /// Whether we allow for extra compile-time budget to perform more /// analysis to produce fewer false positives. /// /// This is useful when reporting missed optimizations. In this case we can @@ -112,7 +112,7 @@ /// Similar but use value from \p OptDiag and update hotness there. void computeHotness(DiagnosticInfoIROptimization &OptDiag); - /// \brief Only allow verbose messages if we know we're filtering by hotness + /// Only allow verbose messages if we know we're filtering by hotness /// (BFI is only set in this case). bool shouldEmitVerbose() { return BFI != nullptr; } @@ -120,7 +120,7 @@ void operator=(const OptimizationRemarkEmitter &) = delete; }; -/// \brief Add a small namespace to avoid name clashes with the classes used in +/// Add a small namespace to avoid name clashes with the classes used in /// the streaming interface. We want these to be short for better /// write/readability. namespace ore { @@ -158,10 +158,10 @@ static AnalysisKey Key; public: - /// \brief Provide the result typedef for this analysis pass. + /// Provide the result typedef for this analysis pass. typedef OptimizationRemarkEmitter Result; - /// \brief Run the analysis pass over a function and produce BFI. + /// Run the analysis pass over a function and produce BFI. Result run(Function &F, FunctionAnalysisManager &AM); }; } Index: llvm/trunk/include/llvm/Analysis/OrderedBasicBlock.h =================================================================== --- llvm/trunk/include/llvm/Analysis/OrderedBasicBlock.h +++ llvm/trunk/include/llvm/Analysis/OrderedBasicBlock.h @@ -33,28 +33,28 @@ class OrderedBasicBlock { private: - /// \brief Map a instruction to its position in a BasicBlock. + /// Map a instruction to its position in a BasicBlock. SmallDenseMap NumberedInsts; - /// \brief Keep track of last instruction inserted into \p NumberedInsts. + /// Keep track of last instruction inserted into \p NumberedInsts. /// It speeds up queries for uncached instructions by providing a start point /// for new queries in OrderedBasicBlock::comesBefore. BasicBlock::const_iterator LastInstFound; - /// \brief The position/number to tag the next instruction to be found. + /// The position/number to tag the next instruction to be found. unsigned NextInstPos; - /// \brief The source BasicBlock to map. + /// The source BasicBlock to map. const BasicBlock *BB; - /// \brief Given no cached results, find if \p A comes before \p B in \p BB. + /// Given no cached results, find if \p A comes before \p B in \p BB. /// Cache and number out instruction while walking \p BB. bool comesBefore(const Instruction *A, const Instruction *B); public: OrderedBasicBlock(const BasicBlock *BasicB); - /// \brief Find out whether \p A dominates \p B, meaning whether \p A + /// Find out whether \p A dominates \p B, meaning whether \p A /// comes before \p B in \p BB. This is a simplification that considers /// cached instruction positions and ignores other basic blocks, being /// only relevant to compare relative instructions positions inside \p BB. Index: llvm/trunk/include/llvm/Analysis/PostDominators.h =================================================================== --- llvm/trunk/include/llvm/Analysis/PostDominators.h +++ llvm/trunk/include/llvm/Analysis/PostDominators.h @@ -35,7 +35,7 @@ FunctionAnalysisManager::Invalidator &); }; -/// \brief Analysis pass which computes a \c PostDominatorTree. +/// Analysis pass which computes a \c PostDominatorTree. class PostDominatorTreeAnalysis : public AnalysisInfoMixin { friend AnalysisInfoMixin; @@ -43,15 +43,15 @@ static AnalysisKey Key; public: - /// \brief Provide the result type for this analysis pass. + /// Provide the result type for this analysis pass. using Result = PostDominatorTree; - /// \brief Run the analysis pass over a function and produce a post dominator + /// Run the analysis pass over a function and produce a post dominator /// tree. PostDominatorTree run(Function &F, FunctionAnalysisManager &); }; -/// \brief Printer pass for the \c PostDominatorTree. +/// Printer pass for the \c PostDominatorTree. class PostDominatorTreePrinterPass : public PassInfoMixin { raw_ostream &OS; Index: llvm/trunk/include/llvm/Analysis/ProfileSummaryInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/ProfileSummaryInfo.h +++ llvm/trunk/include/llvm/Analysis/ProfileSummaryInfo.h @@ -31,7 +31,7 @@ class BlockFrequencyInfo; class CallSite; class ProfileSummary; -/// \brief Analysis providing profile information. +/// Analysis providing profile information. /// /// This is an immutable analysis pass that provides ability to query global /// (program-level) profile information. The main APIs are isHotCount and @@ -59,16 +59,16 @@ ProfileSummaryInfo(ProfileSummaryInfo &&Arg) : M(Arg.M), Summary(std::move(Arg.Summary)) {} - /// \brief Returns true if profile summary is available. + /// Returns true if profile summary is available. bool hasProfileSummary() { return computeSummary(); } - /// \brief Returns true if module \c M has sample profile. + /// Returns true if module \c M has sample profile. bool hasSampleProfile() { return hasProfileSummary() && Summary->getKind() == ProfileSummary::PSK_Sample; } - /// \brief Returns true if module \c M has instrumentation profile. + /// Returns true if module \c M has instrumentation profile. bool hasInstrumentationProfile() { return hasProfileSummary() && Summary->getKind() == ProfileSummary::PSK_Instr; @@ -90,31 +90,31 @@ BlockFrequencyInfo *BFI); /// Returns true if the working set size of the code is considered huge. bool hasHugeWorkingSetSize(); - /// \brief Returns true if \p F has hot function entry. + /// Returns true if \p F has hot function entry. bool isFunctionEntryHot(const Function *F); /// Returns true if \p F contains hot code. bool isFunctionHotInCallGraph(const Function *F, BlockFrequencyInfo &BFI); - /// \brief Returns true if \p F has cold function entry. + /// Returns true if \p F has cold function entry. bool isFunctionEntryCold(const Function *F); /// Returns true if \p F contains only cold code. bool isFunctionColdInCallGraph(const Function *F, BlockFrequencyInfo &BFI); - /// \brief Returns true if \p F is a hot function. + /// Returns true if \p F is a hot function. bool isHotCount(uint64_t C); - /// \brief Returns true if count \p C is considered cold. + /// Returns true if count \p C is considered cold. bool isColdCount(uint64_t C); - /// \brief Returns true if BasicBlock \p B is considered hot. + /// Returns true if BasicBlock \p B is considered hot. bool isHotBB(const BasicBlock *B, BlockFrequencyInfo *BFI); - /// \brief Returns true if BasicBlock \p B is considered cold. + /// Returns true if BasicBlock \p B is considered cold. bool isColdBB(const BasicBlock *B, BlockFrequencyInfo *BFI); - /// \brief Returns true if CallSite \p CS is considered hot. + /// Returns true if CallSite \p CS is considered hot. bool isHotCallSite(const CallSite &CS, BlockFrequencyInfo *BFI); - /// \brief Returns true if Callsite \p CS is considered cold. + /// Returns true if Callsite \p CS is considered cold. bool isColdCallSite(const CallSite &CS, BlockFrequencyInfo *BFI); - /// \brief Returns HotCountThreshold if set. + /// Returns HotCountThreshold if set. uint64_t getHotCountThreshold() { return HotCountThreshold ? HotCountThreshold.getValue() : 0; } - /// \brief Returns ColdCountThreshold if set. + /// Returns ColdCountThreshold if set. uint64_t getColdCountThreshold() { return ColdCountThreshold ? ColdCountThreshold.getValue() : 0; } @@ -152,7 +152,7 @@ static AnalysisKey Key; }; -/// \brief Printer pass that uses \c ProfileSummaryAnalysis. +/// Printer pass that uses \c ProfileSummaryAnalysis. class ProfileSummaryPrinterPass : public PassInfoMixin { raw_ostream &OS; Index: llvm/trunk/include/llvm/Analysis/PtrUseVisitor.h =================================================================== --- llvm/trunk/include/llvm/Analysis/PtrUseVisitor.h +++ llvm/trunk/include/llvm/Analysis/PtrUseVisitor.h @@ -47,7 +47,7 @@ namespace detail { -/// \brief Implementation of non-dependent functionality for \c PtrUseVisitor. +/// Implementation of non-dependent functionality for \c PtrUseVisitor. /// /// See \c PtrUseVisitor for the public interface and detailed comments about /// usage. This class is just a helper base class which is not templated and @@ -55,7 +55,7 @@ /// PtrUseVisitor. class PtrUseVisitorBase { public: - /// \brief This class provides information about the result of a visit. + /// This class provides information about the result of a visit. /// /// After walking all the users (recursively) of a pointer, the basic /// infrastructure records some commonly useful information such as escape @@ -64,7 +64,7 @@ public: PtrInfo() : AbortedInfo(nullptr, false), EscapedInfo(nullptr, false) {} - /// \brief Reset the pointer info, clearing all state. + /// Reset the pointer info, clearing all state. void reset() { AbortedInfo.setPointer(nullptr); AbortedInfo.setInt(false); @@ -72,37 +72,37 @@ EscapedInfo.setInt(false); } - /// \brief Did we abort the visit early? + /// Did we abort the visit early? bool isAborted() const { return AbortedInfo.getInt(); } - /// \brief Is the pointer escaped at some point? + /// Is the pointer escaped at some point? bool isEscaped() const { return EscapedInfo.getInt(); } - /// \brief Get the instruction causing the visit to abort. + /// Get the instruction causing the visit to abort. /// \returns a pointer to the instruction causing the abort if one is /// available; otherwise returns null. Instruction *getAbortingInst() const { return AbortedInfo.getPointer(); } - /// \brief Get the instruction causing the pointer to escape. + /// Get the instruction causing the pointer to escape. /// \returns a pointer to the instruction which escapes the pointer if one /// is available; otherwise returns null. Instruction *getEscapingInst() const { return EscapedInfo.getPointer(); } - /// \brief Mark the visit as aborted. Intended for use in a void return. + /// Mark the visit as aborted. Intended for use in a void return. /// \param I The instruction which caused the visit to abort, if available. void setAborted(Instruction *I = nullptr) { AbortedInfo.setInt(true); AbortedInfo.setPointer(I); } - /// \brief Mark the pointer as escaped. Intended for use in a void return. + /// Mark the pointer as escaped. Intended for use in a void return. /// \param I The instruction which escapes the pointer, if available. void setEscaped(Instruction *I = nullptr) { EscapedInfo.setInt(true); EscapedInfo.setPointer(I); } - /// \brief Mark the pointer as escaped, and the visit as aborted. Intended + /// Mark the pointer as escaped, and the visit as aborted. Intended /// for use in a void return. /// \param I The instruction which both escapes the pointer and aborts the /// visit, if available. @@ -121,10 +121,10 @@ /// \name Visitation infrastructure /// @{ - /// \brief The info collected about the pointer being visited thus far. + /// The info collected about the pointer being visited thus far. PtrInfo PI; - /// \brief A struct of the data needed to visit a particular use. + /// A struct of the data needed to visit a particular use. /// /// This is used to maintain a worklist fo to-visit uses. This is used to /// make the visit be iterative rather than recursive. @@ -135,10 +135,10 @@ APInt Offset; }; - /// \brief The worklist of to-visit uses. + /// The worklist of to-visit uses. SmallVector Worklist; - /// \brief A set of visited uses to break cycles in unreachable code. + /// A set of visited uses to break cycles in unreachable code. SmallPtrSet VisitedUses; /// @} @@ -147,14 +147,14 @@ /// This state is reset for each instruction visited. /// @{ - /// \brief The use currently being visited. + /// The use currently being visited. Use *U; - /// \brief True if we have a known constant offset for the use currently + /// True if we have a known constant offset for the use currently /// being visited. bool IsOffsetKnown; - /// \brief The constant offset of the use if that is known. + /// The constant offset of the use if that is known. APInt Offset; /// @} @@ -163,13 +163,13 @@ /// class, we can't create instances directly of this class. PtrUseVisitorBase(const DataLayout &DL) : DL(DL) {} - /// \brief Enqueue the users of this instruction in the visit worklist. + /// Enqueue the users of this instruction in the visit worklist. /// /// This will visit the users with the same offset of the current visit /// (including an unknown offset if that is the current state). void enqueueUsers(Instruction &I); - /// \brief Walk the operands of a GEP and adjust the offset as appropriate. + /// Walk the operands of a GEP and adjust the offset as appropriate. /// /// This routine does the heavy lifting of the pointer walk by computing /// offsets and looking through GEPs. @@ -178,7 +178,7 @@ } // end namespace detail -/// \brief A base class for visitors over the uses of a pointer value. +/// A base class for visitors over the uses of a pointer value. /// /// Once constructed, a user can call \c visit on a pointer value, and this /// will walk its uses and visit each instruction using an InstVisitor. It also @@ -216,7 +216,7 @@ "Must pass the derived type to this template!"); } - /// \brief Recursively visit the uses of the given pointer. + /// Recursively visit the uses of the given pointer. /// \returns An info struct about the pointer. See \c PtrInfo for details. PtrInfo visitPtr(Instruction &I) { // This must be a pointer type. Get an integer type suitable to hold Index: llvm/trunk/include/llvm/Analysis/RegionInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/RegionInfo.h +++ llvm/trunk/include/llvm/Analysis/RegionInfo.h @@ -726,7 +726,7 @@ BBtoRegionMap BBtoRegion; protected: - /// \brief Update refences to a RegionInfoT held by the RegionT managed here + /// Update refences to a RegionInfoT held by the RegionT managed here /// /// This is a post-move helper. Regions hold references to the owning /// RegionInfo object. After a move these need to be fixed. @@ -740,7 +740,7 @@ } private: - /// \brief Wipe this region tree's state without releasing any resources. + /// Wipe this region tree's state without releasing any resources. /// /// This is essentially a post-move helper only. It leaves the object in an /// assignable and destroyable state, but otherwise invalid. @@ -968,7 +968,7 @@ //@} }; -/// \brief Analysis pass that exposes the \c RegionInfo for a function. +/// Analysis pass that exposes the \c RegionInfo for a function. class RegionInfoAnalysis : public AnalysisInfoMixin { friend AnalysisInfoMixin; @@ -980,7 +980,7 @@ RegionInfo run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Printer pass for the \c RegionInfo. +/// Printer pass for the \c RegionInfo. class RegionInfoPrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -990,7 +990,7 @@ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Verifier pass for the \c RegionInfo. +/// Verifier pass for the \c RegionInfo. struct RegionInfoVerifierPass : PassInfoMixin { PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; Index: llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h =================================================================== --- llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h +++ llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h @@ -49,7 +49,7 @@ class User; class Value; -/// \brief Information about a load/store intrinsic defined by the target. +/// Information about a load/store intrinsic defined by the target. struct MemIntrinsicInfo { /// This is the pointer that the intrinsic is loading from or storing to. /// If this is non-null, then analysis/optimization passes can assume that @@ -73,18 +73,18 @@ } }; -/// \brief This pass provides access to the codegen interfaces that are needed +/// This pass provides access to the codegen interfaces that are needed /// for IR-level transformations. class TargetTransformInfo { public: - /// \brief Construct a TTI object using a type implementing the \c Concept + /// Construct a TTI object using a type implementing the \c Concept /// API below. /// /// This is used by targets to construct a TTI wrapping their target-specific /// implementaion that encodes appropriate costs for their target. template TargetTransformInfo(T Impl); - /// \brief Construct a baseline TTI object using a minimal implementation of + /// Construct a baseline TTI object using a minimal implementation of /// the \c Concept API below. /// /// The TTI implementation will reflect the information in the DataLayout @@ -99,7 +99,7 @@ // out-of-line. ~TargetTransformInfo(); - /// \brief Handle the invalidation of this information. + /// Handle the invalidation of this information. /// /// When used as a result of \c TargetIRAnalysis this method will be called /// when the function this was computed for changes. When it returns false, @@ -114,7 +114,7 @@ /// \name Generic Target Information /// @{ - /// \brief The kind of cost model. + /// The kind of cost model. /// /// There are several different cost models that can be customized by the /// target. The normalization of each cost model may be target specific. @@ -124,7 +124,7 @@ TCK_CodeSize ///< Instruction code size. }; - /// \brief Query the cost of a specified instruction. + /// Query the cost of a specified instruction. /// /// Clients should use this interface to query the cost of an existing /// instruction. The instruction must have a valid parent (basic block). @@ -145,7 +145,7 @@ llvm_unreachable("Unknown instruction cost kind"); } - /// \brief Underlying constants for 'cost' values in this interface. + /// Underlying constants for 'cost' values in this interface. /// /// Many APIs in this interface return a cost. This enum defines the /// fundamental values that should be used to interpret (and produce) those @@ -169,7 +169,7 @@ TCC_Expensive = 4 ///< The cost of a 'div' instruction on x86. }; - /// \brief Estimate the cost of a specific operation when lowered. + /// Estimate the cost of a specific operation when lowered. /// /// Note that this is designed to work on an arbitrary synthetic opcode, and /// thus work for hypothetical queries before an instruction has even been @@ -185,7 +185,7 @@ /// comments for a detailed explanation of the cost values. int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy = nullptr) const; - /// \brief Estimate the cost of a GEP operation when lowered. + /// Estimate the cost of a GEP operation when lowered. /// /// The contract for this function is the same as \c getOperationCost except /// that it supports an interface that provides extra information specific to @@ -193,14 +193,14 @@ int getGEPCost(Type *PointeeType, const Value *Ptr, ArrayRef Operands) const; - /// \brief Estimate the cost of a EXT operation when lowered. + /// Estimate the cost of a EXT operation when lowered. /// /// The contract for this function is the same as \c getOperationCost except /// that it supports an interface that provides extra information specific to /// the EXT operation. int getExtCost(const Instruction *I, const Value *Src) const; - /// \brief Estimate the cost of a function call when lowered. + /// Estimate the cost of a function call when lowered. /// /// The contract for this is the same as \c getOperationCost except that it /// supports an interface that provides extra information specific to call @@ -211,13 +211,13 @@ /// The latter is only interesting for varargs function types. int getCallCost(FunctionType *FTy, int NumArgs = -1) const; - /// \brief Estimate the cost of calling a specific function when lowered. + /// Estimate the cost of calling a specific function when lowered. /// /// This overload adds the ability to reason about the particular function /// being called in the event it is a library call with special lowering. int getCallCost(const Function *F, int NumArgs = -1) const; - /// \brief Estimate the cost of calling a specific function when lowered. + /// Estimate the cost of calling a specific function when lowered. /// /// This overload allows specifying a set of candidate argument values. int getCallCost(const Function *F, ArrayRef Arguments) const; @@ -230,13 +230,13 @@ /// individual classes of instructions would be better. unsigned getInliningThresholdMultiplier() const; - /// \brief Estimate the cost of an intrinsic when lowered. + /// Estimate the cost of an intrinsic when lowered. /// /// Mirrors the \c getCallCost method but uses an intrinsic identifier. int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy, ArrayRef ParamTys) const; - /// \brief Estimate the cost of an intrinsic when lowered. + /// Estimate the cost of an intrinsic when lowered. /// /// Mirrors the \c getCallCost method but uses an intrinsic identifier. int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy, @@ -248,7 +248,7 @@ unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI, unsigned &JTSize) const; - /// \brief Estimate the cost of a given IR user when lowered. + /// Estimate the cost of a given IR user when lowered. /// /// This can estimate the cost of either a ConstantExpr or Instruction when /// lowered. It has two primary advantages over the \c getOperationCost and @@ -271,7 +271,7 @@ /// comments for a detailed explanation of the cost values. int getUserCost(const User *U, ArrayRef Operands) const; - /// \brief This is a helper function which calls the two-argument getUserCost + /// This is a helper function which calls the two-argument getUserCost /// with \p Operands which are the current operands U has. int getUserCost(const User *U) const { SmallVector Operands(U->value_op_begin(), @@ -279,14 +279,14 @@ return getUserCost(U, Operands); } - /// \brief Return true if branch divergence exists. + /// Return true if branch divergence exists. /// /// Branch divergence has a significantly negative impact on GPU performance /// when threads in the same wavefront take different paths due to conditional /// branches. bool hasBranchDivergence() const; - /// \brief Returns whether V is a source of divergence. + /// Returns whether V is a source of divergence. /// /// This function provides the target-dependent information for /// the target-independent DivergenceAnalysis. DivergenceAnalysis first @@ -294,7 +294,7 @@ /// starting with the sources of divergence. bool isSourceOfDivergence(const Value *V) const; - // \brief Returns true for the target specific + // Returns true for the target specific // set of operations which produce uniform result // even taking non-unform arguments bool isAlwaysUniform(const Value *V) const; @@ -317,7 +317,7 @@ /// optimize away. unsigned getFlatAddressSpace() const; - /// \brief Test whether calls to a function lower to actual program function + /// Test whether calls to a function lower to actual program function /// calls. /// /// The idea is to test whether the program is likely to require a 'call' @@ -424,7 +424,7 @@ bool UnrollRemainder; }; - /// \brief Get target-customized preferences for the generic loop unrolling + /// Get target-customized preferences for the generic loop unrolling /// transformation. The caller will initialize UP with the current /// target-independent defaults. void getUnrollingPreferences(Loop *L, ScalarEvolution &, @@ -435,7 +435,7 @@ /// \name Scalar Target Information /// @{ - /// \brief Flags indicating the kind of support for population count. + /// Flags indicating the kind of support for population count. /// /// Compared to the SW implementation, HW support is supposed to /// significantly boost the performance when the population is dense, and it @@ -445,18 +445,18 @@ /// considered as "Slow". enum PopcntSupportKind { PSK_Software, PSK_SlowHardware, PSK_FastHardware }; - /// \brief Return true if the specified immediate is legal add immediate, that + /// Return true if the specified immediate is legal add immediate, that /// is the target has add instructions which can add a register with the /// immediate without having to materialize the immediate into a register. bool isLegalAddImmediate(int64_t Imm) const; - /// \brief Return true if the specified immediate is legal icmp immediate, + /// Return true if the specified immediate is legal icmp immediate, /// that is the target has icmp instructions which can compare a register /// against the immediate without having to materialize the immediate into a /// register. bool isLegalICmpImmediate(int64_t Imm) const; - /// \brief Return true if the addressing mode represented by AM is legal for + /// Return true if the addressing mode represented by AM is legal for /// this target, for a load/store of the specified type. /// The type may be VoidTy, in which case only return true if the addressing /// mode is legal for a load/store of any legal type. @@ -467,7 +467,7 @@ unsigned AddrSpace = 0, Instruction *I = nullptr) const; - /// \brief Return true if LSR cost of C1 is lower than C1. + /// Return true if LSR cost of C1 is lower than C1. bool isLSRCostLess(TargetTransformInfo::LSRCost &C1, TargetTransformInfo::LSRCost &C2) const; @@ -480,12 +480,12 @@ /// addressing mode expressions. bool shouldFavorPostInc() const; - /// \brief Return true if the target supports masked load/store + /// Return true if the target supports masked load/store /// AVX2 and AVX-512 targets allow masks for consecutive load and store bool isLegalMaskedStore(Type *DataType) const; bool isLegalMaskedLoad(Type *DataType) const; - /// \brief Return true if the target supports masked gather/scatter + /// Return true if the target supports masked gather/scatter /// AVX-512 fully supports gather and scatter for vectors with 32 and 64 /// bits scalar type. bool isLegalMaskedScatter(Type *DataType) const; @@ -508,7 +508,7 @@ /// Return true if target doesn't mind addresses in vectors. bool prefersVectorizedAddressing() const; - /// \brief Return the cost of the scaling factor used in the addressing + /// Return the cost of the scaling factor used in the addressing /// mode represented by AM for this target, for a load/store /// of the specified type. /// If the AM is supported, the return value must be >= 0. @@ -518,41 +518,41 @@ bool HasBaseReg, int64_t Scale, unsigned AddrSpace = 0) const; - /// \brief Return true if the loop strength reduce pass should make + /// Return true if the loop strength reduce pass should make /// Instruction* based TTI queries to isLegalAddressingMode(). This is /// needed on SystemZ, where e.g. a memcpy can only have a 12 bit unsigned /// immediate offset and no index register. bool LSRWithInstrQueries() const; - /// \brief Return true if it's free to truncate a value of type Ty1 to type + /// Return true if it's free to truncate a value of type Ty1 to type /// Ty2. e.g. On x86 it's free to truncate a i32 value in register EAX to i16 /// by referencing its sub-register AX. bool isTruncateFree(Type *Ty1, Type *Ty2) const; - /// \brief Return true if it is profitable to hoist instruction in the + /// Return true if it is profitable to hoist instruction in the /// then/else to before if. bool isProfitableToHoist(Instruction *I) const; bool useAA() const; - /// \brief Return true if this type is legal. + /// Return true if this type is legal. bool isTypeLegal(Type *Ty) const; - /// \brief Returns the target's jmp_buf alignment in bytes. + /// Returns the target's jmp_buf alignment in bytes. unsigned getJumpBufAlignment() const; - /// \brief Returns the target's jmp_buf size in bytes. + /// Returns the target's jmp_buf size in bytes. unsigned getJumpBufSize() const; - /// \brief Return true if switches should be turned into lookup tables for the + /// Return true if switches should be turned into lookup tables for the /// target. bool shouldBuildLookupTables() const; - /// \brief Return true if switches should be turned into lookup tables + /// Return true if switches should be turned into lookup tables /// containing this constant value for the target. bool shouldBuildLookupTablesForConstant(Constant *C) const; - /// \brief Return true if the input function which is cold at all call sites, + /// Return true if the input function which is cold at all call sites, /// should use coldcc calling convention. bool useColdCCForColdCall(Function &F) const; @@ -566,10 +566,10 @@ /// the scalarization cost of a load/store. bool supportsEfficientVectorElementLoadStore() const; - /// \brief Don't restrict interleaved unrolling to small loops. + /// Don't restrict interleaved unrolling to small loops. bool enableAggressiveInterleaving(bool LoopHasReductions) const; - /// \brief If not nullptr, enable inline expansion of memcmp. IsZeroCmp is + /// If not nullptr, enable inline expansion of memcmp. IsZeroCmp is /// true if this is the expansion of memcmp(p1, p2, s) == 0. struct MemCmpExpansionOptions { // The list of available load sizes (in bytes), sorted in decreasing order. @@ -577,10 +577,10 @@ }; const MemCmpExpansionOptions *enableMemCmpExpansion(bool IsZeroCmp) const; - /// \brief Enable matching of interleaved access groups. + /// Enable matching of interleaved access groups. bool enableInterleavedAccessVectorization() const; - /// \brief Indicate that it is potentially unsafe to automatically vectorize + /// Indicate that it is potentially unsafe to automatically vectorize /// floating-point operations because the semantics of vector and scalar /// floating-point semantics may differ. For example, ARM NEON v7 SIMD math /// does not support IEEE-754 denormal numbers, while depending on the @@ -589,16 +589,16 @@ /// operations, shuffles, or casts. bool isFPVectorizationPotentiallyUnsafe() const; - /// \brief Determine if the target supports unaligned memory accesses. + /// Determine if the target supports unaligned memory accesses. bool allowsMisalignedMemoryAccesses(LLVMContext &Context, unsigned BitWidth, unsigned AddressSpace = 0, unsigned Alignment = 1, bool *Fast = nullptr) const; - /// \brief Return hardware support for population count. + /// Return hardware support for population count. PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const; - /// \brief Return true if the hardware has a fast square-root instruction. + /// Return true if the hardware has a fast square-root instruction. bool haveFastSqrt(Type *Ty) const; /// Return true if it is faster to check if a floating-point value is NaN @@ -607,15 +607,15 @@ /// generally as cheap as checking for ordered/unordered. bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) const; - /// \brief Return the expected cost of supporting the floating point operation + /// Return the expected cost of supporting the floating point operation /// of the specified type. int getFPOpCost(Type *Ty) const; - /// \brief Return the expected cost of materializing for the given integer + /// Return the expected cost of materializing for the given integer /// immediate of the specified type. int getIntImmCost(const APInt &Imm, Type *Ty) const; - /// \brief Return the expected cost of materialization for the given integer + /// Return the expected cost of materialization for the given integer /// immediate of the specified type for a given instruction. The cost can be /// zero if the immediate can be folded into the specified instruction. int getIntImmCost(unsigned Opc, unsigned Idx, const APInt &Imm, @@ -623,7 +623,7 @@ int getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm, Type *Ty) const; - /// \brief Return the expected cost for the given integer when optimising + /// Return the expected cost for the given integer when optimising /// for size. This is different than the other integer immediate cost /// functions in that it is subtarget agnostic. This is useful when you e.g. /// target one ISA such as Aarch32 but smaller encodings could be possible @@ -637,7 +637,7 @@ /// \name Vector Target Information /// @{ - /// \brief The various kinds of shuffle patterns for vector queries. + /// The various kinds of shuffle patterns for vector queries. enum ShuffleKind { SK_Broadcast, ///< Broadcast element 0 to all other elements. SK_Reverse, ///< Reverse the order of the vector. @@ -651,7 +651,7 @@ ///< shuffle mask. }; - /// \brief Additional information about an operand's possible values. + /// Additional information about an operand's possible values. enum OperandValueKind { OK_AnyValue, // Operand can have any value. OK_UniformValue, // Operand is uniform (splat of a value). @@ -659,7 +659,7 @@ OK_NonUniformConstantValue // Operand is a non uniform constant value. }; - /// \brief Additional properties of an operand's values. + /// Additional properties of an operand's values. enum OperandValueProperties { OP_None = 0, OP_PowerOf2 = 1 }; /// \return The number of scalar or vector registers that the target has. @@ -812,7 +812,7 @@ ArrayRef Indices, unsigned Alignment, unsigned AddressSpace) const; - /// \brief Calculate the cost of performing a vector reduction. + /// Calculate the cost of performing a vector reduction. /// /// This is the cost of reducing the vector value of type \p Ty to a scalar /// value using the operation denoted by \p Opcode. The form of the reduction @@ -906,7 +906,7 @@ bool areInlineCompatible(const Function *Caller, const Function *Callee) const; - /// \brief The type of load/store indexing. + /// The type of load/store indexing. enum MemIndexedMode { MIM_Unindexed, ///< No indexing. MIM_PreInc, ///< Pre-incrementing. @@ -972,19 +972,19 @@ /// @} private: - /// \brief Estimate the latency of specified instruction. + /// Estimate the latency of specified instruction. /// Returns 1 as the default value. int getInstructionLatency(const Instruction *I) const; - /// \brief Returns the expected throughput cost of the instruction. + /// Returns the expected throughput cost of the instruction. /// Returns -1 if the cost is unknown. int getInstructionThroughput(const Instruction *I) const; - /// \brief The abstract base class used to type erase specific TTI + /// The abstract base class used to type erase specific TTI /// implementations. class Concept; - /// \brief The template model for the base class which wraps a concrete + /// The template model for the base class which wraps a concrete /// implementation in a type erased interface. template class Model; @@ -1574,7 +1574,7 @@ TargetTransformInfo::TargetTransformInfo(T Impl) : TTIImpl(new Model(Impl)) {} -/// \brief Analysis pass providing the \c TargetTransformInfo. +/// Analysis pass providing the \c TargetTransformInfo. /// /// The core idea of the TargetIRAnalysis is to expose an interface through /// which LLVM targets can analyze and provide information about the middle @@ -1589,13 +1589,13 @@ public: typedef TargetTransformInfo Result; - /// \brief Default construct a target IR analysis. + /// Default construct a target IR analysis. /// /// This will use the module's datalayout to construct a baseline /// conservative TTI result. TargetIRAnalysis(); - /// \brief Construct an IR analysis pass around a target-provide callback. + /// Construct an IR analysis pass around a target-provide callback. /// /// The callback will be called with a particular function for which the TTI /// is needed and must return a TTI object for that function. @@ -1621,7 +1621,7 @@ friend AnalysisInfoMixin; static AnalysisKey Key; - /// \brief The callback used to produce a result. + /// The callback used to produce a result. /// /// We use a completely opaque callback so that targets can provide whatever /// mechanism they desire for constructing the TTI for a given function. @@ -1633,11 +1633,11 @@ /// the external TargetMachine, and that reference needs to never dangle. std::function TTICallback; - /// \brief Helper function used as the callback in the default constructor. + /// Helper function used as the callback in the default constructor. static Result getDefaultTTI(const Function &F); }; -/// \brief Wrapper pass for TargetTransformInfo. +/// Wrapper pass for TargetTransformInfo. /// /// This pass can be constructed from a TTI object which it stores internally /// and is queried by passes. @@ -1650,7 +1650,7 @@ public: static char ID; - /// \brief We must provide a default constructor for the pass but it should + /// We must provide a default constructor for the pass but it should /// never be used. /// /// Use the constructor below or call one of the creation routines. @@ -1661,7 +1661,7 @@ TargetTransformInfo &getTTI(const Function &F); }; -/// \brief Create an analysis pass wrapper around a TTI object. +/// Create an analysis pass wrapper around a TTI object. /// /// This analysis pass just holds the TTI instance and makes it available to /// clients. Index: llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h =================================================================== --- llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h +++ llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h @@ -27,7 +27,7 @@ namespace llvm { -/// \brief Base class for use as a mix-in that aids implementing +/// Base class for use as a mix-in that aids implementing /// a TargetTransformInfo-compatible class. class TargetTransformInfoImplBase { protected: @@ -651,7 +651,7 @@ } }; -/// \brief CRTP base class for use as a mix-in that aids implementing +/// CRTP base class for use as a mix-in that aids implementing /// a TargetTransformInfo-compatible class. template class TargetTransformInfoImplCRTPBase : public TargetTransformInfoImplBase { Index: llvm/trunk/include/llvm/Analysis/ValueTracking.h =================================================================== --- llvm/trunk/include/llvm/Analysis/ValueTracking.h +++ llvm/trunk/include/llvm/Analysis/ValueTracking.h @@ -288,7 +288,7 @@ return GetUnderlyingObject(const_cast(V), DL, MaxLookup); } - /// \brief This method is similar to GetUnderlyingObject except that it can + /// This method is similar to GetUnderlyingObject except that it can /// look through phi and select instructions and return multiple objects. /// /// If LoopInfo is passed, loop phis are further analyzed. If a pointer @@ -461,7 +461,7 @@ /// the parent of I. bool programUndefinedIfFullPoison(const Instruction *PoisonI); - /// \brief Specific patterns of select instructions we can match. + /// Specific patterns of select instructions we can match. enum SelectPatternFlavor { SPF_UNKNOWN = 0, SPF_SMIN, /// Signed minimum @@ -474,7 +474,7 @@ SPF_NABS /// Negated absolute value }; - /// \brief Behavior when a floating point min/max is given one NaN and one + /// Behavior when a floating point min/max is given one NaN and one /// non-NaN as input. enum SelectPatternNaNBehavior { SPNB_NA = 0, /// NaN behavior not applicable. Index: llvm/trunk/include/llvm/Analysis/VectorUtils.h =================================================================== --- llvm/trunk/include/llvm/Analysis/VectorUtils.h +++ llvm/trunk/include/llvm/Analysis/VectorUtils.h @@ -33,50 +33,50 @@ enum ID : unsigned; } -/// \brief Identify if the intrinsic is trivially vectorizable. +/// Identify if the intrinsic is trivially vectorizable. /// This method returns true if the intrinsic's argument types are all /// scalars for the scalar form of the intrinsic and all vectors for /// the vector form of the intrinsic. bool isTriviallyVectorizable(Intrinsic::ID ID); -/// \brief Identifies if the intrinsic has a scalar operand. It checks for +/// Identifies if the intrinsic has a scalar operand. It checks for /// ctlz,cttz and powi special intrinsics whose argument is scalar. bool hasVectorInstrinsicScalarOpd(Intrinsic::ID ID, unsigned ScalarOpdIdx); -/// \brief Returns intrinsic ID for call. +/// Returns intrinsic ID for call. /// For the input call instruction it finds mapping intrinsic and returns /// its intrinsic ID, in case it does not found it return not_intrinsic. Intrinsic::ID getVectorIntrinsicIDForCall(const CallInst *CI, const TargetLibraryInfo *TLI); -/// \brief Find the operand of the GEP that should be checked for consecutive +/// Find the operand of the GEP that should be checked for consecutive /// stores. This ignores trailing indices that have no effect on the final /// pointer. unsigned getGEPInductionOperand(const GetElementPtrInst *Gep); -/// \brief If the argument is a GEP, then returns the operand identified by +/// If the argument is a GEP, then returns the operand identified by /// getGEPInductionOperand. However, if there is some other non-loop-invariant /// operand, it returns that instead. Value *stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp); -/// \brief If a value has only one user that is a CastInst, return it. +/// If a value has only one user that is a CastInst, return it. Value *getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty); -/// \brief Get the stride of a pointer access in a loop. Looks for symbolic +/// Get the stride of a pointer access in a loop. Looks for symbolic /// strides "a[i*stride]". Returns the symbolic stride, or null otherwise. Value *getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp); -/// \brief Given a vector and an element number, see if the scalar value is +/// Given a vector and an element number, see if the scalar value is /// already around as a register, for example if it were inserted then extracted /// from the vector. Value *findScalarElement(Value *V, unsigned EltNo); -/// \brief Get splat value if the input is a splat vector or return nullptr. +/// Get splat value if the input is a splat vector or return nullptr. /// The value may be extracted from a splat constants vector or from /// a sequence of instructions that broadcast a single value into a vector. const Value *getSplatValue(const Value *V); -/// \brief Compute a map of integer instructions to their minimum legal type +/// Compute a map of integer instructions to their minimum legal type /// size. /// /// C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int @@ -124,7 +124,7 @@ /// This function always sets a (possibly null) value for each K in Kinds. Instruction *propagateMetadata(Instruction *I, ArrayRef VL); -/// \brief Create an interleave shuffle mask. +/// Create an interleave shuffle mask. /// /// This function creates a shuffle mask for interleaving \p NumVecs vectors of /// vectorization factor \p VF into a single wide vector. The mask is of the @@ -138,7 +138,7 @@ Constant *createInterleaveMask(IRBuilder<> &Builder, unsigned VF, unsigned NumVecs); -/// \brief Create a stride shuffle mask. +/// Create a stride shuffle mask. /// /// This function creates a shuffle mask whose elements begin at \p Start and /// are incremented by \p Stride. The mask can be used to deinterleave an @@ -153,7 +153,7 @@ Constant *createStrideMask(IRBuilder<> &Builder, unsigned Start, unsigned Stride, unsigned VF); -/// \brief Create a sequential shuffle mask. +/// Create a sequential shuffle mask. /// /// This function creates shuffle mask whose elements are sequential and begin /// at \p Start. The mask contains \p NumInts integers and is padded with \p @@ -167,7 +167,7 @@ Constant *createSequentialMask(IRBuilder<> &Builder, unsigned Start, unsigned NumInts, unsigned NumUndefs); -/// \brief Concatenate a list of vectors. +/// Concatenate a list of vectors. /// /// This function generates code that concatenate the vectors in \p Vecs into a /// single large vector. The number of vectors should be greater than one, and Index: llvm/trunk/include/llvm/AsmParser/Parser.h =================================================================== --- llvm/trunk/include/llvm/AsmParser/Parser.h +++ llvm/trunk/include/llvm/AsmParser/Parser.h @@ -30,7 +30,7 @@ /// Module (intermediate representation) with the corresponding features. Note /// that this does not verify that the generated Module is valid, so you should /// run the verifier after parsing the file to check that it is okay. -/// \brief Parse LLVM Assembly from a file +/// Parse LLVM Assembly from a file /// \param Filename The name of the file to parse /// \param Error Error result info. /// \param Context Context in which to allocate globals info. @@ -50,7 +50,7 @@ /// Module (intermediate representation) with the corresponding features. Note /// that this does not verify that the generated Module is valid, so you should /// run the verifier after parsing the file to check that it is okay. -/// \brief Parse LLVM Assembly from a string +/// Parse LLVM Assembly from a string /// \param AsmString The string containing assembly /// \param Error Error result info. /// \param Context Context in which to allocate globals info. @@ -68,7 +68,7 @@ StringRef DataLayoutString = ""); /// parseAssemblyFile and parseAssemblyString are wrappers around this function. -/// \brief Parse LLVM Assembly from a MemoryBuffer. +/// Parse LLVM Assembly from a MemoryBuffer. /// \param F The MemoryBuffer containing assembly /// \param Err Error result info. /// \param Slots The optional slot mapping that will be initialized during Index: llvm/trunk/include/llvm/Bitcode/BitcodeWriter.h =================================================================== --- llvm/trunk/include/llvm/Bitcode/BitcodeWriter.h +++ llvm/trunk/include/llvm/Bitcode/BitcodeWriter.h @@ -105,7 +105,7 @@ const std::map *ModuleToSummariesForIndex); }; - /// \brief Write the specified module to the specified raw output stream. + /// Write the specified module to the specified raw output stream. /// /// For streams where it matters, the given stream should be in "binary" /// mode. Index: llvm/trunk/include/llvm/Bitcode/BitcodeWriterPass.h =================================================================== --- llvm/trunk/include/llvm/Bitcode/BitcodeWriterPass.h +++ llvm/trunk/include/llvm/Bitcode/BitcodeWriterPass.h @@ -23,7 +23,7 @@ class ModulePass; class raw_ostream; -/// \brief Create and return a pass that writes the module to the specified +/// Create and return a pass that writes the module to the specified /// ostream. Note that this pass is designed for use with the legacy pass /// manager. /// @@ -40,7 +40,7 @@ bool EmitSummaryIndex = false, bool EmitModuleHash = false); -/// \brief Pass for writing a module of IR out to a bitcode file. +/// Pass for writing a module of IR out to a bitcode file. /// /// Note that this is intended for use with the new pass manager. To construct /// a pass for the legacy pass manager, use the function above. @@ -51,7 +51,7 @@ bool EmitModuleHash; public: - /// \brief Construct a bitcode writer pass around a particular output stream. + /// Construct a bitcode writer pass around a particular output stream. /// /// If \c ShouldPreserveUseListOrder, encode use-list order so it can be /// reproduced when deserialized. @@ -65,7 +65,7 @@ : OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder), EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {} - /// \brief Run the bitcode writer pass, and output the module to the selected + /// Run the bitcode writer pass, and output the module to the selected /// output stream. PreservedAnalyses run(Module &M, ModuleAnalysisManager &); }; Index: llvm/trunk/include/llvm/Bitcode/BitstreamWriter.h =================================================================== --- llvm/trunk/include/llvm/Bitcode/BitstreamWriter.h +++ llvm/trunk/include/llvm/Bitcode/BitstreamWriter.h @@ -90,10 +90,10 @@ assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance"); } - /// \brief Retrieve the current position in the stream, in bits. + /// Retrieve the current position in the stream, in bits. uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; } - /// \brief Retrieve the number of bits currently used to encode an abbrev ID. + /// Retrieve the number of bits currently used to encode an abbrev ID. unsigned GetAbbrevIDWidth() const { return CurCodeSize; } //===--------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/CodeGen/Analysis.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/Analysis.h +++ llvm/trunk/include/llvm/CodeGen/Analysis.h @@ -36,7 +36,7 @@ class SelectionDAG; struct EVT; -/// \brief Compute the linearized index of a member in a nested +/// Compute the linearized index of a member in a nested /// aggregate/struct/array. /// /// Given an LLVM IR aggregate type and a sequence of insertvalue or Index: llvm/trunk/include/llvm/CodeGen/AsmPrinter.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/AsmPrinter.h +++ llvm/trunk/include/llvm/CodeGen/AsmPrinter.h @@ -343,10 +343,10 @@ /// Lower the specified LLVM Constant to an MCExpr. virtual const MCExpr *lowerConstant(const Constant *CV); - /// \brief Print a general LLVM constant to the .s file. + /// Print a general LLVM constant to the .s file. void EmitGlobalConstant(const DataLayout &DL, const Constant *CV); - /// \brief Unnamed constant global variables solely contaning a pointer to + /// Unnamed constant global variables solely contaning a pointer to /// another globals variable act like a global variable "proxy", or GOT /// equivalents, i.e., it's only used to hold the address of the latter. One /// optimization is to replace accesses to these proxies by using the GOT @@ -356,7 +356,7 @@ /// accesses to GOT entries. void computeGlobalGOTEquivs(Module &M); - /// \brief Constant expressions using GOT equivalent globals may not be + /// Constant expressions using GOT equivalent globals may not be /// eligible for PC relative GOT entry conversion, in such cases we need to /// emit the proxies we previously omitted in EmitGlobalVariable. void emitGlobalGOTEquivs(); @@ -541,10 +541,10 @@ // Dwarf Lowering Routines //===------------------------------------------------------------------===// - /// \brief Emit frame instruction to describe the layout of the frame. + /// Emit frame instruction to describe the layout of the frame. void emitCFIInstruction(const MCCFIInstruction &Inst) const; - /// \brief Emit Dwarf abbreviation table. + /// Emit Dwarf abbreviation table. template void emitDwarfAbbrevs(const T &Abbrevs) const { // For each abbreviation. for (const auto &Abbrev : Abbrevs) @@ -556,7 +556,7 @@ void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const; - /// \brief Recursively emit Dwarf DIE tree. + /// Recursively emit Dwarf DIE tree. void emitDwarfDIE(const DIE &Die) const; //===------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/CodeGen/AtomicExpandUtils.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/AtomicExpandUtils.h +++ llvm/trunk/include/llvm/CodeGen/AtomicExpandUtils.h @@ -26,7 +26,7 @@ function_ref &, Value *, Value *, Value *, AtomicOrdering, Value *&, Value *&)>; -/// \brief Expand an atomic RMW instruction into a loop utilizing +/// Expand an atomic RMW instruction into a loop utilizing /// cmpxchg. You'll want to make sure your target machine likes cmpxchg /// instructions in the first place and that there isn't another, better, /// transformation available (for example AArch32/AArch64 have linked loads). Index: llvm/trunk/include/llvm/CodeGen/BasicTTIImpl.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/BasicTTIImpl.h +++ llvm/trunk/include/llvm/CodeGen/BasicTTIImpl.h @@ -65,7 +65,7 @@ extern cl::opt PartialUnrollingThreshold; -/// \brief Base class which can be used to help build a TTI implementation. +/// Base class which can be used to help build a TTI implementation. /// /// This class provides as much implementation of the TTI interface as is /// possible using the target independent parts of the code generator. @@ -101,12 +101,12 @@ return Cost; } - /// \brief Local query method delegates up to T which *must* implement this! + /// Local query method delegates up to T which *must* implement this! const TargetSubtargetInfo *getST() const { return static_cast(this)->getST(); } - /// \brief Local query method delegates up to T which *must* implement this! + /// Local query method delegates up to T which *must* implement this! const TargetLoweringBase *getTLI() const { return static_cast(this)->getTLI(); } @@ -1204,7 +1204,7 @@ return SingleCallCost; } - /// \brief Compute a cost of the given call instruction. + /// Compute a cost of the given call instruction. /// /// Compute the cost of calling function F with return type RetTy and /// argument types Tys. F might be nullptr, in this case the cost of an @@ -1365,7 +1365,7 @@ /// @} }; -/// \brief Concrete BasicTTIImpl that can be used if no further customization +/// Concrete BasicTTIImpl that can be used if no further customization /// is needed. class BasicTTIImpl : public BasicTTIImplBase { using BaseT = BasicTTIImplBase; Index: llvm/trunk/include/llvm/CodeGen/CalcSpillWeights.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/CalcSpillWeights.h +++ llvm/trunk/include/llvm/CodeGen/CalcSpillWeights.h @@ -22,7 +22,7 @@ class MachineLoopInfo; class VirtRegMap; - /// \brief Normalize the spill weight of a live interval + /// Normalize the spill weight of a live interval /// /// The spill weight of a live interval is computed as: /// @@ -42,7 +42,7 @@ return UseDefFreq / (Size + 25*SlotIndex::InstrDist); } - /// \brief Calculate auxiliary information for a virtual register such as its + /// Calculate auxiliary information for a virtual register such as its /// spill weight and allocation hint. class VirtRegAuxInfo { public: @@ -64,10 +64,10 @@ NormalizingFn norm = normalizeSpillWeight) : MF(mf), LIS(lis), VRM(vrm), Loops(loops), MBFI(mbfi), normalize(norm) {} - /// \brief (re)compute li's spill weight and allocation hint. + /// (re)compute li's spill weight and allocation hint. void calculateSpillWeightAndHint(LiveInterval &li); - /// \brief Compute future expected spill weight of a split artifact of li + /// Compute future expected spill weight of a split artifact of li /// that will span between start and end slot indexes. /// \param li The live interval to be split. /// \param start The expected begining of the split artifact. Instructions @@ -78,7 +78,7 @@ /// negative weight for unspillable li. float futureWeight(LiveInterval &li, SlotIndex start, SlotIndex end); - /// \brief Helper function for weight calculations. + /// Helper function for weight calculations. /// (Re)compute li's spill weight and allocation hint, or, for non null /// start and end - compute future expected spill weight of a split /// artifact of li that will span between start and end slot indexes. @@ -94,7 +94,7 @@ SlotIndex *end = nullptr); }; - /// \brief Compute spill weights and allocation hints for all virtual register + /// Compute spill weights and allocation hints for all virtual register /// live intervals. void calculateSpillWeightsAndHints(LiveIntervals &LIS, MachineFunction &MF, VirtRegMap *VRM, Index: llvm/trunk/include/llvm/CodeGen/CommandFlags.inc =================================================================== --- llvm/trunk/include/llvm/CodeGen/CommandFlags.inc +++ llvm/trunk/include/llvm/CodeGen/CommandFlags.inc @@ -349,7 +349,7 @@ return Features.getFeatures(); } -/// \brief Set function attributes of functions in Module M based on CPU, +/// Set function attributes of functions in Module M based on CPU, /// Features, and command line flags. LLVM_ATTRIBUTE_UNUSED static void setFunctionAttributes(StringRef CPU, StringRef Features, Module &M) { Index: llvm/trunk/include/llvm/CodeGen/CostTable.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/CostTable.h +++ llvm/trunk/include/llvm/CodeGen/CostTable.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief Cost tables and simple lookup functions +/// Cost tables and simple lookup functions /// //===----------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/CodeGen/DIE.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/DIE.h +++ llvm/trunk/include/llvm/CodeGen/DIE.h @@ -136,7 +136,7 @@ /// The bump allocator to use when creating DIEAbbrev objects in the uniqued /// storage container. BumpPtrAllocator &Alloc; - /// \brief FoldingSet that uniques the abbreviations. + /// FoldingSet that uniques the abbreviations. FoldingSet AbbreviationsSet; /// A list of all the unique abbreviations in use. std::vector Abbreviations; Index: llvm/trunk/include/llvm/CodeGen/FastISel.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/FastISel.h +++ llvm/trunk/include/llvm/CodeGen/FastISel.h @@ -61,7 +61,7 @@ class User; class Value; -/// \brief This is a fast-path instruction selection class that generates poor +/// This is a fast-path instruction selection class that generates poor /// code and doesn't support illegal types or non-trivial lowering, but runs /// quickly. class FastISel { @@ -78,7 +78,7 @@ bool IsReturnValueUsed : 1; bool IsPatchPoint : 1; - // \brief IsTailCall Should be modified by implementations of FastLowerCall + // IsTailCall Should be modified by implementations of FastLowerCall // that perform tail call conversions. bool IsTailCall = false; @@ -215,13 +215,13 @@ const TargetLibraryInfo *LibInfo; bool SkipTargetIndependentISel; - /// \brief The position of the last instruction for materializing constants + /// The position of the last instruction for materializing constants /// for use in the current block. It resets to EmitStartPt when it makes sense /// (for example, it's usually profitable to avoid function calls between the /// definition and the use) MachineInstr *LastLocalValue; - /// \brief The top most instruction in the current block that is allowed for + /// The top most instruction in the current block that is allowed for /// emitting local variables. LastLocalValue resets to EmitStartPt when it /// makes sense (for example, on function calls) MachineInstr *EmitStartPt; @@ -233,56 +233,56 @@ public: virtual ~FastISel(); - /// \brief Return the position of the last instruction emitted for + /// Return the position of the last instruction emitted for /// materializing constants for use in the current block. MachineInstr *getLastLocalValue() { return LastLocalValue; } - /// \brief Update the position of the last instruction emitted for + /// Update the position of the last instruction emitted for /// materializing constants for use in the current block. void setLastLocalValue(MachineInstr *I) { EmitStartPt = I; LastLocalValue = I; } - /// \brief Set the current block to which generated machine instructions will + /// Set the current block to which generated machine instructions will /// be appended. void startNewBlock(); /// Flush the local value map and sink local values if possible. void finishBasicBlock(); - /// \brief Return current debug location information. + /// Return current debug location information. DebugLoc getCurDebugLoc() const { return DbgLoc; } - /// \brief Do "fast" instruction selection for function arguments and append + /// Do "fast" instruction selection for function arguments and append /// the machine instructions to the current block. Returns true when /// successful. bool lowerArguments(); - /// \brief Do "fast" instruction selection for the given LLVM IR instruction + /// Do "fast" instruction selection for the given LLVM IR instruction /// and append the generated machine instructions to the current block. /// Returns true if selection was successful. bool selectInstruction(const Instruction *I); - /// \brief Do "fast" instruction selection for the given LLVM IR operator + /// Do "fast" instruction selection for the given LLVM IR operator /// (Instruction or ConstantExpr), and append generated machine instructions /// to the current block. Return true if selection was successful. bool selectOperator(const User *I, unsigned Opcode); - /// \brief Create a virtual register and arrange for it to be assigned the + /// Create a virtual register and arrange for it to be assigned the /// value for the given LLVM value. unsigned getRegForValue(const Value *V); - /// \brief Look up the value to see if its value is already cached in a + /// Look up the value to see if its value is already cached in a /// register. It may be defined by instructions across blocks or defined /// locally. unsigned lookUpRegForValue(const Value *V); - /// \brief This is a wrapper around getRegForValue that also takes care of + /// This is a wrapper around getRegForValue that also takes care of /// truncating or sign-extending the given getelementptr index value. std::pair getRegForGEPIndex(const Value *V); - /// \brief We're checking to see if we can fold \p LI into \p FoldInst. Note + /// We're checking to see if we can fold \p LI into \p FoldInst. Note /// that we could have a sequence where multiple LLVM IR instructions are /// folded into the same machineinstr. For example we could have: /// @@ -296,7 +296,7 @@ /// If we succeed folding, return true. bool tryToFoldLoad(const LoadInst *LI, const Instruction *FoldInst); - /// \brief The specified machine instr operand is a vreg, and that vreg is + /// The specified machine instr operand is a vreg, and that vreg is /// being provided by the specified load instruction. If possible, try to /// fold the load as an operand to the instruction, returning true if /// possible. @@ -307,11 +307,11 @@ return false; } - /// \brief Reset InsertPt to prepare for inserting instructions into the + /// Reset InsertPt to prepare for inserting instructions into the /// current block. void recomputeInsertPt(); - /// \brief Remove all dead instructions between the I and E. + /// Remove all dead instructions between the I and E. void removeDeadCode(MachineBasicBlock::iterator I, MachineBasicBlock::iterator E); @@ -320,11 +320,11 @@ DebugLoc DL; }; - /// \brief Prepare InsertPt to begin inserting instructions into the local + /// Prepare InsertPt to begin inserting instructions into the local /// value area and return the old insert position. SavePoint enterLocalValueArea(); - /// \brief Reset InsertPt to the given old insert position. + /// Reset InsertPt to the given old insert position. void leaveLocalValueArea(SavePoint Old); protected: @@ -332,45 +332,45 @@ const TargetLibraryInfo *LibInfo, bool SkipTargetIndependentISel = false); - /// \brief This method is called by target-independent code when the normal + /// This method is called by target-independent code when the normal /// FastISel process fails to select an instruction. This gives targets a /// chance to emit code for anything that doesn't fit into FastISel's /// framework. It returns true if it was successful. virtual bool fastSelectInstruction(const Instruction *I) = 0; - /// \brief This method is called by target-independent code to do target- + /// This method is called by target-independent code to do target- /// specific argument lowering. It returns true if it was successful. virtual bool fastLowerArguments(); - /// \brief This method is called by target-independent code to do target- + /// This method is called by target-independent code to do target- /// specific call lowering. It returns true if it was successful. virtual bool fastLowerCall(CallLoweringInfo &CLI); - /// \brief This method is called by target-independent code to do target- + /// This method is called by target-independent code to do target- /// specific intrinsic lowering. It returns true if it was successful. virtual bool fastLowerIntrinsicCall(const IntrinsicInst *II); - /// \brief This method is called by target-independent code to request that an + /// This method is called by target-independent code to request that an /// instruction with the given type and opcode be emitted. virtual unsigned fastEmit_(MVT VT, MVT RetVT, unsigned Opcode); - /// \brief This method is called by target-independent code to request that an + /// This method is called by target-independent code to request that an /// instruction with the given type, opcode, and register operand be emitted. virtual unsigned fastEmit_r(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill); - /// \brief This method is called by target-independent code to request that an + /// This method is called by target-independent code to request that an /// instruction with the given type, opcode, and register operands be emitted. virtual unsigned fastEmit_rr(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill); - /// \brief This method is called by target-independent code to request that an + /// This method is called by target-independent code to request that an /// instruction with the given type, opcode, and register and immediate /// operands be emitted. virtual unsigned fastEmit_ri(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t Imm); - /// \brief This method is a wrapper of fastEmit_ri. + /// This method is a wrapper of fastEmit_ri. /// /// It first tries to emit an instruction with an immediate operand using /// fastEmit_ri. If that fails, it materializes the immediate into a register @@ -378,80 +378,80 @@ unsigned fastEmit_ri_(MVT VT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t Imm, MVT ImmType); - /// \brief This method is called by target-independent code to request that an + /// This method is called by target-independent code to request that an /// instruction with the given type, opcode, and immediate operand be emitted. virtual unsigned fastEmit_i(MVT VT, MVT RetVT, unsigned Opcode, uint64_t Imm); - /// \brief This method is called by target-independent code to request that an + /// This method is called by target-independent code to request that an /// instruction with the given type, opcode, and floating-point immediate /// operand be emitted. virtual unsigned fastEmit_f(MVT VT, MVT RetVT, unsigned Opcode, const ConstantFP *FPImm); - /// \brief Emit a MachineInstr with no operands and a result register in the + /// Emit a MachineInstr with no operands and a result register in the /// given register class. unsigned fastEmitInst_(unsigned MachineInstOpcode, const TargetRegisterClass *RC); - /// \brief Emit a MachineInstr with one register operand and a result register + /// Emit a MachineInstr with one register operand and a result register /// in the given register class. unsigned fastEmitInst_r(unsigned MachineInstOpcode, const TargetRegisterClass *RC, unsigned Op0, bool Op0IsKill); - /// \brief Emit a MachineInstr with two register operands and a result + /// Emit a MachineInstr with two register operands and a result /// register in the given register class. unsigned fastEmitInst_rr(unsigned MachineInstOpcode, const TargetRegisterClass *RC, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill); - /// \brief Emit a MachineInstr with three register operands and a result + /// Emit a MachineInstr with three register operands and a result /// register in the given register class. unsigned fastEmitInst_rrr(unsigned MachineInstOpcode, const TargetRegisterClass *RC, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, unsigned Op2, bool Op2IsKill); - /// \brief Emit a MachineInstr with a register operand, an immediate, and a + /// Emit a MachineInstr with a register operand, an immediate, and a /// result register in the given register class. unsigned fastEmitInst_ri(unsigned MachineInstOpcode, const TargetRegisterClass *RC, unsigned Op0, bool Op0IsKill, uint64_t Imm); - /// \brief Emit a MachineInstr with one register operand and two immediate + /// Emit a MachineInstr with one register operand and two immediate /// operands. unsigned fastEmitInst_rii(unsigned MachineInstOpcode, const TargetRegisterClass *RC, unsigned Op0, bool Op0IsKill, uint64_t Imm1, uint64_t Imm2); - /// \brief Emit a MachineInstr with a floating point immediate, and a result + /// Emit a MachineInstr with a floating point immediate, and a result /// register in the given register class. unsigned fastEmitInst_f(unsigned MachineInstOpcode, const TargetRegisterClass *RC, const ConstantFP *FPImm); - /// \brief Emit a MachineInstr with two register operands, an immediate, and a + /// Emit a MachineInstr with two register operands, an immediate, and a /// result register in the given register class. unsigned fastEmitInst_rri(unsigned MachineInstOpcode, const TargetRegisterClass *RC, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t Imm); - /// \brief Emit a MachineInstr with a single immediate operand, and a result + /// Emit a MachineInstr with a single immediate operand, and a result /// register in the given register class. unsigned fastEmitInst_i(unsigned MachineInstrOpcode, const TargetRegisterClass *RC, uint64_t Imm); - /// \brief Emit a MachineInstr for an extract_subreg from a specified index of + /// Emit a MachineInstr for an extract_subreg from a specified index of /// a superregister to a specified type. unsigned fastEmitInst_extractsubreg(MVT RetVT, unsigned Op0, bool Op0IsKill, uint32_t Idx); - /// \brief Emit MachineInstrs to compute the value of Op with all but the + /// Emit MachineInstrs to compute the value of Op with all but the /// least significant bit set to zero. unsigned fastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill); - /// \brief Emit an unconditional branch to the given block, unless it is the + /// Emit an unconditional branch to the given block, unless it is the /// immediate (fall-through) successor, and update the CFG. void fastEmitBranch(MachineBasicBlock *MBB, const DebugLoc &DL); @@ -460,7 +460,7 @@ void finishCondBranch(const BasicBlock *BranchBB, MachineBasicBlock *TrueMBB, MachineBasicBlock *FalseMBB); - /// \brief Update the value map to include the new mapping for this + /// Update the value map to include the new mapping for this /// instruction, or insert an extra copy to get the result in a previous /// determined register. /// @@ -471,26 +471,26 @@ unsigned createResultReg(const TargetRegisterClass *RC); - /// \brief Try to constrain Op so that it is usable by argument OpNum of the + /// Try to constrain Op so that it is usable by argument OpNum of the /// provided MCInstrDesc. If this fails, create a new virtual register in the /// correct class and COPY the value there. unsigned constrainOperandRegClass(const MCInstrDesc &II, unsigned Op, unsigned OpNum); - /// \brief Emit a constant in a register using target-specific logic, such as + /// Emit a constant in a register using target-specific logic, such as /// constant pool loads. virtual unsigned fastMaterializeConstant(const Constant *C) { return 0; } - /// \brief Emit an alloca address in a register using target-specific logic. + /// Emit an alloca address in a register using target-specific logic. virtual unsigned fastMaterializeAlloca(const AllocaInst *C) { return 0; } - /// \brief Emit the floating-point constant +0.0 in a register using target- + /// Emit the floating-point constant +0.0 in a register using target- /// specific logic. virtual unsigned fastMaterializeFloatZero(const ConstantFP *CF) { return 0; } - /// \brief Check if \c Add is an add that can be safely folded into \c GEP. + /// Check if \c Add is an add that can be safely folded into \c GEP. /// /// \c Add can be folded into \c GEP if: /// - \c Add is an add, @@ -499,10 +499,10 @@ /// - \c Add has a constant operand. bool canFoldAddIntoGEP(const User *GEP, const Value *Add); - /// \brief Test whether the given value has exactly one use. + /// Test whether the given value has exactly one use. bool hasTrivialKill(const Value *V); - /// \brief Create a machine mem operand from the given instruction. + /// Create a machine mem operand from the given instruction. MachineMemOperand *createMachineMemOperandFor(const Instruction *I) const; CmpInst::Predicate optimizeCmpPredicate(const CmpInst *CI) const; @@ -525,7 +525,7 @@ } bool lowerCall(const CallInst *I); - /// \brief Select and emit code for a binary operator instruction, which has + /// Select and emit code for a binary operator instruction, which has /// an opcode which directly corresponds to the given ISD opcode. bool selectBinaryOp(const User *I, unsigned ISDOpcode); bool selectFNeg(const User *I); @@ -542,7 +542,7 @@ bool selectXRayTypedEvent(const CallInst *II); private: - /// \brief Handle PHI nodes in successor blocks. + /// Handle PHI nodes in successor blocks. /// /// Emit code to ensure constants are copied into registers when needed. /// Remember the virtual registers that need to be added to the Machine PHI @@ -551,21 +551,21 @@ /// correspond to a different MBB than the end. bool handlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB); - /// \brief Helper for materializeRegForValue to materialize a constant in a + /// Helper for materializeRegForValue to materialize a constant in a /// target-independent way. unsigned materializeConstant(const Value *V, MVT VT); - /// \brief Helper for getRegForVale. This function is called when the value + /// Helper for getRegForVale. This function is called when the value /// isn't already available in a register and must be materialized with new /// instructions. unsigned materializeRegForValue(const Value *V, MVT VT); - /// \brief Clears LocalValueMap and moves the area for the new local variables + /// Clears LocalValueMap and moves the area for the new local variables /// to the beginning of the block. It helps to avoid spilling cached variables /// across heavy instructions like calls. void flushLocalValueMap(); - /// \brief Removes dead local value instructions after SavedLastLocalvalue. + /// Removes dead local value instructions after SavedLastLocalvalue. void removeDeadLocalValueCode(MachineInstr *SavedLastLocalValue); struct InstOrderMap { @@ -582,10 +582,10 @@ void sinkLocalValueMaterialization(MachineInstr &LocalMI, unsigned DefReg, InstOrderMap &OrderMap); - /// \brief Insertion point before trying to select the current instruction. + /// Insertion point before trying to select the current instruction. MachineBasicBlock::iterator SavedInsertPt; - /// \brief Add a stackmap or patchpoint intrinsic call's live variable + /// Add a stackmap or patchpoint intrinsic call's live variable /// operands to a stackmap or patchpoint machine instruction. bool addStackMapLiveVars(SmallVectorImpl &Ops, const CallInst *CI, unsigned StartIdx); Index: llvm/trunk/include/llvm/CodeGen/LazyMachineBlockFrequencyInfo.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/LazyMachineBlockFrequencyInfo.h +++ llvm/trunk/include/llvm/CodeGen/LazyMachineBlockFrequencyInfo.h @@ -23,7 +23,7 @@ #include "llvm/CodeGen/MachineLoopInfo.h" namespace llvm { -/// \brief This is an alternative analysis pass to MachineBlockFrequencyInfo. +/// This is an alternative analysis pass to MachineBlockFrequencyInfo. /// The difference is that with this pass, the block frequencies are not /// computed when the analysis pass is executed but rather when the BFI result /// is explicitly requested by the analysis client. @@ -49,7 +49,7 @@ /// The function. MachineFunction *MF = nullptr; - /// \brief Calculate MBFI and all other analyses that's not available and + /// Calculate MBFI and all other analyses that's not available and /// required by BFI. MachineBlockFrequencyInfo &calculateIfNotAvailable() const; @@ -58,10 +58,10 @@ LazyMachineBlockFrequencyInfoPass(); - /// \brief Compute and return the block frequencies. + /// Compute and return the block frequencies. MachineBlockFrequencyInfo &getBFI() { return calculateIfNotAvailable(); } - /// \brief Compute and return the block frequencies. + /// Compute and return the block frequencies. const MachineBlockFrequencyInfo &getBFI() const { return calculateIfNotAvailable(); } Index: llvm/trunk/include/llvm/CodeGen/LiveInterval.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/LiveInterval.h +++ llvm/trunk/include/llvm/CodeGen/LiveInterval.h @@ -609,7 +609,7 @@ void print(raw_ostream &OS) const; void dump() const; - /// \brief Walk the range and assert if any invariants fail to hold. + /// Walk the range and assert if any invariants fail to hold. /// /// Note that this is a no-op when asserts are disabled. #ifdef NDEBUG @@ -802,7 +802,7 @@ void print(raw_ostream &OS) const; void dump() const; - /// \brief Walks the interval and assert if any invariants fail to hold. + /// Walks the interval and assert if any invariants fail to hold. /// /// Note that this is a no-op when asserts are disabled. #ifdef NDEBUG Index: llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h +++ llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h @@ -44,7 +44,7 @@ class MachineRegisterInfo; class raw_ostream; -/// \brief A set of physical registers with utility functions to track liveness +/// A set of physical registers with utility functions to track liveness /// when walking backward/forward through a basic block. class LivePhysRegs { const TargetRegisterInfo *TRI = nullptr; @@ -84,7 +84,7 @@ LiveRegs.insert(*SubRegs); } - /// \brief Removes a physical register, all its sub-registers, and all its + /// Removes a physical register, all its sub-registers, and all its /// super-registers from the set. void removeReg(unsigned Reg) { assert(TRI && "LivePhysRegs is not initialized."); @@ -98,7 +98,7 @@ SmallVectorImpl> *Clobbers = nullptr); - /// \brief Returns true if register \p Reg is contained in the set. This also + /// Returns true if register \p Reg is contained in the set. This also /// works if only the super register of \p Reg has been defined, because /// addReg() always adds all sub-registers to the set as well. /// Note: Returns false if just some sub registers are live, use available() @@ -155,7 +155,7 @@ void dump() const; private: - /// \brief Adds live-in registers from basic block \p MBB, taking associated + /// Adds live-in registers from basic block \p MBB, taking associated /// lane masks into consideration. void addBlockLiveIns(const MachineBasicBlock &MBB); @@ -169,7 +169,7 @@ return OS; } -/// \brief Computes registers live-in to \p MBB assuming all of its successors +/// Computes registers live-in to \p MBB assuming all of its successors /// live-in lists are up-to-date. Puts the result into the given LivePhysReg /// instance \p LiveRegs. void computeLiveIns(LivePhysRegs &LiveRegs, const MachineBasicBlock &MBB); Index: llvm/trunk/include/llvm/CodeGen/LiveRangeEdit.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/LiveRangeEdit.h +++ llvm/trunk/include/llvm/CodeGen/LiveRangeEdit.h @@ -117,7 +117,7 @@ /// registers are created. void MRI_NoteNewVirtualRegister(unsigned VReg) override; - /// \brief Check if MachineOperand \p MO is a last use/kill either in the + /// Check if MachineOperand \p MO is a last use/kill either in the /// main live range of \p LI or in one of the matching subregister ranges. bool useIsKill(const LiveInterval &LI, const MachineOperand &MO) const; Index: llvm/trunk/include/llvm/CodeGen/LiveRegUnits.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/LiveRegUnits.h +++ llvm/trunk/include/llvm/CodeGen/LiveRegUnits.h @@ -90,7 +90,7 @@ Units.set(*Unit); } - /// \brief Adds register units covered by physical register \p Reg that are + /// Adds register units covered by physical register \p Reg that are /// part of the lanemask \p Mask. void addRegMasked(unsigned Reg, LaneBitmask Mask) { for (MCRegUnitMaskIterator Unit(Reg, TRI); Unit.isValid(); ++Unit) { Index: llvm/trunk/include/llvm/CodeGen/LoopTraversal.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/LoopTraversal.h +++ llvm/trunk/include/llvm/CodeGen/LoopTraversal.h @@ -101,7 +101,7 @@ }; LoopTraversal() {} - /// \brief Identifies basic blocks that are part of loops and should to be + /// Identifies basic blocks that are part of loops and should to be /// visited twice and returns efficient traversal order for all the blocks. typedef SmallVector TraversalOrder; TraversalOrder traverse(MachineFunction &MF); Index: llvm/trunk/include/llvm/CodeGen/MIRParser/MIRParser.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MIRParser/MIRParser.h +++ llvm/trunk/include/llvm/CodeGen/MIRParser/MIRParser.h @@ -45,7 +45,7 @@ /// \returns nullptr if a parsing error occurred. std::unique_ptr parseIRModule(); - /// \brief Parses MachineFunctions in the MIR file and add them to the given + /// Parses MachineFunctions in the MIR file and add them to the given /// MachineModuleInfo \p MMI. /// /// \returns true if an error occurred. Index: llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h +++ llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h @@ -121,7 +121,7 @@ /// Indicate that this basic block is the entry block of a cleanup funclet. bool IsCleanupFuncletEntry = false; - /// \brief since getSymbol is a relatively heavy-weight operation, the symbol + /// since getSymbol is a relatively heavy-weight operation, the symbol /// is only computed once and is cached. mutable MCSymbol *CachedMCSymbol = nullptr; Index: llvm/trunk/include/llvm/CodeGen/MachineDominators.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineDominators.h +++ llvm/trunk/include/llvm/CodeGen/MachineDominators.h @@ -45,7 +45,7 @@ /// compute a normal dominator tree. /// class MachineDominatorTree : public MachineFunctionPass { - /// \brief Helper structure used to hold all the basic blocks + /// Helper structure used to hold all the basic blocks /// involved in the split of a critical edge. struct CriticalEdge { MachineBasicBlock *FromBB; @@ -53,12 +53,12 @@ MachineBasicBlock *NewBB; }; - /// \brief Pile up all the critical edges to be split. + /// Pile up all the critical edges to be split. /// The splitting of a critical edge is local and thus, it is possible /// to apply several of those changes at the same time. mutable SmallVector CriticalEdgesToSplit; - /// \brief Remember all the basic blocks that are inserted during + /// Remember all the basic blocks that are inserted during /// edge splitting. /// Invariant: NewBBs == all the basic blocks contained in the NewBB /// field of all the elements of CriticalEdgesToSplit. @@ -69,7 +69,7 @@ /// The DominatorTreeBase that is used to compute a normal dominator tree std::unique_ptr> DT; - /// \brief Apply all the recorded critical edges to the DT. + /// Apply all the recorded critical edges to the DT. /// This updates the underlying DT information in a way that uses /// the fast query path of DT as much as possible. /// @@ -228,7 +228,7 @@ void print(raw_ostream &OS, const Module*) const override; - /// \brief Record that the critical edge (FromBB, ToBB) has been + /// Record that the critical edge (FromBB, ToBB) has been /// split with NewBB. /// This is best to use this method instead of directly update the /// underlying information, because this helps mitigating the Index: llvm/trunk/include/llvm/CodeGen/MachineFunction.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineFunction.h +++ llvm/trunk/include/llvm/CodeGen/MachineFunction.h @@ -96,7 +96,7 @@ struct MachineFunctionInfo { virtual ~MachineFunctionInfo(); - /// \brief Factory function: default behavior is to call new using the + /// Factory function: default behavior is to call new using the /// supplied allocator. /// /// This function can be overridden in a derive class. @@ -610,7 +610,7 @@ //===--------------------------------------------------------------------===// // Internal functions used to automatically number MachineBasicBlocks - /// \brief Adds the MBB to the internal numbering. Returns the unique number + /// Adds the MBB to the internal numbering. Returns the unique number /// assigned to the MBB. unsigned addToMBBNumbering(MachineBasicBlock *MBB) { MBBNumbering.push_back(MBB); @@ -696,7 +696,7 @@ OperandRecycler.deallocate(Cap, Array); } - /// \brief Allocate and initialize a register mask with @p NumRegister bits. + /// Allocate and initialize a register mask with @p NumRegister bits. uint32_t *allocateRegisterMask(unsigned NumRegister) { unsigned Size = (NumRegister + 31) / 32; uint32_t *Mask = Allocator.Allocate(Size); Index: llvm/trunk/include/llvm/CodeGen/MachineInstr.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineInstr.h +++ llvm/trunk/include/llvm/CodeGen/MachineInstr.h @@ -576,7 +576,7 @@ return hasProperty(MCID::FoldableAsLoad, Type); } - /// \brief Return true if this instruction behaves + /// Return true if this instruction behaves /// the same way as the generic REG_SEQUENCE instructions. /// E.g., on ARM, /// dX VMOVDRR rY, rZ @@ -590,7 +590,7 @@ return hasProperty(MCID::RegSequence, Type); } - /// \brief Return true if this instruction behaves + /// Return true if this instruction behaves /// the same way as the generic EXTRACT_SUBREG instructions. /// E.g., on ARM, /// rX, rY VMOVRRD dZ @@ -605,7 +605,7 @@ return hasProperty(MCID::ExtractSubreg, Type); } - /// \brief Return true if this instruction behaves + /// Return true if this instruction behaves /// the same way as the generic INSERT_SUBREG instructions. /// E.g., on ARM, /// dX = VSETLNi32 dY, rZ, Imm @@ -1049,7 +1049,7 @@ const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const; - /// \brief Applies the constraints (def/use) implied by this MI on \p Reg to + /// Applies the constraints (def/use) implied by this MI on \p Reg to /// the given \p CurRC. /// If \p ExploreBundle is set and MI is part of a bundle, all the /// instructions inside the bundle will be taken into account. In other words, @@ -1066,7 +1066,7 @@ const TargetInstrInfo *TII, const TargetRegisterInfo *TRI, bool ExploreBundle = false) const; - /// \brief Applies the constraints (def/use) implied by the \p OpIdx operand + /// Applies the constraints (def/use) implied by the \p OpIdx operand /// to the given \p CurRC. /// /// Returns the register class that satisfies both \p CurRC and the @@ -1363,7 +1363,7 @@ /// Slow path for hasProperty when we're dealing with a bundle. bool hasPropertyInBundle(unsigned Mask, QueryType Type) const; - /// \brief Implements the logic of getRegClassConstraintEffectForVReg for the + /// Implements the logic of getRegClassConstraintEffectForVReg for the /// this MI and the given operand index \p OpIdx. /// If the related operand does not constrained Reg, this returns CurRC. const TargetRegisterClass *getRegClassConstraintEffectForVRegImpl( Index: llvm/trunk/include/llvm/CodeGen/MachineLoopInfo.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineLoopInfo.h +++ llvm/trunk/include/llvm/CodeGen/MachineLoopInfo.h @@ -54,7 +54,7 @@ /// that contains the header. MachineBasicBlock *getBottomBlock(); - /// \brief Find the block that contains the loop control variable and the + /// Find the block that contains the loop control variable and the /// loop test. This will return the latch block if it's one of the exiting /// blocks. Otherwise, return the exiting block. Return 'null' when /// multiple exiting blocks are present. @@ -97,7 +97,7 @@ LoopInfoBase& getBase() { return LI; } - /// \brief Find the block that either is the loop preheader, or could + /// Find the block that either is the loop preheader, or could /// speculatively be used as the preheader. This is e.g. useful to place /// loop setup code. Code that cannot be speculated should not be placed /// here. SpeculativePreheader is controlling whether it also tries to Index: llvm/trunk/include/llvm/CodeGen/MachineOperand.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineOperand.h +++ llvm/trunk/include/llvm/CodeGen/MachineOperand.h @@ -677,7 +677,7 @@ /// should stay in sync with the hash_value overload below. bool isIdenticalTo(const MachineOperand &Other) const; - /// \brief MachineOperand hash_value overload. + /// MachineOperand hash_value overload. /// /// Note that this includes the same information in the hash that /// isIdenticalTo uses for comparison. It is thus suited for use in hash Index: llvm/trunk/include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h +++ llvm/trunk/include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h @@ -24,7 +24,7 @@ class MachineBlockFrequencyInfo; class MachineInstr; -/// \brief Common features for diagnostics dealing with optimization remarks +/// Common features for diagnostics dealing with optimization remarks /// that are used by machine passes. class DiagnosticInfoMIROptimization : public DiagnosticInfoOptimizationBase { public: @@ -151,7 +151,7 @@ /// Emit an optimization remark. void emit(DiagnosticInfoOptimizationBase &OptDiag); - /// \brief Whether we allow for extra compile-time budget to perform more + /// Whether we allow for extra compile-time budget to perform more /// analysis to be more informative. /// /// This is useful to enable additional missed optimizations to be reported @@ -164,7 +164,7 @@ .getDiagHandlerPtr()->isAnyRemarkEnabled(PassName)); } - /// \brief Take a lambda that returns a remark which will be emitted. Second + /// Take a lambda that returns a remark which will be emitted. Second /// argument is only used to restrict this to functions. template void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) { @@ -192,7 +192,7 @@ /// Similar but use value from \p OptDiag and update hotness there. void computeHotness(DiagnosticInfoMIROptimization &Remark); - /// \brief Only allow verbose messages if we know we're filtering by hotness + /// Only allow verbose messages if we know we're filtering by hotness /// (BFI is only set in this case). bool shouldEmitVerbose() { return MBFI != nullptr; } }; Index: llvm/trunk/include/llvm/CodeGen/MachineScheduler.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MachineScheduler.h +++ llvm/trunk/include/llvm/CodeGen/MachineScheduler.h @@ -237,7 +237,7 @@ /// be scheduled at the bottom. virtual SUnit *pickNode(bool &IsTopNode) = 0; - /// \brief Scheduler callback to notify that a new subtree is scheduled. + /// Scheduler callback to notify that a new subtree is scheduled. virtual void scheduleTree(unsigned SubtreeID) {} /// Notify MachineSchedStrategy that ScheduleDAGMI has scheduled an @@ -318,11 +318,11 @@ Mutations.push_back(std::move(Mutation)); } - /// \brief True if an edge can be added from PredSU to SuccSU without creating + /// True if an edge can be added from PredSU to SuccSU without creating /// a cycle. bool canAddEdge(SUnit *SuccSU, SUnit *PredSU); - /// \brief Add a DAG edge to the given SU with the given predecessor + /// Add a DAG edge to the given SU with the given predecessor /// dependence data. /// /// \returns true if the edge may be added without creating a cycle OR if an @@ -374,7 +374,7 @@ /// Reinsert debug_values recorded in ScheduleDAGInstrs::DbgValues. void placeDebugValues(); - /// \brief dump the scheduled Sequence. + /// dump the scheduled Sequence. void dumpSchedule() const; // Lesser helpers... @@ -445,7 +445,7 @@ /// Return true if this DAG supports VReg liveness and RegPressure. bool hasVRegLiveness() const override { return true; } - /// \brief Return true if register pressure tracking is enabled. + /// Return true if register pressure tracking is enabled. bool isTrackingPressure() const { return ShouldTrackPressure; } /// Get current register pressure for the top scheduled instructions. Index: llvm/trunk/include/llvm/CodeGen/MacroFusion.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/MacroFusion.h +++ llvm/trunk/include/llvm/CodeGen/MacroFusion.h @@ -25,7 +25,7 @@ class TargetInstrInfo; class TargetSubtargetInfo; -/// \brief Check if the instr pair, FirstMI and SecondMI, should be fused +/// Check if the instr pair, FirstMI and SecondMI, should be fused /// together. Given SecondMI, when FirstMI is unspecified, then check if /// SecondMI may be part of a fused pair at all. using ShouldSchedulePredTy = std::function; -/// \brief Create a DAG scheduling mutation to pair instructions back to back +/// Create a DAG scheduling mutation to pair instructions back to back /// for instructions that benefit according to the target-specific /// shouldScheduleAdjacent predicate function. std::unique_ptr createMacroFusionDAGMutation(ShouldSchedulePredTy shouldScheduleAdjacent); -/// \brief Create a DAG scheduling mutation to pair branch instructions with one +/// Create a DAG scheduling mutation to pair branch instructions with one /// of their predecessors back to back for instructions that benefit according /// to the target-specific shouldScheduleAdjacent predicate function. std::unique_ptr Index: llvm/trunk/include/llvm/CodeGen/PBQP/Math.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/PBQP/Math.h +++ llvm/trunk/include/llvm/CodeGen/PBQP/Math.h @@ -22,34 +22,34 @@ using PBQPNum = float; -/// \brief PBQP Vector class. +/// PBQP Vector class. class Vector { friend hash_code hash_value(const Vector &); public: - /// \brief Construct a PBQP vector of the given size. + /// Construct a PBQP vector of the given size. explicit Vector(unsigned Length) : Length(Length), Data(llvm::make_unique(Length)) {} - /// \brief Construct a PBQP vector with initializer. + /// Construct a PBQP vector with initializer. Vector(unsigned Length, PBQPNum InitVal) : Length(Length), Data(llvm::make_unique(Length)) { std::fill(Data.get(), Data.get() + Length, InitVal); } - /// \brief Copy construct a PBQP vector. + /// Copy construct a PBQP vector. Vector(const Vector &V) : Length(V.Length), Data(llvm::make_unique(Length)) { std::copy(V.Data.get(), V.Data.get() + Length, Data.get()); } - /// \brief Move construct a PBQP vector. + /// Move construct a PBQP vector. Vector(Vector &&V) : Length(V.Length), Data(std::move(V.Data)) { V.Length = 0; } - /// \brief Comparison operator. + /// Comparison operator. bool operator==(const Vector &V) const { assert(Length != 0 && Data && "Invalid vector"); if (Length != V.Length) @@ -57,27 +57,27 @@ return std::equal(Data.get(), Data.get() + Length, V.Data.get()); } - /// \brief Return the length of the vector + /// Return the length of the vector unsigned getLength() const { assert(Length != 0 && Data && "Invalid vector"); return Length; } - /// \brief Element access. + /// Element access. PBQPNum& operator[](unsigned Index) { assert(Length != 0 && Data && "Invalid vector"); assert(Index < Length && "Vector element access out of bounds."); return Data[Index]; } - /// \brief Const element access. + /// Const element access. const PBQPNum& operator[](unsigned Index) const { assert(Length != 0 && Data && "Invalid vector"); assert(Index < Length && "Vector element access out of bounds."); return Data[Index]; } - /// \brief Add another vector to this one. + /// Add another vector to this one. Vector& operator+=(const Vector &V) { assert(Length != 0 && Data && "Invalid vector"); assert(Length == V.Length && "Vector length mismatch."); @@ -86,7 +86,7 @@ return *this; } - /// \brief Returns the index of the minimum value in this vector + /// Returns the index of the minimum value in this vector unsigned minIndex() const { assert(Length != 0 && Data && "Invalid vector"); return std::min_element(Data.get(), Data.get() + Length) - Data.get(); @@ -97,14 +97,14 @@ std::unique_ptr Data; }; -/// \brief Return a hash_value for the given vector. +/// Return a hash_value for the given vector. inline hash_code hash_value(const Vector &V) { unsigned *VBegin = reinterpret_cast(V.Data.get()); unsigned *VEnd = reinterpret_cast(V.Data.get() + V.Length); return hash_combine(V.Length, hash_combine_range(VBegin, VEnd)); } -/// \brief Output a textual representation of the given vector on the given +/// Output a textual representation of the given vector on the given /// output stream. template OStream& operator<<(OStream &OS, const Vector &V) { @@ -118,18 +118,18 @@ return OS; } -/// \brief PBQP Matrix class +/// PBQP Matrix class class Matrix { private: friend hash_code hash_value(const Matrix &); public: - /// \brief Construct a PBQP Matrix with the given dimensions. + /// Construct a PBQP Matrix with the given dimensions. Matrix(unsigned Rows, unsigned Cols) : Rows(Rows), Cols(Cols), Data(llvm::make_unique(Rows * Cols)) { } - /// \brief Construct a PBQP Matrix with the given dimensions and initial + /// Construct a PBQP Matrix with the given dimensions and initial /// value. Matrix(unsigned Rows, unsigned Cols, PBQPNum InitVal) : Rows(Rows), Cols(Cols), @@ -137,20 +137,20 @@ std::fill(Data.get(), Data.get() + (Rows * Cols), InitVal); } - /// \brief Copy construct a PBQP matrix. + /// Copy construct a PBQP matrix. Matrix(const Matrix &M) : Rows(M.Rows), Cols(M.Cols), Data(llvm::make_unique(Rows * Cols)) { std::copy(M.Data.get(), M.Data.get() + (Rows * Cols), Data.get()); } - /// \brief Move construct a PBQP matrix. + /// Move construct a PBQP matrix. Matrix(Matrix &&M) : Rows(M.Rows), Cols(M.Cols), Data(std::move(M.Data)) { M.Rows = M.Cols = 0; } - /// \brief Comparison operator. + /// Comparison operator. bool operator==(const Matrix &M) const { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); if (Rows != M.Rows || Cols != M.Cols) @@ -158,33 +158,33 @@ return std::equal(Data.get(), Data.get() + (Rows * Cols), M.Data.get()); } - /// \brief Return the number of rows in this matrix. + /// Return the number of rows in this matrix. unsigned getRows() const { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); return Rows; } - /// \brief Return the number of cols in this matrix. + /// Return the number of cols in this matrix. unsigned getCols() const { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); return Cols; } - /// \brief Matrix element access. + /// Matrix element access. PBQPNum* operator[](unsigned R) { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); assert(R < Rows && "Row out of bounds."); return Data.get() + (R * Cols); } - /// \brief Matrix element access. + /// Matrix element access. const PBQPNum* operator[](unsigned R) const { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); assert(R < Rows && "Row out of bounds."); return Data.get() + (R * Cols); } - /// \brief Returns the given row as a vector. + /// Returns the given row as a vector. Vector getRowAsVector(unsigned R) const { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); Vector V(Cols); @@ -193,7 +193,7 @@ return V; } - /// \brief Returns the given column as a vector. + /// Returns the given column as a vector. Vector getColAsVector(unsigned C) const { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); Vector V(Rows); @@ -202,7 +202,7 @@ return V; } - /// \brief Matrix transpose. + /// Matrix transpose. Matrix transpose() const { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); Matrix M(Cols, Rows); @@ -212,7 +212,7 @@ return M; } - /// \brief Add the given matrix to this one. + /// Add the given matrix to this one. Matrix& operator+=(const Matrix &M) { assert(Rows != 0 && Cols != 0 && Data && "Invalid matrix"); assert(Rows == M.Rows && Cols == M.Cols && @@ -234,7 +234,7 @@ std::unique_ptr Data; }; -/// \brief Return a hash_code for the given matrix. +/// Return a hash_code for the given matrix. inline hash_code hash_value(const Matrix &M) { unsigned *MBegin = reinterpret_cast(M.Data.get()); unsigned *MEnd = @@ -242,7 +242,7 @@ return hash_combine(M.Rows, M.Cols, hash_combine_range(MBegin, MEnd)); } -/// \brief Output a textual representation of the given matrix on the given +/// Output a textual representation of the given matrix on the given /// output stream. template OStream& operator<<(OStream &OS, const Matrix &M) { Index: llvm/trunk/include/llvm/CodeGen/PBQP/ReductionRules.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/PBQP/ReductionRules.h +++ llvm/trunk/include/llvm/CodeGen/PBQP/ReductionRules.h @@ -23,7 +23,7 @@ namespace llvm { namespace PBQP { - /// \brief Reduce a node of degree one. + /// Reduce a node of degree one. /// /// Propagate costs from the given node, which must be of degree one, to its /// neighbor. Notify the problem domain. @@ -166,7 +166,7 @@ } #endif - // \brief Find a solution to a fully reduced graph by backpropagation. + // Find a solution to a fully reduced graph by backpropagation. // // Given a graph and a reduction order, pop each node from the reduction // order and greedily compute a minimum solution based on the node costs, and Index: llvm/trunk/include/llvm/CodeGen/PBQP/Solution.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/PBQP/Solution.h +++ llvm/trunk/include/llvm/CodeGen/PBQP/Solution.h @@ -21,7 +21,7 @@ namespace llvm { namespace PBQP { - /// \brief Represents a solution to a PBQP problem. + /// Represents a solution to a PBQP problem. /// /// To get the selection for each node in the problem use the getSelection method. class Solution { @@ -30,17 +30,17 @@ SelectionsMap selections; public: - /// \brief Initialise an empty solution. + /// Initialise an empty solution. Solution() = default; - /// \brief Set the selection for a given node. + /// Set the selection for a given node. /// @param nodeId Node id. /// @param selection Selection for nodeId. void setSelection(GraphBase::NodeId nodeId, unsigned selection) { selections[nodeId] = selection; } - /// \brief Get a node's selection. + /// Get a node's selection. /// @param nodeId Node id. /// @return The selection for nodeId; unsigned getSelection(GraphBase::NodeId nodeId) const { Index: llvm/trunk/include/llvm/CodeGen/Passes.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/Passes.h +++ llvm/trunk/include/llvm/CodeGen/Passes.h @@ -301,7 +301,7 @@ /// StackSlotColoring - This pass performs stack slot coloring. extern char &StackSlotColoringID; - /// \brief This pass lays out funclets contiguously. + /// This pass lays out funclets contiguously. extern char &FuncletLayoutID; /// This pass inserts the XRay instrumentation sleds if they are supported by @@ -311,7 +311,7 @@ /// This pass inserts FEntry calls extern char &FEntryInserterID; - /// \brief This pass implements the "patchable-function" attribute. + /// This pass implements the "patchable-function" attribute. extern char &PatchableFunctionID; /// createStackProtectorPass - This pass adds stack protectors to functions. Index: llvm/trunk/include/llvm/CodeGen/RegAllocPBQP.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/RegAllocPBQP.h +++ llvm/trunk/include/llvm/CodeGen/RegAllocPBQP.h @@ -46,7 +46,7 @@ /// @brief Spill option index. inline unsigned getSpillOptionIdx() { return 0; } -/// \brief Metadata to speed allocatability test. +/// Metadata to speed allocatability test. /// /// Keeps track of the number of infinities in each row and column. class MatrixMetadata { @@ -89,7 +89,7 @@ std::unique_ptr UnsafeCols; }; -/// \brief Holds a vector of the allowed physical regs for a vreg. +/// Holds a vector of the allowed physical regs for a vreg. class AllowedRegVector { friend hash_code hash_value(const AllowedRegVector &); @@ -127,7 +127,7 @@ hash_combine_range(OStart, OEnd)); } -/// \brief Holds graph-level metadata relevant to PBQP RA problems. +/// Holds graph-level metadata relevant to PBQP RA problems. class GraphMetadata { private: using AllowedRegVecPool = ValuePool; @@ -164,7 +164,7 @@ AllowedRegVecPool AllowedRegVecs; }; -/// \brief Holds solver state and other metadata relevant to each PBQP RA node. +/// Holds solver state and other metadata relevant to each PBQP RA node. class NodeMetadata { public: using AllowedRegVector = RegAlloc::AllowedRegVector; Index: llvm/trunk/include/llvm/CodeGen/RegisterPressure.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/RegisterPressure.h +++ llvm/trunk/include/llvm/CodeGen/RegisterPressure.h @@ -171,10 +171,10 @@ public: /// List of virtual registers and register units read by the instruction. SmallVector Uses; - /// \brief List of virtual registers and register units defined by the + /// List of virtual registers and register units defined by the /// instruction which are not dead. SmallVector Defs; - /// \brief List of virtual registers and register units defined by the + /// List of virtual registers and register units defined by the /// instruction but dead. SmallVector DeadDefs; @@ -219,7 +219,7 @@ return const_cast(this)->operator[](Idx); } - /// \brief Record pressure difference induced by the given operand list to + /// Record pressure difference induced by the given operand list to /// node with index \p Idx. void addInstruction(unsigned Idx, const RegisterOperands &RegOpers, const MachineRegisterInfo &MRI); @@ -546,7 +546,7 @@ /// Add Reg to the live in set and increase max pressure. void discoverLiveIn(RegisterMaskPair Pair); - /// \brief Get the SlotIndex for the first nondebug instruction including or + /// Get the SlotIndex for the first nondebug instruction including or /// after the current position. SlotIndex getCurrSlot() const; Index: llvm/trunk/include/llvm/CodeGen/ScheduleDAG.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/ScheduleDAG.h +++ llvm/trunk/include/llvm/CodeGen/ScheduleDAG.h @@ -76,7 +76,7 @@ }; private: - /// \brief A pointer to the depending/depended-on SUnit, and an enum + /// A pointer to the depending/depended-on SUnit, and an enum /// indicating the kind of the dependency. PointerIntPair Dep; @@ -137,7 +137,7 @@ return !operator==(Other); } - /// \brief Returns the latency value for this edge, which roughly means the + /// Returns the latency value for this edge, which roughly means the /// minimum number of cycles that must elapse between the predecessor and /// the successor, given that they have this edge between them. unsigned getLatency() const { @@ -163,7 +163,7 @@ return getKind() != Data; } - /// \brief Tests if this is an Order dependence between two memory accesses + /// Tests if this is an Order dependence between two memory accesses /// where both sides of the dependence access memory in non-volatile and /// fully modeled ways. bool isNormalMemory() const { @@ -181,7 +181,7 @@ return (isNormalMemory() || isBarrier()); } - /// \brief Tests if this is an Order dependence that is marked as + /// Tests if this is an Order dependence that is marked as /// "must alias", meaning that the SUnits at either end of the edge have a /// memory dependence on a known memory location. bool isMustAlias() const { @@ -196,13 +196,13 @@ return getKind() == Order && Contents.OrdKind >= Weak; } - /// \brief Tests if this is an Order dependence that is marked as + /// Tests if this is an Order dependence that is marked as /// "artificial", meaning it isn't necessary for correctness. bool isArtificial() const { return getKind() == Order && Contents.OrdKind == Artificial; } - /// \brief Tests if this is an Order dependence that is marked as "cluster", + /// Tests if this is an Order dependence that is marked as "cluster", /// meaning it is artificial and wants to be adjacent. bool isCluster() const { return getKind() == Order && Contents.OrdKind == Cluster; @@ -308,7 +308,7 @@ nullptr; ///< Is a special copy node if != nullptr. const TargetRegisterClass *CopySrcRC = nullptr; - /// \brief Constructs an SUnit for pre-regalloc scheduling to represent an + /// Constructs an SUnit for pre-regalloc scheduling to represent an /// SDNode and any nodes flagged to it. SUnit(SDNode *node, unsigned nodenum) : Node(node), NodeNum(nodenum), isVRegCycle(false), isCall(false), @@ -319,7 +319,7 @@ isUnbuffered(false), hasReservedResource(false), isDepthCurrent(false), isHeightCurrent(false) {} - /// \brief Constructs an SUnit for post-regalloc scheduling to represent a + /// Constructs an SUnit for post-regalloc scheduling to represent a /// MachineInstr. SUnit(MachineInstr *instr, unsigned nodenum) : Instr(instr), NodeNum(nodenum), isVRegCycle(false), isCall(false), @@ -330,7 +330,7 @@ isUnbuffered(false), hasReservedResource(false), isDepthCurrent(false), isHeightCurrent(false) {} - /// \brief Constructs a placeholder SUnit. + /// Constructs a placeholder SUnit. SUnit() : isVRegCycle(false), isCall(false), isCallOp(false), isTwoAddress(false), isCommutable(false), hasPhysRegUses(false), hasPhysRegDefs(false), @@ -339,7 +339,7 @@ isCloned(false), isUnbuffered(false), hasReservedResource(false), isDepthCurrent(false), isHeightCurrent(false) {} - /// \brief Boundary nodes are placeholders for the boundary of the + /// Boundary nodes are placeholders for the boundary of the /// scheduling region. /// /// BoundaryNodes can have DAG edges, including Data edges, but they do not @@ -362,7 +362,7 @@ return Node; } - /// \brief Returns true if this SUnit refers to a machine instruction as + /// Returns true if this SUnit refers to a machine instruction as /// opposed to an SDNode. bool isInstr() const { return Instr; } @@ -384,7 +384,7 @@ /// It also adds the current node as a successor of the specified node. bool addPred(const SDep &D, bool Required = true); - /// \brief Adds a barrier edge to SU by calling addPred(), with latency 0 + /// Adds a barrier edge to SU by calling addPred(), with latency 0 /// generally or latency 1 for a store followed by a load. bool addPredBarrier(SUnit *SU) { SDep Dep(SU, SDep::Barrier); @@ -406,7 +406,7 @@ return Depth; } - /// \brief Returns the height of this node, which is the length of the + /// Returns the height of this node, which is the length of the /// maximum path down to any node which has no successors. unsigned getHeight() const { if (!isHeightCurrent) @@ -414,21 +414,21 @@ return Height; } - /// \brief If NewDepth is greater than this node's depth value, sets it to + /// If NewDepth is greater than this node's depth value, sets it to /// be the new depth value. This also recursively marks successor nodes /// dirty. void setDepthToAtLeast(unsigned NewDepth); - /// \brief If NewDepth is greater than this node's depth value, set it to be + /// If NewDepth is greater than this node's depth value, set it to be /// the new height value. This also recursively marks predecessor nodes /// dirty. void setHeightToAtLeast(unsigned NewHeight); - /// \brief Sets a flag in this node to indicate that its stored Depth value + /// Sets a flag in this node to indicate that its stored Depth value /// will require recomputation the next time getDepth() is called. void setDepthDirty(); - /// \brief Sets a flag in this node to indicate that its stored Height value + /// Sets a flag in this node to indicate that its stored Height value /// will require recomputation the next time getHeight() is called. void setHeightDirty(); @@ -455,7 +455,7 @@ return NumSuccsLeft == 0; } - /// \brief Orders this node's predecessor edges such that the critical path + /// Orders this node's predecessor edges such that the critical path /// edge occurs first. void biasCriticalPath(); @@ -497,7 +497,7 @@ //===--------------------------------------------------------------------===// - /// \brief This interface is used to plug different priorities computation + /// This interface is used to plug different priorities computation /// algorithms into the list scheduler. It implements the interface of a /// standard priority queue, where nodes are inserted in arbitrary order and /// returned in priority order. The computation of the priority and the @@ -609,7 +609,7 @@ virtual void addCustomGraphFeatures(GraphWriter &) const {} #ifndef NDEBUG - /// \brief Verifies that all SUnits were scheduled and that their state is + /// Verifies that all SUnits were scheduled and that their state is /// consistent. Returns the number of scheduled SUnits. unsigned VerifyScheduledDAG(bool isBottomUp); #endif @@ -708,7 +708,7 @@ /// method. void DFS(const SUnit *SU, int UpperBound, bool& HasLoop); - /// \brief Reassigns topological indexes for the nodes in the DAG to + /// Reassigns topological indexes for the nodes in the DAG to /// preserve the topological ordering. void Shift(BitVector& Visited, int LowerBound, int UpperBound); @@ -735,11 +735,11 @@ /// Returns true if addPred(TargetSU, SU) creates a cycle. bool WillCreateCycle(SUnit *TargetSU, SUnit *SU); - /// \brief Updates the topological ordering to accommodate an edge to be + /// Updates the topological ordering to accommodate an edge to be /// added from SUnit \p X to SUnit \p Y. void AddPred(SUnit *Y, SUnit *X); - /// \brief Updates the topological ordering to accommodate an an edge to be + /// Updates the topological ordering to accommodate an an edge to be /// removed from the specified node \p N from the predecessors of the /// current node \p M. void RemovePred(SUnit *M, SUnit *N); Index: llvm/trunk/include/llvm/CodeGen/ScheduleDAGInstrs.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/ScheduleDAGInstrs.h +++ llvm/trunk/include/llvm/CodeGen/ScheduleDAGInstrs.h @@ -190,7 +190,7 @@ using SUList = std::list; protected: - /// \brief A map from ValueType to SUList, used during DAG construction, as + /// A map from ValueType to SUList, used during DAG construction, as /// a means of remembering which SUs depend on which memory locations. class Value2SUsMap; @@ -201,7 +201,7 @@ void reduceHugeMemNodeMaps(Value2SUsMap &stores, Value2SUsMap &loads, unsigned N); - /// \brief Adds a chain edge between SUa and SUb, but only if both + /// Adds a chain edge between SUa and SUb, but only if both /// AliasAnalysis and Target fail to deny the dependency. void addChainDependency(SUnit *SUa, SUnit *SUb, unsigned Latency = 0); @@ -286,7 +286,7 @@ /// Cleans up after scheduling in the given block. virtual void finishBlock(); - /// \brief Initialize the DAG and common scheduler state for a new + /// Initialize the DAG and common scheduler state for a new /// scheduling region. This does not actually create the DAG, only clears /// it. The scheduling driver may call BuildSchedGraph multiple times per /// scheduling region. @@ -308,7 +308,7 @@ LiveIntervals *LIS = nullptr, bool TrackLaneMasks = false); - /// \brief Adds dependencies from instructions in the current list of + /// Adds dependencies from instructions in the current list of /// instructions being scheduled to scheduling barrier. We want to make sure /// instructions which define registers that are either used by the /// terminator or are live-out are properly scheduled. This is especially Index: llvm/trunk/include/llvm/CodeGen/ScheduleDFS.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/ScheduleDFS.h +++ llvm/trunk/include/llvm/CodeGen/ScheduleDFS.h @@ -25,7 +25,7 @@ class raw_ostream; -/// \brief Represent the ILP of the subDAG rooted at a DAG node. +/// Represent the ILP of the subDAG rooted at a DAG node. /// /// ILPValues summarize the DAG subtree rooted at each node. ILPValues are /// valid for all nodes regardless of their subtree membership. @@ -62,13 +62,13 @@ void dump() const; }; -/// \brief Compute the values of each DAG node for various metrics during DFS. +/// Compute the values of each DAG node for various metrics during DFS. class SchedDFSResult { friend class SchedDFSImpl; static const unsigned InvalidSubtreeID = ~0u; - /// \brief Per-SUnit data computed during DFS for various metrics. + /// Per-SUnit data computed during DFS for various metrics. /// /// A node's SubtreeID is set to itself when it is visited to indicate that it /// is the root of a subtree. Later it is set to its parent to indicate an @@ -81,7 +81,7 @@ NodeData() = default; }; - /// \brief Per-Subtree data computed during DFS. + /// Per-Subtree data computed during DFS. struct TreeData { unsigned ParentTreeID = InvalidSubtreeID; unsigned SubInstrCount = 0; @@ -89,7 +89,7 @@ TreeData() = default; }; - /// \brief Record a connection between subtrees and the connection level. + /// Record a connection between subtrees and the connection level. struct Connection { unsigned TreeID; unsigned Level; @@ -117,15 +117,15 @@ SchedDFSResult(bool IsBU, unsigned lim) : IsBottomUp(IsBU), SubtreeLimit(lim) {} - /// \brief Get the node cutoff before subtrees are considered significant. + /// Get the node cutoff before subtrees are considered significant. unsigned getSubtreeLimit() const { return SubtreeLimit; } - /// \brief Return true if this DFSResult is uninitialized. + /// Return true if this DFSResult is uninitialized. /// /// resize() initializes DFSResult, while compute() populates it. bool empty() const { return DFSNodeData.empty(); } - /// \brief Clear the results. + /// Clear the results. void clear() { DFSNodeData.clear(); DFSTreeData.clear(); @@ -133,37 +133,37 @@ SubtreeConnectLevels.clear(); } - /// \brief Initialize the result data with the size of the DAG. + /// Initialize the result data with the size of the DAG. void resize(unsigned NumSUnits) { DFSNodeData.resize(NumSUnits); } - /// \brief Compute various metrics for the DAG with given roots. + /// Compute various metrics for the DAG with given roots. void compute(ArrayRef SUnits); - /// \brief Get the number of instructions in the given subtree and its + /// Get the number of instructions in the given subtree and its /// children. unsigned getNumInstrs(const SUnit *SU) const { return DFSNodeData[SU->NodeNum].InstrCount; } - /// \brief Get the number of instructions in the given subtree not including + /// Get the number of instructions in the given subtree not including /// children. unsigned getNumSubInstrs(unsigned SubtreeID) const { return DFSTreeData[SubtreeID].SubInstrCount; } - /// \brief Get the ILP value for a DAG node. + /// Get the ILP value for a DAG node. /// /// A leaf node has an ILP of 1/1. ILPValue getILP(const SUnit *SU) const { return ILPValue(DFSNodeData[SU->NodeNum].InstrCount, 1 + SU->getDepth()); } - /// \brief The number of subtrees detected in this DAG. + /// The number of subtrees detected in this DAG. unsigned getNumSubtrees() const { return SubtreeConnectLevels.size(); } - /// \brief Get the ID of the subtree the given DAG node belongs to. + /// Get the ID of the subtree the given DAG node belongs to. /// /// For convenience, if DFSResults have not been computed yet, give everything /// tree ID 0. @@ -174,7 +174,7 @@ return DFSNodeData[SU->NodeNum].SubtreeID; } - /// \brief Get the connection level of a subtree. + /// Get the connection level of a subtree. /// /// For bottom-up trees, the connection level is the latency depth (in cycles) /// of the deepest connection to another subtree. @@ -182,7 +182,7 @@ return SubtreeConnectLevels[SubtreeID]; } - /// \brief Scheduler callback to update SubtreeConnectLevels when a tree is + /// Scheduler callback to update SubtreeConnectLevels when a tree is /// initially scheduled. void scheduleTree(unsigned SubtreeID); }; Index: llvm/trunk/include/llvm/CodeGen/SelectionDAG.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/SelectionDAG.h +++ llvm/trunk/include/llvm/CodeGen/SelectionDAG.h @@ -164,7 +164,7 @@ DbgValMap[Node].push_back(V); } - /// \brief Invalidate all DbgValues attached to the node and remove + /// Invalidate all DbgValues attached to the node and remove /// it from the Node-to-DbgValues map. void erase(const SDNode *Node); @@ -486,7 +486,7 @@ /// the graph. void Legalize(); - /// \brief Transforms a SelectionDAG node and any operands to it into a node + /// Transforms a SelectionDAG node and any operands to it into a node /// that is compatible with the target instruction selector, as indicated by /// the TargetLowering object. /// @@ -537,7 +537,7 @@ //===--------------------------------------------------------------------===// // Node creation methods. - /// \brief Create a ConstantSDNode wrapping a constant value. + /// Create a ConstantSDNode wrapping a constant value. /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR. /// /// If only legal types can be produced, this does the necessary @@ -571,12 +571,12 @@ return getConstant(Val, DL, VT, true, isOpaque); } - /// \brief Create a true or false constant of type \p VT using the target's + /// Create a true or false constant of type \p VT using the target's /// BooleanContent for type \p OpVT. SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT); /// @} - /// \brief Create a ConstantFPSDNode wrapping a constant value. + /// Create a ConstantFPSDNode wrapping a constant value. /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR. /// /// If only legal types can be produced, this does the necessary @@ -748,7 +748,7 @@ return getNode(ISD::BUILD_VECTOR, DL, VT, Ops); } - /// \brief Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to + /// Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to /// the shuffle node in input but with swapped operands. /// /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3> @@ -800,10 +800,10 @@ /// Create a bitwise NOT operation as (XOR Val, -1). SDValue getNOT(const SDLoc &DL, SDValue Val, EVT VT); - /// \brief Create a logical NOT operation as (XOR Val, BooleanOne). + /// Create a logical NOT operation as (XOR Val, BooleanOne). SDValue getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT); - /// \brief Create an add instruction with appropriate flags when used for + /// Create an add instruction with appropriate flags when used for /// addressing some offset of an object. i.e. if a load is split into multiple /// components, create an add nuw from the base pointer to the offset. SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Op, int64_t Offset) { Index: llvm/trunk/include/llvm/CodeGen/SelectionDAGISel.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/SelectionDAGISel.h +++ llvm/trunk/include/llvm/CodeGen/SelectionDAGISel.h @@ -280,7 +280,7 @@ void SelectCodeCommon(SDNode *NodeToMatch, const unsigned char *MatcherTable, unsigned TableSize); - /// \brief Return true if complex patterns for this target can mutate the + /// Return true if complex patterns for this target can mutate the /// DAG. virtual bool ComplexPatternFuncMutatesDAG() const { return false; @@ -309,10 +309,10 @@ /// instruction selected, false if no code should be emitted for it. bool PrepareEHLandingPad(); - /// \brief Perform instruction selection on all basic blocks in the function. + /// Perform instruction selection on all basic blocks in the function. void SelectAllBasicBlocks(const Function &Fn); - /// \brief Perform instruction selection on a single basic block, for + /// Perform instruction selection on a single basic block, for /// instructions between \p Begin and \p End. \p HadTailCall will be set /// to true if a call in the block was translated as a tail call. void SelectBasicBlock(BasicBlock::const_iterator Begin, @@ -322,7 +322,7 @@ void CodeGenAndEmitDAG(); - /// \brief Generate instructions for lowering the incoming arguments of the + /// Generate instructions for lowering the incoming arguments of the /// given function. void LowerArguments(const Function &F); Index: llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h +++ llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h @@ -1765,13 +1765,13 @@ unsigned MinSplatBits = 0, bool isBigEndian = false) const; - /// \brief Returns the splatted value or a null value if this is not a splat. + /// Returns the splatted value or a null value if this is not a splat. /// /// If passed a non-null UndefElements bitvector, it will resize it to match /// the vector width and set the bits where elements are undef. SDValue getSplatValue(BitVector *UndefElements = nullptr) const; - /// \brief Returns the splatted constant or null if this is not a constant + /// Returns the splatted constant or null if this is not a constant /// splat. /// /// If passed a non-null UndefElements bitvector, it will resize it to match @@ -1779,7 +1779,7 @@ ConstantSDNode * getConstantSplatNode(BitVector *UndefElements = nullptr) const; - /// \brief Returns the splatted constant FP or null if this is not a constant + /// Returns the splatted constant FP or null if this is not a constant /// FP splat. /// /// If passed a non-null UndefElements bitvector, it will resize it to match @@ -1787,7 +1787,7 @@ ConstantFPSDNode * getConstantFPSplatNode(BitVector *UndefElements = nullptr) const; - /// \brief If this is a constant FP splat and the splatted constant FP is an + /// If this is a constant FP splat and the splatted constant FP is an /// exact power or 2, return the log base 2 integer value. Otherwise, /// return -1. /// Index: llvm/trunk/include/llvm/CodeGen/SlotIndexes.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/SlotIndexes.h +++ llvm/trunk/include/llvm/CodeGen/SlotIndexes.h @@ -677,7 +677,7 @@ llvm::sort(idx2MBBMap.begin(), idx2MBBMap.end(), Idx2MBBCompare()); } - /// \brief Free the resources that were required to maintain a SlotIndex. + /// Free the resources that were required to maintain a SlotIndex. /// /// Once an index is no longer needed (for instance because the instruction /// at that index has been moved), the resources required to maintain the Index: llvm/trunk/include/llvm/CodeGen/StackMaps.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/StackMaps.h +++ llvm/trunk/include/llvm/CodeGen/StackMaps.h @@ -29,7 +29,7 @@ class raw_ostream; class TargetRegisterInfo; -/// \brief MI-level stackmap operands. +/// MI-level stackmap operands. /// /// MI stackmap operations take the form: /// , , live args... @@ -60,7 +60,7 @@ } }; -/// \brief MI-level patchpoint operands. +/// MI-level patchpoint operands. /// /// MI patchpoint operations take the form: /// [], , , , , , ... @@ -137,7 +137,7 @@ return getVarIdx(); } - /// \brief Get the next scratch register operand index. + /// Get the next scratch register operand index. unsigned getNextScratchIdx(unsigned StartIdx = 0) const; }; @@ -236,15 +236,15 @@ FnInfos.clear(); } - /// \brief Generate a stackmap record for a stackmap instruction. + /// Generate a stackmap record for a stackmap instruction. /// /// MI must be a raw STACKMAP, not a PATCHPOINT. void recordStackMap(const MachineInstr &MI); - /// \brief Generate a stackmap record for a patchpoint instruction. + /// Generate a stackmap record for a patchpoint instruction. void recordPatchPoint(const MachineInstr &MI); - /// \brief Generate a stackmap record for a statepoint instruction. + /// Generate a stackmap record for a statepoint instruction. void recordStatepoint(const MachineInstr &MI); /// If there is any stack map data, create a stack map section and serialize @@ -293,11 +293,11 @@ MachineInstr::const_mop_iterator MOE, LocationVec &Locs, LiveOutVec &LiveOuts) const; - /// \brief Create a live-out register record for the given register @p Reg. + /// Create a live-out register record for the given register @p Reg. LiveOutReg createLiveOutReg(unsigned Reg, const TargetRegisterInfo *TRI) const; - /// \brief Parse the register live-out mask and return a vector of live-out + /// Parse the register live-out mask and return a vector of live-out /// registers that need to be recorded in the stackmap. LiveOutVec parseRegisterLiveOutMask(const uint32_t *Mask) const; @@ -311,16 +311,16 @@ MachineInstr::const_mop_iterator MOE, bool recordResult = false); - /// \brief Emit the stackmap header. + /// Emit the stackmap header. void emitStackmapHeader(MCStreamer &OS); - /// \brief Emit the function frame record for each function. + /// Emit the function frame record for each function. void emitFunctionFrameRecords(MCStreamer &OS); - /// \brief Emit the constant pool. + /// Emit the constant pool. void emitConstantPoolEntries(MCStreamer &OS); - /// \brief Emit the callsite info for each stackmap/patchpoint intrinsic call. + /// Emit the callsite info for each stackmap/patchpoint intrinsic call. void emitCallsiteEntries(MCStreamer &OS); void print(raw_ostream &OS); Index: llvm/trunk/include/llvm/CodeGen/StackProtector.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/StackProtector.h +++ llvm/trunk/include/llvm/CodeGen/StackProtector.h @@ -70,7 +70,7 @@ /// AllocaInst triggers a stack protector. SSPLayoutMap Layout; - /// \brief The minimum size of buffers that will receive stack smashing + /// The minimum size of buffers that will receive stack smashing /// protection when -fstack-protection is used. unsigned SSPBufferSize = 0; @@ -107,7 +107,7 @@ bool ContainsProtectableArray(Type *Ty, bool &IsLarge, bool Strong = false, bool InStruct = false) const; - /// \brief Check whether a stack allocation has its address taken. + /// Check whether a stack allocation has its address taken. bool HasAddressTaken(const Instruction *AI); /// RequiresStackProtector - Check whether or not this function needs a Index: llvm/trunk/include/llvm/CodeGen/TargetInstrInfo.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/TargetInstrInfo.h +++ llvm/trunk/include/llvm/CodeGen/TargetInstrInfo.h @@ -348,7 +348,7 @@ unsigned SubIdx, const MachineInstr &Orig, const TargetRegisterInfo &TRI) const; - /// \brief Clones instruction or the whole instruction bundle \p Orig and + /// Clones instruction or the whole instruction bundle \p Orig and /// insert into \p MBB before \p InsertBefore. The target may update operands /// that are required to be unique. /// @@ -1006,7 +1006,7 @@ return nullptr; } - /// \brief Target-dependent implementation of getRegSequenceInputs. + /// Target-dependent implementation of getRegSequenceInputs. /// /// \returns true if it is possible to build the equivalent /// REG_SEQUENCE inputs with the pair \p MI, \p DefIdx. False otherwise. @@ -1020,7 +1020,7 @@ return false; } - /// \brief Target-dependent implementation of getExtractSubregInputs. + /// Target-dependent implementation of getExtractSubregInputs. /// /// \returns true if it is possible to build the equivalent /// EXTRACT_SUBREG inputs with the pair \p MI, \p DefIdx. False otherwise. @@ -1034,7 +1034,7 @@ return false; } - /// \brief Target-dependent implementation of getInsertSubregInputs. + /// Target-dependent implementation of getInsertSubregInputs. /// /// \returns true if it is possible to build the equivalent /// INSERT_SUBREG inputs with the pair \p MI, \p DefIdx. False otherwise. @@ -1456,7 +1456,7 @@ return 0; } - /// \brief Return the minimum clearance before an instruction that reads an + /// Return the minimum clearance before an instruction that reads an /// unused register. /// /// For example, AVX instructions may copy part of a register operand into @@ -1523,7 +1523,7 @@ return false; } - /// \brief Return the value to use for the MachineCSE's LookAheadLimit, + /// Return the value to use for the MachineCSE's LookAheadLimit, /// which is a heuristic used for CSE'ing phys reg defs. virtual unsigned getMachineCSELookAheadLimit() const { // The default lookahead is small to prevent unprofitable quadratic @@ -1595,21 +1595,21 @@ /// Returns true if the target implements the MachineOutliner. virtual bool useMachineOutliner() const { return false; } - /// \brief Describes the number of instructions that it will take to call and + /// Describes the number of instructions that it will take to call and /// construct a frame for a given outlining candidate. struct MachineOutlinerInfo { /// Number of instructions to call an outlined function for this candidate. unsigned CallOverhead; - /// \brief Number of instructions to construct an outlined function frame + /// Number of instructions to construct an outlined function frame /// for this candidate. unsigned FrameOverhead; - /// \brief Represents the specific instructions that must be emitted to + /// Represents the specific instructions that must be emitted to /// construct a call to this candidate. unsigned CallConstructionID; - /// \brief Represents the specific instructions that must be emitted to + /// Represents the specific instructions that must be emitted to /// construct a frame for this candidate's outlined function. unsigned FrameConstructionID; @@ -1622,7 +1622,7 @@ FrameConstructionID(FrameConstructionID) {} }; - /// \brief Returns a \p MachineOutlinerInfo struct containing target-specific + /// Returns a \p MachineOutlinerInfo struct containing target-specific /// information for a set of outlining candidates. virtual MachineOutlinerInfo getOutlininingCandidateInfo( std::vector< @@ -1646,7 +1646,7 @@ "Target didn't implement TargetInstrInfo::getOutliningType!"); } - /// \brief Returns target-defined flags defining properties of the MBB for + /// Returns target-defined flags defining properties of the MBB for /// the outliner. virtual unsigned getMachineOutlinerMBBFlags(MachineBasicBlock &MBB) const { return 0x0; @@ -1698,7 +1698,7 @@ unsigned ReturnOpcode; }; -/// \brief Provide DenseMapInfo for TargetInstrInfo::RegSubRegPair. +/// Provide DenseMapInfo for TargetInstrInfo::RegSubRegPair. template <> struct DenseMapInfo { using RegInfo = DenseMapInfo; @@ -1712,7 +1712,7 @@ RegInfo::getTombstoneKey()); } - /// \brief Reuse getHashValue implementation from + /// Reuse getHashValue implementation from /// std::pair. static unsigned getHashValue(const TargetInstrInfo::RegSubRegPair &Val) { std::pair PairVal = std::make_pair(Val.Reg, Val.SubReg); Index: llvm/trunk/include/llvm/CodeGen/TargetLowering.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/TargetLowering.h +++ llvm/trunk/include/llvm/CodeGen/TargetLowering.h @@ -223,7 +223,7 @@ virtual ~TargetLoweringBase() = default; protected: - /// \brief Initialize all of the actions to default values. + /// Initialize all of the actions to default values. void initActions(); public: @@ -423,17 +423,17 @@ return true; } - /// \brief Return true if it is cheap to speculate a call to intrinsic cttz. + /// Return true if it is cheap to speculate a call to intrinsic cttz. virtual bool isCheapToSpeculateCttz() const { return false; } - /// \brief Return true if it is cheap to speculate a call to intrinsic ctlz. + /// Return true if it is cheap to speculate a call to intrinsic ctlz. virtual bool isCheapToSpeculateCtlz() const { return false; } - /// \brief Return true if ctlz instruction is fast. + /// Return true if ctlz instruction is fast. virtual bool isCtlzFast() const { return false; } @@ -446,13 +446,13 @@ return false; } - /// \brief Return true if it is cheaper to split the store of a merged int val + /// Return true if it is cheaper to split the store of a merged int val /// from a pair of smaller values into multiple stores. virtual bool isMultiStoresCheaperThanBitsMerge(EVT LTy, EVT HTy) const { return false; } - /// \brief Return if the target supports combining a + /// Return if the target supports combining a /// chain like: /// \code /// %andResult = and %val1, #mask @@ -509,7 +509,7 @@ return hasAndNotCompare(X); } - /// \brief Return true if the target wants to use the optimization that + /// Return true if the target wants to use the optimization that /// turns ext(promotableInst1(...(promotableInstN(load)))) into /// promotedInst1(...(promotedInstN(ext(load)))). bool enableExtLdPromotion() const { return EnableExtLdPromotion; } @@ -1179,7 +1179,7 @@ return getPointerTy(DL).getSizeInBits(); } - /// \brief Get maximum # of store operations permitted for llvm.memset + /// Get maximum # of store operations permitted for llvm.memset /// /// This function returns the maximum number of store operations permitted /// to replace a call to llvm.memset. The value is set by the target at the @@ -1189,7 +1189,7 @@ return OptSize ? MaxStoresPerMemsetOptSize : MaxStoresPerMemset; } - /// \brief Get maximum # of store operations permitted for llvm.memcpy + /// Get maximum # of store operations permitted for llvm.memcpy /// /// This function returns the maximum number of store operations permitted /// to replace a call to llvm.memcpy. The value is set by the target at the @@ -1221,7 +1221,7 @@ return 1; } - /// \brief Get maximum # of store operations permitted for llvm.memmove + /// Get maximum # of store operations permitted for llvm.memmove /// /// This function returns the maximum number of store operations permitted /// to replace a call to llvm.memmove. The value is set by the target at the @@ -1231,7 +1231,7 @@ return OptSize ? MaxStoresPerMemmoveOptSize : MaxStoresPerMemmove; } - /// \brief Determine if the target supports unaligned memory accesses. + /// Determine if the target supports unaligned memory accesses. /// /// This function returns true if the target allows unaligned memory accesses /// of the specified type in the given address space. If true, it also returns @@ -1924,7 +1924,7 @@ Type *Ty, unsigned AddrSpace, Instruction *I = nullptr) const; - /// \brief Return the cost of the scaling factor used in the addressing mode + /// Return the cost of the scaling factor used in the addressing mode /// represented by AM for this target, for a load/store of the specified type. /// /// If the AM is supported, the return value must be >= 0. @@ -2120,11 +2120,11 @@ /// Return true if the target has a vector blend instruction. virtual bool hasVectorBlend() const { return false; } - /// \brief Get the maximum supported factor for interleaved memory accesses. + /// Get the maximum supported factor for interleaved memory accesses. /// Default to be the minimum interleave factor: 2. virtual unsigned getMaxSupportedInterleaveFactor() const { return 2; } - /// \brief Lower an interleaved load to target specific intrinsics. Return + /// Lower an interleaved load to target specific intrinsics. Return /// true on success. /// /// \p LI is the vector load instruction. @@ -2138,7 +2138,7 @@ return false; } - /// \brief Lower an interleaved store to target specific intrinsics. Return + /// Lower an interleaved store to target specific intrinsics. Return /// true on success. /// /// \p SI is the vector store instruction. @@ -2211,7 +2211,7 @@ return false; } - /// \brief Return true if it is beneficial to convert a load of a constant to + /// Return true if it is beneficial to convert a load of a constant to /// just the constant itself. /// On some targets it might be more efficient to use a combination of /// arithmetic instructions to materialize the constant instead of loading it @@ -2475,7 +2475,7 @@ /// expected to be merged. unsigned GatherAllAliasesMaxDepth; - /// \brief Specify maximum number of store instructions per memset call. + /// Specify maximum number of store instructions per memset call. /// /// When lowering \@llvm.memset this field specifies the maximum number of /// store operations that may be substituted for the call to memset. Targets @@ -2491,7 +2491,7 @@ /// to memset, used for functions with OptSize attribute. unsigned MaxStoresPerMemsetOptSize; - /// \brief Specify maximum bytes of store instructions per memcpy call. + /// Specify maximum bytes of store instructions per memcpy call. /// /// When lowering \@llvm.memcpy this field specifies the maximum number of /// store operations that may be substituted for a call to memcpy. Targets @@ -2510,7 +2510,7 @@ unsigned MaxLoadsPerMemcmp; unsigned MaxLoadsPerMemcmpOptSize; - /// \brief Specify maximum bytes of store instructions per memmove call. + /// Specify maximum bytes of store instructions per memmove call. /// /// When lowering \@llvm.memmove this field specifies the maximum number of /// store instructions that may be substituted for a call to memmove. Targets Index: llvm/trunk/include/llvm/CodeGen/TargetRegisterInfo.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/TargetRegisterInfo.h +++ llvm/trunk/include/llvm/CodeGen/TargetRegisterInfo.h @@ -971,7 +971,7 @@ //===--------------------------------------------------------------------===// /// Subtarget Hooks - /// \brief SrcRC and DstRC will be morphed into NewRC if this returns true. + /// SrcRC and DstRC will be morphed into NewRC if this returns true. virtual bool shouldCoalesce(MachineInstr *MI, const TargetRegisterClass *SrcRC, unsigned SubReg, @@ -1174,11 +1174,11 @@ /// Usage: OS << printRegUnit(Unit, TRI) << '\n'; Printable printRegUnit(unsigned Unit, const TargetRegisterInfo *TRI); -/// \brief Create Printable object to print virtual registers and physical +/// Create Printable object to print virtual registers and physical /// registers on a \ref raw_ostream. Printable printVRegOrUnit(unsigned VRegOrUnit, const TargetRegisterInfo *TRI); -/// \brief Create Printable object to print register classes or register banks +/// Create Printable object to print register classes or register banks /// on a \ref raw_ostream. Printable printRegClassOrBank(unsigned Reg, const MachineRegisterInfo &RegInfo, const TargetRegisterInfo *TRI); Index: llvm/trunk/include/llvm/CodeGen/TargetSchedule.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/TargetSchedule.h +++ llvm/trunk/include/llvm/CodeGen/TargetSchedule.h @@ -46,7 +46,7 @@ public: TargetSchedModel() : SchedModel(MCSchedModel::GetDefaultSchedModel()) {} - /// \brief Initialize the machine model for instruction scheduling. + /// Initialize the machine model for instruction scheduling. /// /// The machine model API keeps a copy of the top-level MCSchedModel table /// indices and may query TargetSubtargetInfo and TargetInstrInfo to resolve @@ -56,13 +56,13 @@ /// Return the MCSchedClassDesc for this instruction. const MCSchedClassDesc *resolveSchedClass(const MachineInstr *MI) const; - /// \brief TargetSubtargetInfo getter. + /// TargetSubtargetInfo getter. const TargetSubtargetInfo *getSubtargetInfo() const { return STI; } - /// \brief TargetInstrInfo getter. + /// TargetInstrInfo getter. const TargetInstrInfo *getInstrInfo() const { return TII; } - /// \brief Return true if this machine model includes an instruction-level + /// Return true if this machine model includes an instruction-level /// scheduling model. /// /// This is more detailed than the course grain IssueWidth and default @@ -71,7 +71,7 @@ const MCSchedModel *getMCSchedModel() const { return &SchedModel; } - /// \brief Return true if this machine model includes cycle-to-cycle itinerary + /// Return true if this machine model includes cycle-to-cycle itinerary /// data. /// /// This models scheduling at each stage in the processor pipeline. @@ -83,35 +83,35 @@ return nullptr; } - /// \brief Return true if this machine model includes an instruction-level + /// Return true if this machine model includes an instruction-level /// scheduling model or cycle-to-cycle itinerary data. bool hasInstrSchedModelOrItineraries() const { return hasInstrSchedModel() || hasInstrItineraries(); } - /// \brief Identify the processor corresponding to the current subtarget. + /// Identify the processor corresponding to the current subtarget. unsigned getProcessorID() const { return SchedModel.getProcessorID(); } - /// \brief Maximum number of micro-ops that may be scheduled per cycle. + /// Maximum number of micro-ops that may be scheduled per cycle. unsigned getIssueWidth() const { return SchedModel.IssueWidth; } - /// \brief Return true if new group must begin. + /// Return true if new group must begin. bool mustBeginGroup(const MachineInstr *MI, const MCSchedClassDesc *SC = nullptr) const; - /// \brief Return true if current group must end. + /// Return true if current group must end. bool mustEndGroup(const MachineInstr *MI, const MCSchedClassDesc *SC = nullptr) const; - /// \brief Return the number of issue slots required for this MI. + /// Return the number of issue slots required for this MI. unsigned getNumMicroOps(const MachineInstr *MI, const MCSchedClassDesc *SC = nullptr) const; - /// \brief Get the number of kinds of resources for this target. + /// Get the number of kinds of resources for this target. unsigned getNumProcResourceKinds() const { return SchedModel.getNumProcResourceKinds(); } - /// \brief Get a processor resource by ID for convenience. + /// Get a processor resource by ID for convenience. const MCProcResourceDesc *getProcResource(unsigned PIdx) const { return SchedModel.getProcResource(PIdx); } @@ -126,7 +126,7 @@ using ProcResIter = const MCWriteProcResEntry *; - // \brief Get an iterator into the processor resources consumed by this + // Get an iterator into the processor resources consumed by this // scheduling class. ProcResIter getWriteProcResBegin(const MCSchedClassDesc *SC) const { // The subtarget holds a single resource table for all processors. @@ -136,34 +136,34 @@ return STI->getWriteProcResEnd(SC); } - /// \brief Multiply the number of units consumed for a resource by this factor + /// Multiply the number of units consumed for a resource by this factor /// to normalize it relative to other resources. unsigned getResourceFactor(unsigned ResIdx) const { return ResourceFactors[ResIdx]; } - /// \brief Multiply number of micro-ops by this factor to normalize it + /// Multiply number of micro-ops by this factor to normalize it /// relative to other resources. unsigned getMicroOpFactor() const { return MicroOpFactor; } - /// \brief Multiply cycle count by this factor to normalize it relative to + /// Multiply cycle count by this factor to normalize it relative to /// other resources. This is the number of resource units per cycle. unsigned getLatencyFactor() const { return ResourceLCM; } - /// \brief Number of micro-ops that may be buffered for OOO execution. + /// Number of micro-ops that may be buffered for OOO execution. unsigned getMicroOpBufferSize() const { return SchedModel.MicroOpBufferSize; } - /// \brief Number of resource units that may be buffered for OOO execution. + /// Number of resource units that may be buffered for OOO execution. /// \return The buffer size in resource units or -1 for unlimited. int getResourceBufferSize(unsigned PIdx) const { return SchedModel.getProcResource(PIdx)->BufferSize; } - /// \brief Compute operand latency based on the available machine model. + /// Compute operand latency based on the available machine model. /// /// Compute and return the latency of the given data dependent def and use /// when the operand indices are already known. UseMI may be NULL for an @@ -172,7 +172,7 @@ const MachineInstr *UseMI, unsigned UseOperIdx) const; - /// \brief Compute the instruction latency based on the available machine + /// Compute the instruction latency based on the available machine /// model. /// /// Compute and return the expected latency of this instruction independent of @@ -188,13 +188,13 @@ unsigned computeInstrLatency(unsigned Opcode) const; - /// \brief Output dependency latency of a pair of defs of the same register. + /// Output dependency latency of a pair of defs of the same register. /// /// This is typically one cycle. unsigned computeOutputLatency(const MachineInstr *DefMI, unsigned DefIdx, const MachineInstr *DepMI) const; - /// \brief Compute the reciprocal throughput of the given instruction. + /// Compute the reciprocal throughput of the given instruction. Optional computeReciprocalThroughput(const MachineInstr *MI) const; Optional computeReciprocalThroughput(unsigned Opcode) const; }; Index: llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h =================================================================== --- llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h +++ llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h @@ -144,7 +144,7 @@ return 0; } - /// \brief True if the subtarget should run MachineScheduler after aggressive + /// True if the subtarget should run MachineScheduler after aggressive /// coalescing. /// /// This currently replaces the SelectionDAG scheduler with the "source" order @@ -152,14 +152,14 @@ /// TargetLowering preference). It does not yet disable the postRA scheduler. virtual bool enableMachineScheduler() const; - /// \brief Support printing of [latency:throughput] comment in output .S file. + /// Support printing of [latency:throughput] comment in output .S file. virtual bool supportPrintSchedInfo() const { return false; } - /// \brief True if the machine scheduler should disable the TLI preference + /// True if the machine scheduler should disable the TLI preference /// for preRA scheduling with the source level scheduler. virtual bool enableMachineSchedDefaultSched() const { return true; } - /// \brief True if the subtarget should enable joining global copies. + /// True if the subtarget should enable joining global copies. /// /// By default this is enabled if the machine scheduler is enabled, but /// can be overridden. @@ -171,13 +171,13 @@ /// which is the preferred way to influence this. virtual bool enablePostRAScheduler() const; - /// \brief True if the subtarget should run the atomic expansion pass. + /// True if the subtarget should run the atomic expansion pass. virtual bool enableAtomicExpand() const; /// True if the subtarget should run the indirectbr expansion pass. virtual bool enableIndirectBrExpand() const; - /// \brief Override generic scheduling policy within a region. + /// Override generic scheduling policy within a region. /// /// This is a convenient way for targets that don't provide any custom /// scheduling heuristics (no custom MachineSchedStrategy) to make @@ -185,7 +185,7 @@ virtual void overrideSchedPolicy(MachineSchedPolicy &Policy, unsigned NumRegionInstrs) const {} - // \brief Perform target specific adjustments to the latency of a schedule + // Perform target specific adjustments to the latency of a schedule // dependency. virtual void adjustSchedDependency(SUnit *def, SUnit *use, SDep &dep) const {} @@ -200,13 +200,13 @@ return CriticalPathRCs.clear(); } - // \brief Provide an ordered list of schedule DAG mutations for the post-RA + // Provide an ordered list of schedule DAG mutations for the post-RA // scheduler. virtual void getPostRAMutations( std::vector> &Mutations) const { } - // \brief Provide an ordered list of schedule DAG mutations for the machine + // Provide an ordered list of schedule DAG mutations for the machine // pipeliner. virtual void getSMSMutations( std::vector> &Mutations) const { @@ -218,25 +218,25 @@ return CodeGenOpt::Default; } - /// \brief True if the subtarget should run the local reassignment + /// True if the subtarget should run the local reassignment /// heuristic of the register allocator. /// This heuristic may be compile time intensive, \p OptLevel provides /// a finer grain to tune the register allocator. virtual bool enableRALocalReassignment(CodeGenOpt::Level OptLevel) const; - /// \brief True if the subtarget should consider the cost of local intervals + /// True if the subtarget should consider the cost of local intervals /// created by a split candidate when choosing the best split candidate. This /// heuristic may be compile time intensive. virtual bool enableAdvancedRASplitCost() const; - /// \brief Enable use of alias analysis during code generation (during MI + /// Enable use of alias analysis during code generation (during MI /// scheduling, DAGCombine, etc.). virtual bool useAA() const; - /// \brief Enable the use of the early if conversion pass. + /// Enable the use of the early if conversion pass. virtual bool enableEarlyIfConversion() const { return false; } - /// \brief Return PBQPConstraint(s) for the target. + /// Return PBQPConstraint(s) for the target. /// /// Override to provide custom PBQP constraints. virtual std::unique_ptr getCustomPBQPConstraints() const { Index: llvm/trunk/include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h =================================================================== --- llvm/trunk/include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h +++ llvm/trunk/include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h @@ -26,7 +26,7 @@ namespace llvm { namespace codeview { -/// \brief Provides amortized O(1) random access to a CodeView type stream. +/// Provides amortized O(1) random access to a CodeView type stream. /// Normally to access a type from a type stream, you must know its byte /// offset into the type stream, because type records are variable-lengthed. /// However, this is not the way we prefer to access them. For example, given Index: llvm/trunk/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h =================================================================== --- llvm/trunk/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h +++ llvm/trunk/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h @@ -23,7 +23,7 @@ class GlobalTypeTableBuilder; class MergingTypeTableBuilder; -/// \brief Merge one set of type records into another. This method assumes +/// Merge one set of type records into another. This method assumes /// that all records are type records, and there are no Id records present. /// /// \param Dest The table to store the re-written type records into. @@ -40,7 +40,7 @@ SmallVectorImpl &SourceToDest, const CVTypeArray &Types); -/// \brief Merge one set of id records into another. This method assumes +/// Merge one set of id records into another. This method assumes /// that all records are id records, and there are no Type records present. /// However, since Id records can refer back to Type records, this method /// assumes that the referenced type records have also been merged into @@ -65,7 +65,7 @@ SmallVectorImpl &SourceToDest, const CVTypeArray &Ids); -/// \brief Merge a unified set of type and id records, splitting them into +/// Merge a unified set of type and id records, splitting them into /// separate output streams. /// /// \param DestIds The table to store the re-written id records into. Index: llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h =================================================================== --- llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h +++ llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h @@ -357,7 +357,7 @@ return false; } - /// \brief Return the number of bytes for the header of a unit of + /// Return the number of bytes for the header of a unit of /// UnitType type. /// /// This function must be called with a valid unit type which in @@ -407,14 +407,14 @@ /// getUnitSection - Return the DWARFUnitSection containing this unit. const DWARFUnitSectionBase &getUnitSection() const { return UnitSection; } - /// \brief Returns the number of DIEs in the unit. Parses the unit + /// Returns the number of DIEs in the unit. Parses the unit /// if necessary. unsigned getNumDIEs() { extractDIEsIfNeeded(false); return DieArray.size(); } - /// \brief Return the index of a DIE inside the unit's DIE vector. + /// Return the index of a DIE inside the unit's DIE vector. /// /// It is illegal to call this method with a DIE that hasn't be /// created by this unit. In other word, it's illegal to call this @@ -424,7 +424,7 @@ return getDIEIndex(D.getDebugInfoEntry()); } - /// \brief Return the DIE object at the given index. + /// Return the DIE object at the given index. DWARFDie getDIEAtIndex(unsigned Index) { assert(Index < DieArray.size()); return DWARFDie(this, &DieArray[Index]); @@ -434,7 +434,7 @@ DWARFDie getSibling(const DWARFDebugInfoEntry *Die); DWARFDie getFirstChild(const DWARFDebugInfoEntry *Die); - /// \brief Return the DIE object for a given offset inside the + /// Return the DIE object for a given offset inside the /// unit's DIE vector. /// /// The unit needs to have its DIEs extracted for this method to work. Index: llvm/trunk/include/llvm/DebugInfo/MSF/MSFBuilder.h =================================================================== --- llvm/trunk/include/llvm/DebugInfo/MSF/MSFBuilder.h +++ llvm/trunk/include/llvm/DebugInfo/MSF/MSFBuilder.h @@ -24,7 +24,7 @@ class MSFBuilder { public: - /// \brief Create a new `MSFBuilder`. + /// Create a new `MSFBuilder`. /// /// \param BlockSize The internal block size used by the PDB file. See /// isValidBlockSize() for a list of valid block sizes. Index: llvm/trunk/include/llvm/DebugInfo/MSF/MSFCommon.h =================================================================== --- llvm/trunk/include/llvm/DebugInfo/MSF/MSFCommon.h +++ llvm/trunk/include/llvm/DebugInfo/MSF/MSFCommon.h @@ -69,7 +69,7 @@ std::vector> StreamMap; }; -/// \brief Describes the layout of a stream in an MSF layout. A "stream" here +/// Describes the layout of a stream in an MSF layout. A "stream" here /// is defined as any logical unit of data which may be arranged inside the MSF /// file as a sequence of (possibly discontiguous) blocks. When we want to read /// from a particular MSF Stream, we fill out a stream layout structure and the @@ -81,7 +81,7 @@ std::vector Blocks; }; -/// \brief Determine the layout of the FPM stream, given the MSF layout. An FPM +/// Determine the layout of the FPM stream, given the MSF layout. An FPM /// stream spans 1 or more blocks, each at equally spaced intervals throughout /// the file. MSFStreamLayout getFpmStreamLayout(const MSFLayout &Msf, Index: llvm/trunk/include/llvm/DebugInfo/Symbolize/Symbolize.h =================================================================== --- llvm/trunk/include/llvm/DebugInfo/Symbolize/Symbolize.h +++ llvm/trunk/include/llvm/DebugInfo/Symbolize/Symbolize.h @@ -90,11 +90,11 @@ const ObjectFile *Obj, const std::string &ArchName); - /// \brief Returns pair of pointers to object and debug object. + /// Returns pair of pointers to object and debug object. Expected getOrCreateObjectPair(const std::string &Path, const std::string &ArchName); - /// \brief Return a pointer to object file at specified path, for a specified + /// Return a pointer to object file at specified path, for a specified /// architecture (e.g. if path refers to a Mach-O universal binary, only one /// object file from it will be returned). Expected getOrCreateObject(const std::string &Path, @@ -102,14 +102,14 @@ std::map> Modules; - /// \brief Contains cached results of getOrCreateObjectPair(). + /// Contains cached results of getOrCreateObjectPair(). std::map, ObjectPair> ObjectPairForPathArch; - /// \brief Contains parsed binary for each path, or parsing error. + /// Contains parsed binary for each path, or parsing error. std::map> BinaryForPath; - /// \brief Parsed object file for path/architecture pair, where "path" refers + /// Parsed object file for path/architecture pair, where "path" refers /// to Mach-O universal binary. std::map, std::unique_ptr> ObjectForUBPathAndArch; Index: llvm/trunk/include/llvm/Demangle/Compiler.h =================================================================== --- llvm/trunk/include/llvm/Demangle/Compiler.h +++ llvm/trunk/include/llvm/Demangle/Compiler.h @@ -42,7 +42,7 @@ #endif /// \macro LLVM_GNUC_PREREQ -/// \brief Extend the default __GNUC_PREREQ even if glibc's features.h isn't +/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't /// available. #ifndef LLVM_GNUC_PREREQ # if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) @@ -58,7 +58,7 @@ #endif /// \macro LLVM_MSC_PREREQ -/// \brief Is the compiler MSVC of at least the specified version? +/// Is the compiler MSVC of at least the specified version? /// The common \param version values to check for are: /// * 1900: Microsoft Visual Studio 2015 / 14.0 #ifdef _MSC_VER @@ -73,7 +73,7 @@ #define LLVM_MSC_PREREQ(version) 0 #endif -/// \brief Does the compiler support ref-qualifiers for *this? +/// Does the compiler support ref-qualifiers for *this? /// /// Sadly, this is separate from just rvalue reference support because GCC /// and MSVC implemented this later than everything else. @@ -303,7 +303,7 @@ #endif /// \macro LLVM_ASSUME_ALIGNED -/// \brief Returns a pointer with an assumed alignment. +/// Returns a pointer with an assumed alignment. #if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0) # define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a) #elif defined(LLVM_BUILTIN_UNREACHABLE) @@ -315,7 +315,7 @@ #endif /// \macro LLVM_ALIGNAS -/// \brief Used to specify a minimum alignment for a structure or variable. +/// Used to specify a minimum alignment for a structure or variable. #if __GNUC__ && !__has_feature(cxx_alignas) && !LLVM_GNUC_PREREQ(4, 8, 1) # define LLVM_ALIGNAS(x) __attribute__((aligned(x))) #else @@ -323,7 +323,7 @@ #endif /// \macro LLVM_PACKED -/// \brief Used to specify a packed structure. +/// Used to specify a packed structure. /// LLVM_PACKED( /// struct A { /// int i; @@ -351,7 +351,7 @@ #endif /// \macro LLVM_PTR_SIZE -/// \brief A constant integer equivalent to the value of sizeof(void*). +/// A constant integer equivalent to the value of sizeof(void*). /// Generally used in combination with LLVM_ALIGNAS or when doing computation in /// the preprocessor. #ifdef __SIZEOF_POINTER__ @@ -367,7 +367,7 @@ #endif /// \macro LLVM_MEMORY_SANITIZER_BUILD -/// \brief Whether LLVM itself is built with MemorySanitizer instrumentation. +/// Whether LLVM itself is built with MemorySanitizer instrumentation. #if __has_feature(memory_sanitizer) # define LLVM_MEMORY_SANITIZER_BUILD 1 # include @@ -378,7 +378,7 @@ #endif /// \macro LLVM_ADDRESS_SANITIZER_BUILD -/// \brief Whether LLVM itself is built with AddressSanitizer instrumentation. +/// Whether LLVM itself is built with AddressSanitizer instrumentation. #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) # define LLVM_ADDRESS_SANITIZER_BUILD 1 # include @@ -389,7 +389,7 @@ #endif /// \macro LLVM_THREAD_SANITIZER_BUILD -/// \brief Whether LLVM itself is built with ThreadSanitizer instrumentation. +/// Whether LLVM itself is built with ThreadSanitizer instrumentation. #if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__) # define LLVM_THREAD_SANITIZER_BUILD 1 #else @@ -432,14 +432,14 @@ #endif /// \macro LLVM_NO_SANITIZE -/// \brief Disable a particular sanitizer for a function. +/// Disable a particular sanitizer for a function. #if __has_attribute(no_sanitize) #define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND))) #else #define LLVM_NO_SANITIZE(KIND) #endif -/// \brief Mark debug helper function definitions like dump() that should not be +/// Mark debug helper function definitions like dump() that should not be /// stripped from debug builds. /// Note that you should also surround dump() functions with /// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always @@ -452,7 +452,7 @@ #endif /// \macro LLVM_PRETTY_FUNCTION -/// \brief Gets a user-friendly looking function signature for the current scope +/// Gets a user-friendly looking function signature for the current scope /// using the best available method on each platform. The exact format of the /// resulting string is implementation specific and non-portable, so this should /// only be used, for example, for logging or diagnostics. @@ -465,7 +465,7 @@ #endif /// \macro LLVM_THREAD_LOCAL -/// \brief A thread-local storage specifier which can be used with globals, +/// A thread-local storage specifier which can be used with globals, /// extern globals, and static globals. /// /// This is essentially an extremely restricted analog to C++11's thread_local @@ -494,7 +494,7 @@ #endif /// \macro LLVM_ENABLE_EXCEPTIONS -/// \brief Whether LLVM is built with exception support. +/// Whether LLVM is built with exception support. #if __has_feature(cxx_exceptions) #define LLVM_ENABLE_EXCEPTIONS 1 #elif defined(__GNUC__) && defined(__EXCEPTIONS) @@ -504,7 +504,7 @@ #endif /// \macro LLVM_PLUGIN_IMPORT -/// \brief Used to import the well-known entry point for registering loaded pass +/// Used to import the well-known entry point for registering loaded pass /// plugins #ifdef WIN32 #define LLVM_PLUGIN_IMPORT __declspec(dllimport) @@ -513,7 +513,7 @@ #endif /// \macro LLVM_PLUGIN_EXPORT -/// \brief Used to export the well-known entry point for registering loaded pass +/// Used to export the well-known entry point for registering loaded pass /// plugins #ifdef WIN32 #define LLVM_PLUGIN_EXPORT __declspec(dllexport) Index: llvm/trunk/include/llvm/ExecutionEngine/ExecutionEngine.h =================================================================== --- llvm/trunk/include/llvm/ExecutionEngine/ExecutionEngine.h +++ llvm/trunk/include/llvm/ExecutionEngine/ExecutionEngine.h @@ -60,7 +60,7 @@ } // end namespace object -/// \brief Helper class for helping synchronize access to the global address map +/// Helper class for helping synchronize access to the global address map /// table. Access to this class should be serialized under a mutex. class ExecutionEngineState { public: @@ -86,7 +86,7 @@ return GlobalAddressReverseMap; } - /// \brief Erase an entry from the mapping table. + /// Erase an entry from the mapping table. /// /// \returns The address that \p ToUnmap was happed to. uint64_t RemoveMapping(StringRef Name); @@ -94,7 +94,7 @@ using FunctionCreator = std::function; -/// \brief Abstract interface for implementation execution of LLVM modules, +/// Abstract interface for implementation execution of LLVM modules, /// designed to support both interpreter and just-in-time (JIT) compiler /// implementations. class ExecutionEngine { @@ -634,7 +634,7 @@ return *this; } - // \brief Use OrcMCJITReplacement instead of MCJIT. Off by default. + // Use OrcMCJITReplacement instead of MCJIT. Off by default. void setUseOrcMCJITReplacement(bool UseOrcMCJITReplacement) { this->UseOrcMCJITReplacement = UseOrcMCJITReplacement; } Index: llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h =================================================================== --- llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h +++ llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h @@ -311,7 +311,7 @@ virtual void anchor(); }; -/// \brief Legacy symbol resolution interface. +/// Legacy symbol resolution interface. class LegacyJITSymbolResolver : public JITSymbolResolver { public: /// @brief Performs lookup by, for each symbol, first calling Index: llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h =================================================================== --- llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h @@ -1631,7 +1631,7 @@ return RPCAsyncDispatch(Endpoint); } -/// \brief Allows a set of asynchrounous calls to be dispatched, and then +/// Allows a set of asynchrounous calls to be dispatched, and then /// waited on as a group. class ParallelCallGroup { public: @@ -1640,7 +1640,7 @@ ParallelCallGroup(const ParallelCallGroup &) = delete; ParallelCallGroup &operator=(const ParallelCallGroup &) = delete; - /// \brief Make as asynchronous call. + /// Make as asynchronous call. template Error call(const AsyncDispatcher &AsyncDispatch, HandlerT Handler, const ArgTs &... Args) { @@ -1669,7 +1669,7 @@ return AsyncDispatch(std::move(WrappedHandler), Args...); } - /// \brief Blocks until all calls have been completed and their return value + /// Blocks until all calls have been completed and their return value /// handlers run. void wait() { std::unique_lock Lock(M); Index: llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyld.h =================================================================== --- llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyld.h +++ llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyld.h @@ -65,7 +65,7 @@ void reassignSectionAddress(unsigned SectionID, uint64_t Addr); public: - /// \brief Information about the loaded object. + /// Information about the loaded object. class LoadedObjectInfo : public llvm::LoadedObjectInfo { friend class RuntimeDyldImpl; @@ -88,7 +88,7 @@ ObjSectionToIDMap ObjSecToIDMap; }; - /// \brief Memory Management. + /// Memory Management. class MemoryManager { friend class RuntimeDyld; @@ -170,7 +170,7 @@ bool FinalizationLocked = false; }; - /// \brief Construct a RuntimeDyld instance. + /// Construct a RuntimeDyld instance. RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver); RuntimeDyld(const RuntimeDyld &) = delete; RuntimeDyld &operator=(const RuntimeDyld &) = delete; Index: llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyldChecker.h =================================================================== --- llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyldChecker.h +++ llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyldChecker.h @@ -27,7 +27,7 @@ class RuntimeDyldCheckerImpl; class raw_ostream; -/// \brief RuntimeDyld invariant checker for verifying that RuntimeDyld has +/// RuntimeDyld invariant checker for verifying that RuntimeDyld has /// correctly applied relocations. /// /// The RuntimeDyldChecker class evaluates expressions against an attached @@ -74,22 +74,22 @@ MCInstPrinter *InstPrinter, raw_ostream &ErrStream); ~RuntimeDyldChecker(); - // \brief Get the associated RTDyld instance. + // Get the associated RTDyld instance. RuntimeDyld& getRTDyld(); - // \brief Get the associated RTDyld instance. + // Get the associated RTDyld instance. const RuntimeDyld& getRTDyld() const; - /// \brief Check a single expression against the attached RuntimeDyld + /// Check a single expression against the attached RuntimeDyld /// instance. bool check(StringRef CheckExpr) const; - /// \brief Scan the given memory buffer for lines beginning with the string + /// Scan the given memory buffer for lines beginning with the string /// in RulePrefix. The remainder of the line is passed to the check /// method to be evaluated as an expression. bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const; - /// \brief Returns the address of the requested section (or an error message + /// Returns the address of the requested section (or an error message /// in the second element of the pair if the address cannot be found). /// /// if 'LocalAddress' is true, this returns the address of the section @@ -99,7 +99,7 @@ StringRef SectionName, bool LocalAddress); - /// \brief If there is a section at the given local address, return its load + /// If there is a section at the given local address, return its load /// address, otherwise return none. Optional getSectionLoadAddress(void *LocalAddress) const; Index: llvm/trunk/include/llvm/ExecutionEngine/SectionMemoryManager.h =================================================================== --- llvm/trunk/include/llvm/ExecutionEngine/SectionMemoryManager.h +++ llvm/trunk/include/llvm/ExecutionEngine/SectionMemoryManager.h @@ -111,7 +111,7 @@ void operator=(const SectionMemoryManager &) = delete; ~SectionMemoryManager() override; - /// \brief Allocates a memory block of (at least) the given size suitable for + /// Allocates a memory block of (at least) the given size suitable for /// executable code. /// /// The value of \p Alignment must be a power of two. If \p Alignment is zero @@ -120,7 +120,7 @@ unsigned SectionID, StringRef SectionName) override; - /// \brief Allocates a memory block of (at least) the given size suitable for + /// Allocates a memory block of (at least) the given size suitable for /// executable code. /// /// The value of \p Alignment must be a power of two. If \p Alignment is zero @@ -129,7 +129,7 @@ unsigned SectionID, StringRef SectionName, bool isReadOnly) override; - /// \brief Update section-specific memory permissions and other attributes. + /// Update section-specific memory permissions and other attributes. /// /// This method is called when object loading is complete and section page /// permissions can be applied. It is up to the memory manager implementation @@ -142,7 +142,7 @@ /// \returns true if an error occurred, false otherwise. bool finalizeMemory(std::string *ErrMsg = nullptr) override; - /// \brief Invalidate instruction cache for code sections. + /// Invalidate instruction cache for code sections. /// /// Some platforms with separate data cache and instruction cache require /// explicit cache flush, otherwise JIT code manipulations (like resolved Index: llvm/trunk/include/llvm/IR/Attributes.h =================================================================== --- llvm/trunk/include/llvm/IR/Attributes.h +++ llvm/trunk/include/llvm/IR/Attributes.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// // /// \file -/// \brief This file contains the simple types necessary to represent the +/// This file contains the simple types necessary to represent the /// attributes associated with functions and their calls. // //===----------------------------------------------------------------------===// @@ -44,7 +44,7 @@ //===----------------------------------------------------------------------===// /// \class -/// \brief Functions, function parameters, and return types can have attributes +/// Functions, function parameters, and return types can have attributes /// to indicate how they should be treated by optimizations and code /// generation. This class represents one of those attributes. It's light-weight /// and should be passed around by-value. @@ -87,12 +87,12 @@ // Attribute Construction //===--------------------------------------------------------------------===// - /// \brief Return a uniquified Attribute object. + /// Return a uniquified Attribute object. static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0); static Attribute get(LLVMContext &Context, StringRef Kind, StringRef Val = StringRef()); - /// \brief Return a uniquified Attribute object that has the specific + /// Return a uniquified Attribute object that has the specific /// alignment set. static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align); static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align); @@ -108,51 +108,51 @@ // Attribute Accessors //===--------------------------------------------------------------------===// - /// \brief Return true if the attribute is an Attribute::AttrKind type. + /// Return true if the attribute is an Attribute::AttrKind type. bool isEnumAttribute() const; - /// \brief Return true if the attribute is an integer attribute. + /// Return true if the attribute is an integer attribute. bool isIntAttribute() const; - /// \brief Return true if the attribute is a string (target-dependent) + /// Return true if the attribute is a string (target-dependent) /// attribute. bool isStringAttribute() const; - /// \brief Return true if the attribute is present. + /// Return true if the attribute is present. bool hasAttribute(AttrKind Val) const; - /// \brief Return true if the target-dependent attribute is present. + /// Return true if the target-dependent attribute is present. bool hasAttribute(StringRef Val) const; - /// \brief Return the attribute's kind as an enum (Attribute::AttrKind). This + /// Return the attribute's kind as an enum (Attribute::AttrKind). This /// requires the attribute to be an enum or integer attribute. Attribute::AttrKind getKindAsEnum() const; - /// \brief Return the attribute's value as an integer. This requires that the + /// Return the attribute's value as an integer. This requires that the /// attribute be an integer attribute. uint64_t getValueAsInt() const; - /// \brief Return the attribute's kind as a string. This requires the + /// Return the attribute's kind as a string. This requires the /// attribute to be a string attribute. StringRef getKindAsString() const; - /// \brief Return the attribute's value as a string. This requires the + /// Return the attribute's value as a string. This requires the /// attribute to be a string attribute. StringRef getValueAsString() const; - /// \brief Returns the alignment field of an attribute as a byte alignment + /// Returns the alignment field of an attribute as a byte alignment /// value. unsigned getAlignment() const; - /// \brief Returns the stack alignment field of an attribute as a byte + /// Returns the stack alignment field of an attribute as a byte /// alignment value. unsigned getStackAlignment() const; - /// \brief Returns the number of dereferenceable bytes from the + /// Returns the number of dereferenceable bytes from the /// dereferenceable attribute. uint64_t getDereferenceableBytes() const; - /// \brief Returns the number of dereferenceable_or_null bytes from the + /// Returns the number of dereferenceable_or_null bytes from the /// dereferenceable_or_null attribute. uint64_t getDereferenceableOrNullBytes() const; @@ -160,27 +160,27 @@ /// if not known). std::pair> getAllocSizeArgs() const; - /// \brief The Attribute is converted to a string of equivalent mnemonic. This + /// The Attribute is converted to a string of equivalent mnemonic. This /// is, presumably, for writing out the mnemonics for the assembly writer. std::string getAsString(bool InAttrGrp = false) const; - /// \brief Equality and non-equality operators. + /// Equality and non-equality operators. bool operator==(Attribute A) const { return pImpl == A.pImpl; } bool operator!=(Attribute A) const { return pImpl != A.pImpl; } - /// \brief Less-than operator. Useful for sorting the attributes list. + /// Less-than operator. Useful for sorting the attributes list. bool operator<(Attribute A) const; void Profile(FoldingSetNodeID &ID) const { ID.AddPointer(pImpl); } - /// \brief Return a raw pointer that uniquely identifies this attribute. + /// Return a raw pointer that uniquely identifies this attribute. void *getRawPointer() const { return pImpl; } - /// \brief Get an attribute from a raw pointer created by getRawPointer. + /// Get an attribute from a raw pointer created by getRawPointer. static Attribute fromRawPointer(void *RawPtr) { return Attribute(reinterpret_cast(RawPtr)); } @@ -290,7 +290,7 @@ //===----------------------------------------------------------------------===// /// \class -/// \brief Provide DenseMapInfo for AttributeSet. +/// Provide DenseMapInfo for AttributeSet. template <> struct DenseMapInfo { static AttributeSet getEmptyKey() { auto Val = static_cast(-1); @@ -314,7 +314,7 @@ //===----------------------------------------------------------------------===// /// \class -/// \brief This class holds the attributes for a function, its return value, and +/// This class holds the attributes for a function, its return value, and /// its parameters. You access the attributes for each of them via an index into /// the AttributeList object. The function attributes are at index /// `AttributeList::FunctionIndex', the return value is at index @@ -335,18 +335,18 @@ friend class AttributeSetNode; template friend struct DenseMapInfo; - /// \brief The attributes that we are managing. This can be null to represent + /// The attributes that we are managing. This can be null to represent /// the empty attributes list. AttributeListImpl *pImpl = nullptr; public: - /// \brief Create an AttributeList with the specified parameters in it. + /// Create an AttributeList with the specified parameters in it. static AttributeList get(LLVMContext &C, ArrayRef> Attrs); static AttributeList get(LLVMContext &C, ArrayRef> Attrs); - /// \brief Create an AttributeList from attribute sets for a function, its + /// Create an AttributeList from attribute sets for a function, its /// return value, and all of its arguments. static AttributeList get(LLVMContext &C, AttributeSet FnAttrs, AttributeSet RetAttrs, @@ -364,7 +364,7 @@ // AttributeList Construction and Mutation //===--------------------------------------------------------------------===// - /// \brief Return an AttributeList with the specified parameters in it. + /// Return an AttributeList with the specified parameters in it. static AttributeList get(LLVMContext &C, ArrayRef Attrs); static AttributeList get(LLVMContext &C, unsigned Index, ArrayRef Kinds); @@ -373,12 +373,12 @@ static AttributeList get(LLVMContext &C, unsigned Index, const AttrBuilder &B); - /// \brief Add an attribute to the attribute set at the given index. + /// Add an attribute to the attribute set at the given index. /// Returns a new list because attribute lists are immutable. AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const; - /// \brief Add an attribute to the attribute set at the given index. + /// Add an attribute to the attribute set at the given index. /// Returns a new list because attribute lists are immutable. AttributeList addAttribute(LLVMContext &C, unsigned Index, StringRef Kind, StringRef Value = StringRef()) const; @@ -387,7 +387,7 @@ /// Returns a new list because attribute lists are immutable. AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute A) const; - /// \brief Add attributes to the attribute set at the given index. + /// Add attributes to the attribute set at the given index. /// Returns a new list because attribute lists are immutable. AttributeList addAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &B) const; @@ -419,47 +419,47 @@ return addAttributes(C, ArgNo + FirstArgIndex, B); } - /// \brief Remove the specified attribute at the specified index from this + /// Remove the specified attribute at the specified index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const; - /// \brief Remove the specified attribute at the specified index from this + /// Remove the specified attribute at the specified index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeAttribute(LLVMContext &C, unsigned Index, StringRef Kind) const; - /// \brief Remove the specified attributes at the specified index from this + /// Remove the specified attributes at the specified index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &AttrsToRemove) const; - /// \brief Remove all attributes at the specified index from this + /// Remove all attributes at the specified index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeAttributes(LLVMContext &C, unsigned Index) const; - /// \brief Remove the specified attribute at the specified arg index from this + /// Remove the specified attribute at the specified arg index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const { return removeAttribute(C, ArgNo + FirstArgIndex, Kind); } - /// \brief Remove the specified attribute at the specified arg index from this + /// Remove the specified attribute at the specified arg index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo, StringRef Kind) const { return removeAttribute(C, ArgNo + FirstArgIndex, Kind); } - /// \brief Remove the specified attribute at the specified arg index from this + /// Remove the specified attribute at the specified arg index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &AttrsToRemove) const { return removeAttributes(C, ArgNo + FirstArgIndex, AttrsToRemove); } - /// \brief Remove all attributes at the specified arg index from this + /// Remove all attributes at the specified arg index from this /// attribute list. Returns a new list because attribute lists are immutable. AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo) const { return removeAttributes(C, ArgNo + FirstArgIndex); @@ -477,12 +477,12 @@ return addDereferenceableAttr(C, ArgNo + FirstArgIndex, Bytes); } - /// \brief Add the dereferenceable_or_null attribute to the attribute set at + /// Add the dereferenceable_or_null attribute to the attribute set at /// the given index. Returns a new list because attribute lists are immutable. AttributeList addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const; - /// \brief Add the dereferenceable_or_null attribute to the attribute set at + /// Add the dereferenceable_or_null attribute to the attribute set at /// the given arg index. Returns a new list because attribute lists are /// immutable. AttributeList addDereferenceableOrNullParamAttr(LLVMContext &C, @@ -509,102 +509,102 @@ // AttributeList Accessors //===--------------------------------------------------------------------===// - /// \brief Retrieve the LLVM context. + /// Retrieve the LLVM context. LLVMContext &getContext() const; - /// \brief The attributes for the specified index are returned. + /// The attributes for the specified index are returned. AttributeSet getAttributes(unsigned Index) const; - /// \brief The attributes for the argument or parameter at the given index are + /// The attributes for the argument or parameter at the given index are /// returned. AttributeSet getParamAttributes(unsigned ArgNo) const; - /// \brief The attributes for the ret value are returned. + /// The attributes for the ret value are returned. AttributeSet getRetAttributes() const; - /// \brief The function attributes are returned. + /// The function attributes are returned. AttributeSet getFnAttributes() const; - /// \brief Return true if the attribute exists at the given index. + /// Return true if the attribute exists at the given index. bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const; - /// \brief Return true if the attribute exists at the given index. + /// Return true if the attribute exists at the given index. bool hasAttribute(unsigned Index, StringRef Kind) const; - /// \brief Return true if attribute exists at the given index. + /// Return true if attribute exists at the given index. bool hasAttributes(unsigned Index) const; - /// \brief Return true if the attribute exists for the given argument + /// Return true if the attribute exists for the given argument bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const { return hasAttribute(ArgNo + FirstArgIndex, Kind); } - /// \brief Return true if the attribute exists for the given argument + /// Return true if the attribute exists for the given argument bool hasParamAttr(unsigned ArgNo, StringRef Kind) const { return hasAttribute(ArgNo + FirstArgIndex, Kind); } - /// \brief Return true if attributes exists for the given argument + /// Return true if attributes exists for the given argument bool hasParamAttrs(unsigned ArgNo) const { return hasAttributes(ArgNo + FirstArgIndex); } - /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but + /// Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but /// may be faster. bool hasFnAttribute(Attribute::AttrKind Kind) const; - /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but + /// Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but /// may be faster. bool hasFnAttribute(StringRef Kind) const; - /// \brief Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind). + /// Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind). bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const; - /// \brief Return true if the specified attribute is set for at least one + /// Return true if the specified attribute is set for at least one /// parameter or for the return value. If Index is not nullptr, the index /// of a parameter with the specified attribute is provided. bool hasAttrSomewhere(Attribute::AttrKind Kind, unsigned *Index = nullptr) const; - /// \brief Return the attribute object that exists at the given index. + /// Return the attribute object that exists at the given index. Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const; - /// \brief Return the attribute object that exists at the given index. + /// Return the attribute object that exists at the given index. Attribute getAttribute(unsigned Index, StringRef Kind) const; - /// \brief Return the attribute object that exists at the arg index. + /// Return the attribute object that exists at the arg index. Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const { return getAttribute(ArgNo + FirstArgIndex, Kind); } - /// \brief Return the attribute object that exists at the given index. + /// Return the attribute object that exists at the given index. Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const { return getAttribute(ArgNo + FirstArgIndex, Kind); } - /// \brief Return the alignment of the return value. + /// Return the alignment of the return value. unsigned getRetAlignment() const; - /// \brief Return the alignment for the specified function parameter. + /// Return the alignment for the specified function parameter. unsigned getParamAlignment(unsigned ArgNo) const; - /// \brief Get the stack alignment. + /// Get the stack alignment. unsigned getStackAlignment(unsigned Index) const; - /// \brief Get the number of dereferenceable bytes (or zero if unknown). + /// Get the number of dereferenceable bytes (or zero if unknown). uint64_t getDereferenceableBytes(unsigned Index) const; - /// \brief Get the number of dereferenceable bytes (or zero if unknown) of an + /// Get the number of dereferenceable bytes (or zero if unknown) of an /// arg. uint64_t getParamDereferenceableBytes(unsigned ArgNo) const { return getDereferenceableBytes(ArgNo + FirstArgIndex); } - /// \brief Get the number of dereferenceable_or_null bytes (or zero if + /// Get the number of dereferenceable_or_null bytes (or zero if /// unknown). uint64_t getDereferenceableOrNullBytes(unsigned Index) const; - /// \brief Get the number of dereferenceable_or_null bytes (or zero if + /// Get the number of dereferenceable_or_null bytes (or zero if /// unknown) of an arg. uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const { return getDereferenceableOrNullBytes(ArgNo + FirstArgIndex); @@ -614,7 +614,7 @@ std::pair> getAllocSizeArgs(unsigned Index) const; - /// \brief Return the attributes at the index as a string. + /// Return the attributes at the index as a string. std::string getAsString(unsigned Index, bool InAttrGrp = false) const; //===--------------------------------------------------------------------===// @@ -636,12 +636,12 @@ bool operator==(const AttributeList &RHS) const { return pImpl == RHS.pImpl; } bool operator!=(const AttributeList &RHS) const { return pImpl != RHS.pImpl; } - /// \brief Return a raw pointer that uniquely identifies this attribute list. + /// Return a raw pointer that uniquely identifies this attribute list. void *getRawPointer() const { return pImpl; } - /// \brief Return true if there are no attributes. + /// Return true if there are no attributes. bool isEmpty() const { return pImpl == nullptr; } void dump() const; @@ -649,7 +649,7 @@ //===----------------------------------------------------------------------===// /// \class -/// \brief Provide DenseMapInfo for AttributeList. +/// Provide DenseMapInfo for AttributeList. template <> struct DenseMapInfo { static AttributeList getEmptyKey() { auto Val = static_cast(-1); @@ -675,7 +675,7 @@ //===----------------------------------------------------------------------===// /// \class -/// \brief This class is used in conjunction with the Attribute::get method to +/// This class is used in conjunction with the Attribute::get method to /// create an Attribute object. The object itself is uniquified. The Builder's /// value, however, is not. So this can be used as a quick way to test for /// equality, presence of attributes, etc. @@ -700,65 +700,65 @@ void clear(); - /// \brief Add an attribute to the builder. + /// Add an attribute to the builder. AttrBuilder &addAttribute(Attribute::AttrKind Val); - /// \brief Add the Attribute object to the builder. + /// Add the Attribute object to the builder. AttrBuilder &addAttribute(Attribute A); - /// \brief Add the target-dependent attribute to the builder. + /// Add the target-dependent attribute to the builder. AttrBuilder &addAttribute(StringRef A, StringRef V = StringRef()); - /// \brief Remove an attribute from the builder. + /// Remove an attribute from the builder. AttrBuilder &removeAttribute(Attribute::AttrKind Val); - /// \brief Remove the attributes from the builder. + /// Remove the attributes from the builder. AttrBuilder &removeAttributes(AttributeList A, uint64_t WithoutIndex); - /// \brief Remove the target-dependent attribute to the builder. + /// Remove the target-dependent attribute to the builder. AttrBuilder &removeAttribute(StringRef A); - /// \brief Add the attributes from the builder. + /// Add the attributes from the builder. AttrBuilder &merge(const AttrBuilder &B); - /// \brief Remove the attributes from the builder. + /// Remove the attributes from the builder. AttrBuilder &remove(const AttrBuilder &B); - /// \brief Return true if the builder has any attribute that's in the + /// Return true if the builder has any attribute that's in the /// specified builder. bool overlaps(const AttrBuilder &B) const; - /// \brief Return true if the builder has the specified attribute. + /// Return true if the builder has the specified attribute. bool contains(Attribute::AttrKind A) const { assert((unsigned)A < Attribute::EndAttrKinds && "Attribute out of range!"); return Attrs[A]; } - /// \brief Return true if the builder has the specified target-dependent + /// Return true if the builder has the specified target-dependent /// attribute. bool contains(StringRef A) const; - /// \brief Return true if the builder has IR-level attributes. + /// Return true if the builder has IR-level attributes. bool hasAttributes() const; - /// \brief Return true if the builder has any attribute that's in the + /// Return true if the builder has any attribute that's in the /// specified attribute. bool hasAttributes(AttributeList A, uint64_t Index) const; - /// \brief Return true if the builder has an alignment attribute. + /// Return true if the builder has an alignment attribute. bool hasAlignmentAttr() const; - /// \brief Retrieve the alignment attribute, if it exists. + /// Retrieve the alignment attribute, if it exists. uint64_t getAlignment() const { return Alignment; } - /// \brief Retrieve the stack alignment attribute, if it exists. + /// Retrieve the stack alignment attribute, if it exists. uint64_t getStackAlignment() const { return StackAlignment; } - /// \brief Retrieve the number of dereferenceable bytes, if the + /// Retrieve the number of dereferenceable bytes, if the /// dereferenceable attribute exists (zero is returned otherwise). uint64_t getDereferenceableBytes() const { return DerefBytes; } - /// \brief Retrieve the number of dereferenceable_or_null bytes, if the + /// Retrieve the number of dereferenceable_or_null bytes, if the /// dereferenceable_or_null attribute exists (zero is returned otherwise). uint64_t getDereferenceableOrNullBytes() const { return DerefOrNullBytes; } @@ -766,19 +766,19 @@ /// doesn't exist, pair(0, 0) is returned. std::pair> getAllocSizeArgs() const; - /// \brief This turns an int alignment (which must be a power of 2) into the + /// This turns an int alignment (which must be a power of 2) into the /// form used internally in Attribute. AttrBuilder &addAlignmentAttr(unsigned Align); - /// \brief This turns an int stack alignment (which must be a power of 2) into + /// This turns an int stack alignment (which must be a power of 2) into /// the form used internally in Attribute. AttrBuilder &addStackAlignmentAttr(unsigned Align); - /// \brief This turns the number of dereferenceable bytes into the form used + /// This turns the number of dereferenceable bytes into the form used /// internally in Attribute. AttrBuilder &addDereferenceableAttr(uint64_t Bytes); - /// \brief This turns the number of dereferenceable_or_null bytes into the + /// This turns the number of dereferenceable_or_null bytes into the /// form used internally in Attribute. AttrBuilder &addDereferenceableOrNullAttr(uint64_t Bytes); @@ -790,7 +790,7 @@ /// Attribute.getIntValue(). AttrBuilder &addAllocSizeAttrFromRawRepr(uint64_t RawAllocSizeRepr); - /// \brief Return true if the builder contains no target-independent + /// Return true if the builder contains no target-independent /// attributes. bool empty() const { return Attrs.none(); } @@ -823,14 +823,14 @@ namespace AttributeFuncs { -/// \brief Which attributes cannot be applied to a type. +/// Which attributes cannot be applied to a type. AttrBuilder typeIncompatible(Type *Ty); /// \returns Return true if the two functions have compatible target-independent /// attributes for inlining purposes. bool areInlineCompatible(const Function &Caller, const Function &Callee); -/// \brief Merge caller's and callee's attributes. +/// Merge caller's and callee's attributes. void mergeAttributesForInlining(Function &Caller, const Function &Callee); } // end namespace AttributeFuncs Index: llvm/trunk/include/llvm/IR/CallingConv.h =================================================================== --- llvm/trunk/include/llvm/IR/CallingConv.h +++ llvm/trunk/include/llvm/IR/CallingConv.h @@ -139,11 +139,11 @@ /// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins Intel_OCL_BI = 77, - /// \brief The C convention as specified in the x86-64 supplement to the + /// The C convention as specified in the x86-64 supplement to the /// System V ABI, used on most non-Windows systems. X86_64_SysV = 78, - /// \brief The C convention as implemented on Windows/x86-64 and + /// The C convention as implemented on Windows/x86-64 and /// AArch64. This convention differs from the more common /// \c X86_64_SysV convention in a number of ways, most notably in /// that XMM registers used to pass arguments are shadowed by GPRs, @@ -153,17 +153,17 @@ /// registers to variadic functions. Win64 = 79, - /// \brief MSVC calling convention that passes vectors and vector aggregates + /// MSVC calling convention that passes vectors and vector aggregates /// in SSE registers. X86_VectorCall = 80, - /// \brief Calling convention used by HipHop Virtual Machine (HHVM) to + /// Calling convention used by HipHop Virtual Machine (HHVM) to /// perform calls to and from translation cache, and for calling PHP /// functions. /// HHVM calling convention supports tail/sibling call elimination. HHVM = 81, - /// \brief HHVM calling convention for invoking C/C++ helpers. + /// HHVM calling convention for invoking C/C++ helpers. HHVM_C = 82, /// X86_INTR - x86 hardware interrupt context. Callee may take one or two Index: llvm/trunk/include/llvm/IR/Constants.h =================================================================== --- llvm/trunk/include/llvm/IR/Constants.h +++ llvm/trunk/include/llvm/IR/Constants.h @@ -1022,7 +1022,7 @@ /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); - /// \brief Convenience function for getting a Cast operation. + /// Convenience function for getting a Cast operation. /// /// \param ops The opcode for the conversion /// \param C The constant to be converted @@ -1106,7 +1106,7 @@ static Constant *get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr); - /// \brief Return an ICmp or FCmp comparison operator constant expression. + /// Return an ICmp or FCmp comparison operator constant expression. /// /// \param OnlyIfReduced see \a getWithOperands() docs. static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2, Index: llvm/trunk/include/llvm/IR/DataLayout.h =================================================================== --- llvm/trunk/include/llvm/IR/DataLayout.h +++ llvm/trunk/include/llvm/IR/DataLayout.h @@ -61,7 +61,7 @@ // sunk down to an FTTI element that is queried rather than a global // preference. -/// \brief Layout alignment element. +/// Layout alignment element. /// /// Stores the alignment data associated with a given alignment type (integer, /// vector, float) and type bit width. @@ -69,7 +69,7 @@ /// \note The unusual order of elements in the structure attempts to reduce /// padding and make the structure slightly more cache friendly. struct LayoutAlignElem { - /// \brief Alignment type from \c AlignTypeEnum + /// Alignment type from \c AlignTypeEnum unsigned AlignType : 8; unsigned TypeBitWidth : 24; unsigned ABIAlign : 16; @@ -81,7 +81,7 @@ bool operator==(const LayoutAlignElem &rhs) const; }; -/// \brief Layout pointer alignment element. +/// Layout pointer alignment element. /// /// Stores the alignment data associated with a given pointer and address space. /// @@ -102,7 +102,7 @@ bool operator==(const PointerAlignElem &rhs) const; }; -/// \brief A parsed version of the target data layout string in and methods for +/// A parsed version of the target data layout string in and methods for /// querying it. /// /// The target data layout string is specified *by the target* - a frontend @@ -129,7 +129,7 @@ SmallVector LegalIntWidths; - /// \brief Primitive type alignment data. This is sorted by type and bit + /// Primitive type alignment data. This is sorted by type and bit /// width during construction. using AlignmentsTy = SmallVector; AlignmentsTy Alignments; @@ -143,7 +143,7 @@ AlignmentsTy::iterator findAlignmentLowerBound(AlignTypeEnum AlignType, uint32_t BitWidth); - /// \brief The string representation used to create this DataLayout + /// The string representation used to create this DataLayout std::string StringRepresentation; using PointersTy = SmallVector; @@ -221,7 +221,7 @@ bool isLittleEndian() const { return !BigEndian; } bool isBigEndian() const { return BigEndian; } - /// \brief Returns the string representation of the DataLayout. + /// Returns the string representation of the DataLayout. /// /// This representation is in the same format accepted by the string /// constructor above. This should not be used to compare two DataLayout as @@ -230,10 +230,10 @@ return StringRepresentation; } - /// \brief Test if the DataLayout was constructed from an empty string. + /// Test if the DataLayout was constructed from an empty string. bool isDefault() const { return StringRepresentation.empty(); } - /// \brief Returns true if the specified type is known to be a native integer + /// Returns true if the specified type is known to be a native integer /// type supported by the CPU. /// /// For example, i64 is not native on most 32-bit CPUs and i37 is not native @@ -309,7 +309,7 @@ static const char *getManglingComponent(const Triple &T); - /// \brief Returns true if the specified type fits in a native integer type + /// Returns true if the specified type fits in a native integer type /// supported by the CPU. /// /// For example, if the CPU only supports i32 as a native integer type, then @@ -398,13 +398,13 @@ /// [*] The alloc size depends on the alignment, and thus on the target. /// These values are for x86-32 linux. - /// \brief Returns the number of bits necessary to hold the specified type. + /// Returns the number of bits necessary to hold the specified type. /// /// For example, returns 36 for i36 and 80 for x86_fp80. The type passed must /// have a size (Type::isSized() must return true). uint64_t getTypeSizeInBits(Type *Ty) const; - /// \brief Returns the maximum number of bytes that may be overwritten by + /// Returns the maximum number of bytes that may be overwritten by /// storing the specified type. /// /// For example, returns 5 for i36 and 10 for x86_fp80. @@ -412,7 +412,7 @@ return (getTypeSizeInBits(Ty) + 7) / 8; } - /// \brief Returns the maximum number of bits that may be overwritten by + /// Returns the maximum number of bits that may be overwritten by /// storing the specified type; always a multiple of 8. /// /// For example, returns 40 for i36 and 80 for x86_fp80. @@ -420,7 +420,7 @@ return 8 * getTypeStoreSize(Ty); } - /// \brief Returns the offset in bytes between successive objects of the + /// Returns the offset in bytes between successive objects of the /// specified type, including alignment padding. /// /// This is the amount that alloca reserves for this type. For example, @@ -430,7 +430,7 @@ return alignTo(getTypeStoreSize(Ty), getABITypeAlignment(Ty)); } - /// \brief Returns the offset in bits between successive objects of the + /// Returns the offset in bits between successive objects of the /// specified type, including alignment padding; always a multiple of 8. /// /// This is the amount that alloca reserves for this type. For example, @@ -439,69 +439,69 @@ return 8 * getTypeAllocSize(Ty); } - /// \brief Returns the minimum ABI-required alignment for the specified type. + /// Returns the minimum ABI-required alignment for the specified type. unsigned getABITypeAlignment(Type *Ty) const; - /// \brief Returns the minimum ABI-required alignment for an integer type of + /// Returns the minimum ABI-required alignment for an integer type of /// the specified bitwidth. unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const; - /// \brief Returns the preferred stack/global alignment for the specified + /// Returns the preferred stack/global alignment for the specified /// type. /// /// This is always at least as good as the ABI alignment. unsigned getPrefTypeAlignment(Type *Ty) const; - /// \brief Returns the preferred alignment for the specified type, returned as + /// Returns the preferred alignment for the specified type, returned as /// log2 of the value (a shift amount). unsigned getPreferredTypeAlignmentShift(Type *Ty) const; - /// \brief Returns an integer type with size at least as big as that of a + /// Returns an integer type with size at least as big as that of a /// pointer in the given address space. IntegerType *getIntPtrType(LLVMContext &C, unsigned AddressSpace = 0) const; - /// \brief Returns an integer (vector of integer) type with size at least as + /// Returns an integer (vector of integer) type with size at least as /// big as that of a pointer of the given pointer (vector of pointer) type. Type *getIntPtrType(Type *) const; - /// \brief Returns the smallest integer type with size at least as big as + /// Returns the smallest integer type with size at least as big as /// Width bits. Type *getSmallestLegalIntType(LLVMContext &C, unsigned Width = 0) const; - /// \brief Returns the largest legal integer type, or null if none are set. + /// Returns the largest legal integer type, or null if none are set. Type *getLargestLegalIntType(LLVMContext &C) const { unsigned LargestSize = getLargestLegalIntTypeSizeInBits(); return (LargestSize == 0) ? nullptr : Type::getIntNTy(C, LargestSize); } - /// \brief Returns the size of largest legal integer type size, or 0 if none + /// Returns the size of largest legal integer type size, or 0 if none /// are set. unsigned getLargestLegalIntTypeSizeInBits() const; - /// \brief Returns the type of a GEP index. + /// Returns the type of a GEP index. /// If it was not specified explicitly, it will be the integer type of the /// pointer width - IntPtrType. Type *getIndexType(Type *PtrTy) const; - /// \brief Returns the offset from the beginning of the type for the specified + /// Returns the offset from the beginning of the type for the specified /// indices. /// /// Note that this takes the element type, not the pointer type. /// This is used to implement getelementptr. int64_t getIndexedOffsetInType(Type *ElemTy, ArrayRef Indices) const; - /// \brief Returns a StructLayout object, indicating the alignment of the + /// Returns a StructLayout object, indicating the alignment of the /// struct, its size, and the offsets of its fields. /// /// Note that this information is lazily cached. const StructLayout *getStructLayout(StructType *Ty) const; - /// \brief Returns the preferred alignment of the specified global. + /// Returns the preferred alignment of the specified global. /// /// This includes an explicitly requested alignment (if the global has one). unsigned getPreferredAlignment(const GlobalVariable *GV) const; - /// \brief Returns the preferred alignment of the specified global, returned + /// Returns the preferred alignment of the specified global, returned /// in log form. /// /// This includes an explicitly requested alignment (if the global has one). @@ -536,7 +536,7 @@ /// NB: Padding in nested element is not taken into account. bool hasPadding() const { return IsPadded; } - /// \brief Given a valid byte offset into the structure, returns the structure + /// Given a valid byte offset into the structure, returns the structure /// index that contains it. unsigned getElementContainingOffset(uint64_t Offset) const; Index: llvm/trunk/include/llvm/IR/DebugInfoMetadata.h =================================================================== --- llvm/trunk/include/llvm/IR/DebugInfoMetadata.h +++ llvm/trunk/include/llvm/IR/DebugInfoMetadata.h @@ -790,7 +790,7 @@ friend class LLVMContextImpl; friend class MDNode; - /// \brief The DWARF address space of the memory pointed to or referenced by a + /// The DWARF address space of the memory pointed to or referenced by a /// pointer or reference type respectively. Optional DWARFAddressSpace; Index: llvm/trunk/include/llvm/IR/DebugLoc.h =================================================================== --- llvm/trunk/include/llvm/IR/DebugLoc.h +++ llvm/trunk/include/llvm/IR/DebugLoc.h @@ -24,7 +24,7 @@ class raw_ostream; class DILocation; - /// \brief A debug info location. + /// A debug info location. /// /// This class is a wrapper around a tracking reference to an \a DILocation /// pointer. @@ -37,10 +37,10 @@ public: DebugLoc() = default; - /// \brief Construct from an \a DILocation. + /// Construct from an \a DILocation. DebugLoc(const DILocation *L); - /// \brief Construct from an \a MDNode. + /// Construct from an \a MDNode. /// /// Note: if \c N is not an \a DILocation, a verifier check will fail, and /// accessors will crash. However, construction from other nodes is @@ -48,7 +48,7 @@ /// IR. explicit DebugLoc(const MDNode *N); - /// \brief Get the underlying \a DILocation. + /// Get the underlying \a DILocation. /// /// \pre !*this or \c isa(getAsMDNode()). /// @{ @@ -58,7 +58,7 @@ DILocation &operator*() const { return *get(); } /// @} - /// \brief Check for null. + /// Check for null. /// /// Check for null in a way that is safe with broken debug info. Unlike /// the conversion to \c DILocation, this doesn't require that \c Loc is of @@ -66,10 +66,10 @@ /// \a Instruction::hasMetadata(). explicit operator bool() const { return Loc; } - /// \brief Check whether this has a trivial destructor. + /// Check whether this has a trivial destructor. bool hasTrivialDestructor() const { return Loc.hasTrivialDestructor(); } - /// \brief Create a new DebugLoc. + /// Create a new DebugLoc. /// /// Create a new DebugLoc at the specified line/col and scope/inline. This /// forwards to \a DILocation::get(). @@ -95,12 +95,12 @@ MDNode *getScope() const; DILocation *getInlinedAt() const; - /// \brief Get the fully inlined-at scope for a DebugLoc. + /// Get the fully inlined-at scope for a DebugLoc. /// /// Gets the inlined-at scope for a DebugLoc. MDNode *getInlinedAtScope() const; - /// \brief Find the debug info location for the start of the function. + /// Find the debug info location for the start of the function. /// /// Walk up the scope chain of given debug loc and find line number info /// for the function. @@ -109,7 +109,7 @@ /// find the subprogram, and then DILocation::get(). DebugLoc getFnDebugLoc() const; - /// \brief Return \c this as a bar \a MDNode. + /// Return \c this as a bar \a MDNode. MDNode *getAsMDNode() const { return Loc; } bool operator==(const DebugLoc &DL) const { return Loc == DL.Loc; } @@ -117,7 +117,7 @@ void dump() const; - /// \brief prints source location /path/to/file.exe:line:col @[inlined at] + /// prints source location /path/to/file.exe:line:col @[inlined at] void print(raw_ostream &OS) const; }; Index: llvm/trunk/include/llvm/IR/DiagnosticHandler.h =================================================================== --- llvm/trunk/include/llvm/IR/DiagnosticHandler.h +++ llvm/trunk/include/llvm/IR/DiagnosticHandler.h @@ -18,7 +18,7 @@ namespace llvm { class DiagnosticInfo; -/// \brief This is the base class for diagnostic handling in LLVM. +/// This is the base class for diagnostic handling in LLVM. /// The handleDiagnostics method must be overriden by the subclasses to handle /// diagnostic. The *RemarkEnabled methods can be overriden to control /// which remarks are enabled. Index: llvm/trunk/include/llvm/IR/DiagnosticInfo.h =================================================================== --- llvm/trunk/include/llvm/IR/DiagnosticInfo.h +++ llvm/trunk/include/llvm/IR/DiagnosticInfo.h @@ -39,7 +39,7 @@ class Module; class SMDiagnostic; -/// \brief Defines the different supported severity of a diagnostic. +/// Defines the different supported severity of a diagnostic. enum DiagnosticSeverity : char { DS_Error, DS_Warning, @@ -49,7 +49,7 @@ DS_Note }; -/// \brief Defines the different supported kind of a diagnostic. +/// Defines the different supported kind of a diagnostic. /// This enum should be extended with a new ID for each added concrete subclass. enum DiagnosticKind { DK_InlineAsm, @@ -79,7 +79,7 @@ DK_FirstPluginKind }; -/// \brief Get the next available kind ID for a plugin diagnostic. +/// Get the next available kind ID for a plugin diagnostic. /// Each time this function is called, it returns a different number. /// Therefore, a plugin that wants to "identify" its own classes /// with a dynamic identifier, just have to use this method to get a new ID @@ -89,7 +89,7 @@ /// DiagnosticKind values. int getNextAvailablePluginDiagnosticKind(); -/// \brief This is the base abstract class for diagnostic reporting in +/// This is the base abstract class for diagnostic reporting in /// the backend. /// The print method must be overloaded by the subclasses to print a /// user-friendly message in the client of the backend (let us call it a @@ -389,20 +389,20 @@ DiagnosticLocation Loc; }; -/// \brief Common features for diagnostics dealing with optimization remarks +/// Common features for diagnostics dealing with optimization remarks /// that are used by both IR and MIR passes. class DiagnosticInfoOptimizationBase : public DiagnosticInfoWithLocationBase { public: - /// \brief Used to set IsVerbose via the stream interface. + /// Used to set IsVerbose via the stream interface. struct setIsVerbose {}; - /// \brief When an instance of this is inserted into the stream, the arguments + /// When an instance of this is inserted into the stream, the arguments /// following will not appear in the remark printed in the compiler output /// (-Rpass) but only in the optimization record file /// (-fsave-optimization-record). struct setExtraArgs {}; - /// \brief Used in the streaming interface as the general argument type. It + /// Used in the streaming interface as the general argument type. It /// internally converts everything into a key-value pair. struct Argument { std::string Key; @@ -504,7 +504,7 @@ /// The remark is expected to be noisy. bool IsVerbose = false; - /// \brief If positive, the index of the first argument that only appear in + /// If positive, the index of the first argument that only appear in /// the optimization records and not in the remark printed in the compiler /// output. int FirstExtraArgIndex = -1; @@ -587,7 +587,7 @@ return R; } -/// \brief Common features for diagnostics dealing with optimization remarks +/// Common features for diagnostics dealing with optimization remarks /// that are used by IR passes. class DiagnosticInfoIROptimization : public DiagnosticInfoOptimizationBase { public: @@ -609,7 +609,7 @@ Loc), CodeRegion(CodeRegion) {} - /// \brief This is ctor variant allows a pass to build an optimization remark + /// This is ctor variant allows a pass to build an optimization remark /// from an existing remark. /// /// This is useful when a transformation pass (e.g LV) wants to emit a remark @@ -712,7 +712,7 @@ const DiagnosticLocation &Loc, const Value *CodeRegion); - /// \brief Same as above but \p Inst is used to derive code region and debug + /// Same as above but \p Inst is used to derive code region and debug /// location. OptimizationRemarkMissed(const char *PassName, StringRef RemarkName, const Instruction *Inst); @@ -753,7 +753,7 @@ const DiagnosticLocation &Loc, const Value *CodeRegion); - /// \brief This is ctor variant allows a pass to build an optimization remark + /// This is ctor variant allows a pass to build an optimization remark /// from an existing remark. /// /// This is useful when a transformation pass (e.g LV) wants to emit a remark @@ -764,7 +764,7 @@ const OptimizationRemarkAnalysis &Orig) : DiagnosticInfoIROptimization(PassName, Prepend, Orig) {} - /// \brief Same as above but \p Inst is used to derive code region and debug + /// Same as above but \p Inst is used to derive code region and debug /// location. OptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName, const Instruction *Inst); Index: llvm/trunk/include/llvm/IR/DiagnosticPrinter.h =================================================================== --- llvm/trunk/include/llvm/IR/DiagnosticPrinter.h +++ llvm/trunk/include/llvm/IR/DiagnosticPrinter.h @@ -28,7 +28,7 @@ class Twine; class Value; -/// \brief Interface for custom diagnostic printing. +/// Interface for custom diagnostic printing. class DiagnosticPrinter { public: virtual ~DiagnosticPrinter() = default; @@ -58,7 +58,7 @@ virtual DiagnosticPrinter &operator<<(const SMDiagnostic &Diag) = 0; }; -/// \brief Basic diagnostic printer that uses an underlying raw_ostream. +/// Basic diagnostic printer that uses an underlying raw_ostream. class DiagnosticPrinterRawOStream : public DiagnosticPrinter { protected: raw_ostream &Stream; Index: llvm/trunk/include/llvm/IR/Dominators.h =================================================================== --- llvm/trunk/include/llvm/IR/Dominators.h +++ llvm/trunk/include/llvm/IR/Dominators.h @@ -121,7 +121,7 @@ } }; -/// \brief Concrete subclass of DominatorTreeBase that is used to compute a +/// Concrete subclass of DominatorTreeBase that is used to compute a /// normal dominator tree. /// /// Definition: A block is said to be forward statically reachable if there is @@ -153,7 +153,7 @@ // Ensure base-class overloads are visible. using Base::dominates; - /// \brief Return true if Def dominates a use in User. + /// Return true if Def dominates a use in User. /// /// This performs the special checks necessary if Def and User are in the same /// basic block. Note that Def doesn't dominate a use in Def itself! @@ -171,7 +171,7 @@ // Ensure base class overloads are visible. using Base::isReachableFromEntry; - /// \brief Provide an overload for a Use. + /// Provide an overload for a Use. bool isReachableFromEntry(const Use &U) const; // Pop up a GraphViz/gv window with the Dominator Tree rendered using `dot`. @@ -221,20 +221,20 @@ } }; -/// \brief Analysis pass which computes a \c DominatorTree. +/// Analysis pass which computes a \c DominatorTree. class DominatorTreeAnalysis : public AnalysisInfoMixin { friend AnalysisInfoMixin; static AnalysisKey Key; public: - /// \brief Provide the result typedef for this analysis pass. + /// Provide the result typedef for this analysis pass. using Result = DominatorTree; - /// \brief Run the analysis pass over a function and produce a dominator tree. + /// Run the analysis pass over a function and produce a dominator tree. DominatorTree run(Function &F, FunctionAnalysisManager &); }; -/// \brief Printer pass for the \c DominatorTree. +/// Printer pass for the \c DominatorTree. class DominatorTreePrinterPass : public PassInfoMixin { raw_ostream &OS; @@ -245,12 +245,12 @@ PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Verifier pass for the \c DominatorTree. +/// Verifier pass for the \c DominatorTree. struct DominatorTreeVerifierPass : PassInfoMixin { PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); }; -/// \brief Legacy analysis pass which computes a \c DominatorTree. +/// Legacy analysis pass which computes a \c DominatorTree. class DominatorTreeWrapperPass : public FunctionPass { DominatorTree DT; @@ -278,7 +278,7 @@ }; //===------------------------------------- -/// \brief Class to defer updates to a DominatorTree. +/// Class to defer updates to a DominatorTree. /// /// Definition: Applying updates to every edge insertion and deletion is /// expensive and not necessary. When one needs the DominatorTree for analysis @@ -308,40 +308,40 @@ public: DeferredDominance(DominatorTree &DT_) : DT(DT_) {} - /// \brief Queues multiple updates and discards duplicates. + /// Queues multiple updates and discards duplicates. void applyUpdates(ArrayRef Updates); - /// \brief Helper method for a single edge insertion. It's almost always + /// Helper method for a single edge insertion. It's almost always /// better to batch updates and call applyUpdates to quickly remove duplicate /// edges. This is best used when there is only a single insertion needed to /// update Dominators. void insertEdge(BasicBlock *From, BasicBlock *To); - /// \brief Helper method for a single edge deletion. It's almost always better + /// Helper method for a single edge deletion. It's almost always better /// to batch updates and call applyUpdates to quickly remove duplicate edges. /// This is best used when there is only a single deletion needed to update /// Dominators. void deleteEdge(BasicBlock *From, BasicBlock *To); - /// \brief Delays the deletion of a basic block until a flush() event. + /// Delays the deletion of a basic block until a flush() event. void deleteBB(BasicBlock *DelBB); - /// \brief Returns true if DelBB is awaiting deletion at a flush() event. + /// Returns true if DelBB is awaiting deletion at a flush() event. bool pendingDeletedBB(BasicBlock *DelBB); - /// \brief Returns true if pending DT updates are queued for a flush() event. + /// Returns true if pending DT updates are queued for a flush() event. bool pending(); - /// \brief Flushes all pending updates and block deletions. Returns a + /// Flushes all pending updates and block deletions. Returns a /// correct DominatorTree reference to be used by the caller for analysis. DominatorTree &flush(); - /// \brief Drops all internal state and forces a (slow) recalculation of the + /// Drops all internal state and forces a (slow) recalculation of the /// DominatorTree based on the current state of the LLVM IR in F. This should /// only be used in corner cases such as the Entry block of F being deleted. void recalculate(Function &F); - /// \brief Debug method to help view the state of pending updates. + /// Debug method to help view the state of pending updates. LLVM_DUMP_METHOD void dump() const; private: Index: llvm/trunk/include/llvm/IR/Function.h =================================================================== --- llvm/trunk/include/llvm/IR/Function.h +++ llvm/trunk/include/llvm/IR/Function.h @@ -181,7 +181,7 @@ static Intrinsic::ID lookupIntrinsicID(StringRef Name); - /// \brief Recalculate the ID for this function if it is an Intrinsic defined + /// Recalculate the ID for this function if it is an Intrinsic defined /// in llvm/Intrinsics.h. Sets the intrinsic ID to Intrinsic::not_intrinsic /// if the name of this function does not match an intrinsic in that header. /// Note, this method does not need to be called directly, as it is called @@ -263,7 +263,7 @@ static ProfileCount getInvalid() { return ProfileCount(-1, PCT_Invalid); } }; - /// \brief Set the entry count for this function. + /// Set the entry count for this function. /// /// Entry count is the number of times this function was executed based on /// pgo data. \p Imports points to a set of GUIDs that needs to @@ -276,7 +276,7 @@ void setEntryCount(uint64_t Count, ProfileCountType Type = PCT_Real, const DenseSet *Imports = nullptr); - /// \brief Get the entry count for this function. + /// Get the entry count for this function. /// /// Entry count is the number of times the function was executed based on /// pgo data. @@ -318,7 +318,7 @@ return getAttribute(AttributeList::FunctionIndex, Kind); } - /// \brief Return the stack alignment for the function. + /// Return the stack alignment for the function. unsigned getFnStackAlignment() const { if (!hasFnAttribute(Attribute::StackAlignment)) return 0; @@ -679,30 +679,30 @@ size_t arg_size() const { return NumArgs; } bool arg_empty() const { return arg_size() == 0; } - /// \brief Check whether this function has a personality function. + /// Check whether this function has a personality function. bool hasPersonalityFn() const { return getSubclassDataFromValue() & (1<<3); } - /// \brief Get the personality function associated with this function. + /// Get the personality function associated with this function. Constant *getPersonalityFn() const; void setPersonalityFn(Constant *Fn); - /// \brief Check whether this function has prefix data. + /// Check whether this function has prefix data. bool hasPrefixData() const { return getSubclassDataFromValue() & (1<<1); } - /// \brief Get the prefix data associated with this function. + /// Get the prefix data associated with this function. Constant *getPrefixData() const; void setPrefixData(Constant *PrefixData); - /// \brief Check whether this function has prologue data. + /// Check whether this function has prologue data. bool hasPrologueData() const { return getSubclassDataFromValue() & (1<<2); } - /// \brief Get the prologue data associated with this function. + /// Get the prologue data associated with this function. Constant *getPrologueData() const; void setPrologueData(Constant *PrologueData); @@ -762,12 +762,12 @@ /// setjmp or other function that gcc recognizes as "returning twice". bool callsFunctionThatReturnsTwice() const; - /// \brief Set the attached subprogram. + /// Set the attached subprogram. /// /// Calls \a setMetadata() with \a LLVMContext::MD_dbg. void setSubprogram(DISubprogram *SP); - /// \brief Get the attached subprogram. + /// Get the attached subprogram. /// /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result /// to \a DISubprogram. Index: llvm/trunk/include/llvm/IR/GlobalValue.h =================================================================== --- llvm/trunk/include/llvm/IR/GlobalValue.h +++ llvm/trunk/include/llvm/IR/GlobalValue.h @@ -150,7 +150,7 @@ } protected: - /// \brief The intrinsic ID for this subclass (which must be a Function). + /// The intrinsic ID for this subclass (which must be a Function). /// /// This member is defined by this class, but not used for anything. /// Subclasses can use it to store their intrinsic ID, if they have one. Index: llvm/trunk/include/llvm/IR/IRBuilder.h =================================================================== --- llvm/trunk/include/llvm/IR/IRBuilder.h +++ llvm/trunk/include/llvm/IR/IRBuilder.h @@ -54,7 +54,7 @@ class MDNode; class Use; -/// \brief This provides the default implementation of the IRBuilder +/// This provides the default implementation of the IRBuilder /// 'InsertHelper' method that is called whenever an instruction is created by /// IRBuilder and needs to be inserted. /// @@ -85,7 +85,7 @@ } }; -/// \brief Common base class shared among various IRBuilders. +/// Common base class shared among various IRBuilders. class IRBuilderBase { DebugLoc CurDbgLocation; @@ -111,7 +111,7 @@ // Builder configuration methods //===--------------------------------------------------------------------===// - /// \brief Clear the insertion point: created instructions will not be + /// Clear the insertion point: created instructions will not be /// inserted into a block. void ClearInsertionPoint() { BB = nullptr; @@ -122,14 +122,14 @@ BasicBlock::iterator GetInsertPoint() const { return InsertPt; } LLVMContext &getContext() const { return Context; } - /// \brief This specifies that created instructions should be appended to the + /// This specifies that created instructions should be appended to the /// end of the specified block. void SetInsertPoint(BasicBlock *TheBB) { BB = TheBB; InsertPt = BB->end(); } - /// \brief This specifies that created instructions should be inserted before + /// This specifies that created instructions should be inserted before /// the specified instruction. void SetInsertPoint(Instruction *I) { BB = I->getParent(); @@ -138,7 +138,7 @@ SetCurrentDebugLocation(I->getDebugLoc()); } - /// \brief This specifies that created instructions should be inserted at the + /// This specifies that created instructions should be inserted at the /// specified point. void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) { BB = TheBB; @@ -147,20 +147,20 @@ SetCurrentDebugLocation(IP->getDebugLoc()); } - /// \brief Set location information used by debugging information. + /// Set location information used by debugging information. void SetCurrentDebugLocation(DebugLoc L) { CurDbgLocation = std::move(L); } - /// \brief Get location information used by debugging information. + /// Get location information used by debugging information. const DebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; } - /// \brief If this builder has a current debug location, set it on the + /// If this builder has a current debug location, set it on the /// specified instruction. void SetInstDebugLocation(Instruction *I) const { if (CurDbgLocation) I->setDebugLoc(CurDbgLocation); } - /// \brief Get the return type of the current function that we're emitting + /// Get the return type of the current function that we're emitting /// into. Type *getCurrentFunctionReturnType() const; @@ -170,33 +170,33 @@ BasicBlock::iterator Point; public: - /// \brief Creates a new insertion point which doesn't point to anything. + /// Creates a new insertion point which doesn't point to anything. InsertPoint() = default; - /// \brief Creates a new insertion point at the given location. + /// Creates a new insertion point at the given location. InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint) : Block(InsertBlock), Point(InsertPoint) {} - /// \brief Returns true if this insert point is set. + /// Returns true if this insert point is set. bool isSet() const { return (Block != nullptr); } BasicBlock *getBlock() const { return Block; } BasicBlock::iterator getPoint() const { return Point; } }; - /// \brief Returns the current insert point. + /// Returns the current insert point. InsertPoint saveIP() const { return InsertPoint(GetInsertBlock(), GetInsertPoint()); } - /// \brief Returns the current insert point, clearing it in the process. + /// Returns the current insert point, clearing it in the process. InsertPoint saveAndClearIP() { InsertPoint IP(GetInsertBlock(), GetInsertPoint()); ClearInsertionPoint(); return IP; } - /// \brief Sets the current insert point to a previously-saved location. + /// Sets the current insert point to a previously-saved location. void restoreIP(InsertPoint IP) { if (IP.isSet()) SetInsertPoint(IP.getBlock(), IP.getPoint()); @@ -204,26 +204,26 @@ ClearInsertionPoint(); } - /// \brief Get the floating point math metadata being used. + /// Get the floating point math metadata being used. MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; } - /// \brief Get the flags to be applied to created floating point ops + /// Get the flags to be applied to created floating point ops FastMathFlags getFastMathFlags() const { return FMF; } - /// \brief Clear the fast-math flags. + /// Clear the fast-math flags. void clearFastMathFlags() { FMF.clear(); } - /// \brief Set the floating point math metadata to be used. + /// Set the floating point math metadata to be used. void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; } - /// \brief Set the fast-math flags to be used with generated fp-math operators + /// Set the fast-math flags to be used with generated fp-math operators void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; } //===--------------------------------------------------------------------===// // RAII helpers. //===--------------------------------------------------------------------===// - // \brief RAII object that stores the current insertion point and restores it + // RAII object that stores the current insertion point and restores it // when the object is destroyed. This includes the debug location. class InsertPointGuard { IRBuilderBase &Builder; @@ -245,7 +245,7 @@ } }; - // \brief RAII object that stores the current fast math settings and restores + // RAII object that stores the current fast math settings and restores // them when the object is destroyed. class FastMathFlagGuard { IRBuilderBase &Builder; @@ -269,7 +269,7 @@ // Miscellaneous creation methods. //===--------------------------------------------------------------------===// - /// \brief Make a new global variable with initializer type i8* + /// Make a new global variable with initializer type i8* /// /// Make a new global variable with an initializer that has array of i8 type /// filled in with the null terminated string value specified. The new global @@ -278,48 +278,48 @@ GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "", unsigned AddressSpace = 0); - /// \brief Get a constant value representing either true or false. + /// Get a constant value representing either true or false. ConstantInt *getInt1(bool V) { return ConstantInt::get(getInt1Ty(), V); } - /// \brief Get the constant value for i1 true. + /// Get the constant value for i1 true. ConstantInt *getTrue() { return ConstantInt::getTrue(Context); } - /// \brief Get the constant value for i1 false. + /// Get the constant value for i1 false. ConstantInt *getFalse() { return ConstantInt::getFalse(Context); } - /// \brief Get a constant 8-bit value. + /// Get a constant 8-bit value. ConstantInt *getInt8(uint8_t C) { return ConstantInt::get(getInt8Ty(), C); } - /// \brief Get a constant 16-bit value. + /// Get a constant 16-bit value. ConstantInt *getInt16(uint16_t C) { return ConstantInt::get(getInt16Ty(), C); } - /// \brief Get a constant 32-bit value. + /// Get a constant 32-bit value. ConstantInt *getInt32(uint32_t C) { return ConstantInt::get(getInt32Ty(), C); } - /// \brief Get a constant 64-bit value. + /// Get a constant 64-bit value. ConstantInt *getInt64(uint64_t C) { return ConstantInt::get(getInt64Ty(), C); } - /// \brief Get a constant N-bit value, zero extended or truncated from + /// Get a constant N-bit value, zero extended or truncated from /// a 64-bit value. ConstantInt *getIntN(unsigned N, uint64_t C) { return ConstantInt::get(getIntNTy(N), C); } - /// \brief Get a constant integer value. + /// Get a constant integer value. ConstantInt *getInt(const APInt &AI) { return ConstantInt::get(Context, AI); } @@ -328,65 +328,65 @@ // Type creation methods //===--------------------------------------------------------------------===// - /// \brief Fetch the type representing a single bit + /// Fetch the type representing a single bit IntegerType *getInt1Ty() { return Type::getInt1Ty(Context); } - /// \brief Fetch the type representing an 8-bit integer. + /// Fetch the type representing an 8-bit integer. IntegerType *getInt8Ty() { return Type::getInt8Ty(Context); } - /// \brief Fetch the type representing a 16-bit integer. + /// Fetch the type representing a 16-bit integer. IntegerType *getInt16Ty() { return Type::getInt16Ty(Context); } - /// \brief Fetch the type representing a 32-bit integer. + /// Fetch the type representing a 32-bit integer. IntegerType *getInt32Ty() { return Type::getInt32Ty(Context); } - /// \brief Fetch the type representing a 64-bit integer. + /// Fetch the type representing a 64-bit integer. IntegerType *getInt64Ty() { return Type::getInt64Ty(Context); } - /// \brief Fetch the type representing a 128-bit integer. + /// Fetch the type representing a 128-bit integer. IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); } - /// \brief Fetch the type representing an N-bit integer. + /// Fetch the type representing an N-bit integer. IntegerType *getIntNTy(unsigned N) { return Type::getIntNTy(Context, N); } - /// \brief Fetch the type representing a 16-bit floating point value. + /// Fetch the type representing a 16-bit floating point value. Type *getHalfTy() { return Type::getHalfTy(Context); } - /// \brief Fetch the type representing a 32-bit floating point value. + /// Fetch the type representing a 32-bit floating point value. Type *getFloatTy() { return Type::getFloatTy(Context); } - /// \brief Fetch the type representing a 64-bit floating point value. + /// Fetch the type representing a 64-bit floating point value. Type *getDoubleTy() { return Type::getDoubleTy(Context); } - /// \brief Fetch the type representing void. + /// Fetch the type representing void. Type *getVoidTy() { return Type::getVoidTy(Context); } - /// \brief Fetch the type representing a pointer to an 8-bit integer value. + /// Fetch the type representing a pointer to an 8-bit integer value. PointerType *getInt8PtrTy(unsigned AddrSpace = 0) { return Type::getInt8PtrTy(Context, AddrSpace); } - /// \brief Fetch the type representing a pointer to an integer value. + /// Fetch the type representing a pointer to an integer value. IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) { return DL.getIntPtrType(Context, AddrSpace); } @@ -395,7 +395,7 @@ // Intrinsic creation methods //===--------------------------------------------------------------------===// - /// \brief Create and insert a memset to the specified pointer and the + /// Create and insert a memset to the specified pointer and the /// specified value. /// /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is @@ -414,7 +414,7 @@ MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr); - /// \brief Create and insert a memcpy between the specified pointers. + /// Create and insert a memcpy between the specified pointers. /// /// If the pointers aren't i8*, they will be converted. If a TBAA tag is /// specified, it will be added to the instruction. Likewise with alias.scope @@ -437,7 +437,7 @@ MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr); - /// \brief Create and insert an element unordered-atomic memcpy between the + /// Create and insert an element unordered-atomic memcpy between the /// specified pointers. /// /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively. @@ -461,7 +461,7 @@ MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr); - /// \brief Create and insert a memmove between the specified + /// Create and insert a memmove between the specified /// pointers. /// /// If the pointers aren't i8*, they will be converted. If a TBAA tag is @@ -480,51 +480,51 @@ MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr); - /// \brief Create a vector fadd reduction intrinsic of the source vector. + /// Create a vector fadd reduction intrinsic of the source vector. /// The first parameter is a scalar accumulator value for ordered reductions. CallInst *CreateFAddReduce(Value *Acc, Value *Src); - /// \brief Create a vector fmul reduction intrinsic of the source vector. + /// Create a vector fmul reduction intrinsic of the source vector. /// The first parameter is a scalar accumulator value for ordered reductions. CallInst *CreateFMulReduce(Value *Acc, Value *Src); - /// \brief Create a vector int add reduction intrinsic of the source vector. + /// Create a vector int add reduction intrinsic of the source vector. CallInst *CreateAddReduce(Value *Src); - /// \brief Create a vector int mul reduction intrinsic of the source vector. + /// Create a vector int mul reduction intrinsic of the source vector. CallInst *CreateMulReduce(Value *Src); - /// \brief Create a vector int AND reduction intrinsic of the source vector. + /// Create a vector int AND reduction intrinsic of the source vector. CallInst *CreateAndReduce(Value *Src); - /// \brief Create a vector int OR reduction intrinsic of the source vector. + /// Create a vector int OR reduction intrinsic of the source vector. CallInst *CreateOrReduce(Value *Src); - /// \brief Create a vector int XOR reduction intrinsic of the source vector. + /// Create a vector int XOR reduction intrinsic of the source vector. CallInst *CreateXorReduce(Value *Src); - /// \brief Create a vector integer max reduction intrinsic of the source + /// Create a vector integer max reduction intrinsic of the source /// vector. CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false); - /// \brief Create a vector integer min reduction intrinsic of the source + /// Create a vector integer min reduction intrinsic of the source /// vector. CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false); - /// \brief Create a vector float max reduction intrinsic of the source + /// Create a vector float max reduction intrinsic of the source /// vector. CallInst *CreateFPMaxReduce(Value *Src, bool NoNaN = false); - /// \brief Create a vector float min reduction intrinsic of the source + /// Create a vector float min reduction intrinsic of the source /// vector. CallInst *CreateFPMinReduce(Value *Src, bool NoNaN = false); - /// \brief Create a lifetime.start intrinsic. + /// Create a lifetime.start intrinsic. /// /// If the pointer isn't i8* it will be converted. CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr); - /// \brief Create a lifetime.end intrinsic. + /// Create a lifetime.end intrinsic. /// /// If the pointer isn't i8* it will be converted. CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr); @@ -534,29 +534,29 @@ /// If the pointer isn't i8* it will be converted. CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr); - /// \brief Create a call to Masked Load intrinsic + /// Create a call to Masked Load intrinsic CallInst *CreateMaskedLoad(Value *Ptr, unsigned Align, Value *Mask, Value *PassThru = nullptr, const Twine &Name = ""); - /// \brief Create a call to Masked Store intrinsic + /// Create a call to Masked Store intrinsic CallInst *CreateMaskedStore(Value *Val, Value *Ptr, unsigned Align, Value *Mask); - /// \brief Create a call to Masked Gather intrinsic + /// Create a call to Masked Gather intrinsic CallInst *CreateMaskedGather(Value *Ptrs, unsigned Align, Value *Mask = nullptr, Value *PassThru = nullptr, const Twine& Name = ""); - /// \brief Create a call to Masked Scatter intrinsic + /// Create a call to Masked Scatter intrinsic CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Align, Value *Mask = nullptr); - /// \brief Create an assume intrinsic call that allows the optimizer to + /// Create an assume intrinsic call that allows the optimizer to /// assume that the provided condition will be true. CallInst *CreateAssumption(Value *Cond); - /// \brief Create a call to the experimental.gc.statepoint intrinsic to + /// Create a call to the experimental.gc.statepoint intrinsic to /// start a new statepoint sequence. CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee, @@ -565,7 +565,7 @@ ArrayRef GCArgs, const Twine &Name = ""); - /// \brief Create a call to the experimental.gc.statepoint intrinsic to + /// Create a call to the experimental.gc.statepoint intrinsic to /// start a new statepoint sequence. CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee, uint32_t Flags, @@ -575,7 +575,7 @@ ArrayRef GCArgs, const Twine &Name = ""); - /// \brief Conveninence function for the common case when CallArgs are filled + /// Conveninence function for the common case when CallArgs are filled /// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be /// .get()'ed to get the Value pointer. CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, @@ -584,7 +584,7 @@ ArrayRef GCArgs, const Twine &Name = ""); - /// \brief Create an invoke to the experimental.gc.statepoint intrinsic to + /// Create an invoke to the experimental.gc.statepoint intrinsic to /// start a new statepoint sequence. InvokeInst * CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes, @@ -593,7 +593,7 @@ ArrayRef DeoptArgs, ArrayRef GCArgs, const Twine &Name = ""); - /// \brief Create an invoke to the experimental.gc.statepoint intrinsic to + /// Create an invoke to the experimental.gc.statepoint intrinsic to /// start a new statepoint sequence. InvokeInst *CreateGCStatepointInvoke( uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee, @@ -612,13 +612,13 @@ ArrayRef DeoptArgs, ArrayRef GCArgs, const Twine &Name = ""); - /// \brief Create a call to the experimental.gc.result intrinsic to extract + /// Create a call to the experimental.gc.result intrinsic to extract /// the result from a call wrapped in a statepoint. CallInst *CreateGCResult(Instruction *Statepoint, Type *ResultType, const Twine &Name = ""); - /// \brief Create a call to the experimental.gc.relocate intrinsics to + /// Create a call to the experimental.gc.relocate intrinsics to /// project the relocated value of one pointer from the statepoint. CallInst *CreateGCRelocate(Instruction *Statepoint, int BaseOffset, @@ -650,7 +650,7 @@ } private: - /// \brief Create a call to a masked intrinsic with given Id. + /// Create a call to a masked intrinsic with given Id. CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef Ops, ArrayRef OverloadedTypes, const Twine &Name = ""); @@ -658,7 +658,7 @@ Value *getCastedInt8PtrValue(Value *Ptr); }; -/// \brief This provides a uniform API for creating instructions and inserting +/// This provides a uniform API for creating instructions and inserting /// them into a basic block: either at the end of a BasicBlock, or at a specific /// iterator location in a block. /// @@ -720,10 +720,10 @@ SetInsertPoint(TheBB, IP); } - /// \brief Get the constant folder being used. + /// Get the constant folder being used. const T &getFolder() { return Folder; } - /// \brief Insert and return the specified instruction. + /// Insert and return the specified instruction. template InstTy *Insert(InstTy *I, const Twine &Name = "") const { this->InsertHelper(I, Name, BB, InsertPt); @@ -731,7 +731,7 @@ return I; } - /// \brief No-op overload to handle constants. + /// No-op overload to handle constants. Constant *Insert(Constant *C, const Twine& = "") const { return C; } @@ -741,7 +741,7 @@ //===--------------------------------------------------------------------===// private: - /// \brief Helper to add branch weight and unpredictable metadata onto an + /// Helper to add branch weight and unpredictable metadata onto an /// instruction. /// \returns The annotated instruction. template @@ -754,17 +754,17 @@ } public: - /// \brief Create a 'ret void' instruction. + /// Create a 'ret void' instruction. ReturnInst *CreateRetVoid() { return Insert(ReturnInst::Create(Context)); } - /// \brief Create a 'ret ' instruction. + /// Create a 'ret ' instruction. ReturnInst *CreateRet(Value *V) { return Insert(ReturnInst::Create(Context, V)); } - /// \brief Create a sequence of N insertvalue instructions, + /// Create a sequence of N insertvalue instructions, /// with one Value from the retVals array each, that build a aggregate /// return value one value at a time, and a ret instruction to return /// the resulting aggregate value. @@ -778,12 +778,12 @@ return Insert(ReturnInst::Create(Context, V)); } - /// \brief Create an unconditional 'br label X' instruction. + /// Create an unconditional 'br label X' instruction. BranchInst *CreateBr(BasicBlock *Dest) { return Insert(BranchInst::Create(Dest)); } - /// \brief Create a conditional 'br Cond, TrueDest, FalseDest' + /// Create a conditional 'br Cond, TrueDest, FalseDest' /// instruction. BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights = nullptr, @@ -792,7 +792,7 @@ BranchWeights, Unpredictable)); } - /// \brief Create a conditional 'br Cond, TrueDest, FalseDest' + /// Create a conditional 'br Cond, TrueDest, FalseDest' /// instruction. Copy branch meta data if available. BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, Instruction *MDSrc) { @@ -805,7 +805,7 @@ return Insert(Br); } - /// \brief Create a switch instruction with the specified value, default dest, + /// Create a switch instruction with the specified value, default dest, /// and with a hint for the number of cases that will be added (for efficient /// allocation). SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10, @@ -815,14 +815,14 @@ BranchWeights, Unpredictable)); } - /// \brief Create an indirect branch instruction with the specified address + /// Create an indirect branch instruction with the specified address /// operand, with an optional hint for the number of destinations that will be /// added (for efficient allocation). IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) { return Insert(IndirectBrInst::Create(Addr, NumDests)); } - /// \brief Create an invoke instruction. + /// Create an invoke instruction. InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef Args = None, @@ -1246,7 +1246,7 @@ return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name); } - /// \brief Provided to resolve 'CreateLoad(Ptr, "...")' correctly, instead of + /// Provided to resolve 'CreateLoad(Ptr, "...")' correctly, instead of /// converting the string to 'bool' for the isVolatile parameter. LoadInst *CreateLoad(Value *Ptr, const char *Name) { return Insert(new LoadInst(Ptr), Name); @@ -1268,7 +1268,7 @@ return Insert(new StoreInst(Val, Ptr, isVolatile)); } - /// \brief Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")' + /// Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")' /// correctly, instead of converting the string to 'bool' for the isVolatile /// parameter. LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) { @@ -1476,7 +1476,7 @@ return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name); } - /// \brief Same as CreateGlobalString, but return a pointer with "i8*" type + /// Same as CreateGlobalString, but return a pointer with "i8*" type /// instead of a pointer to array of i8. Value *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "", unsigned AddressSpace = 0) { @@ -1502,7 +1502,7 @@ return CreateCast(Instruction::SExt, V, DestTy, Name); } - /// \brief Create a ZExt or Trunc from the integer value V to DestTy. Return + /// Create a ZExt or Trunc from the integer value V to DestTy. Return /// the value untouched if the type of V is already DestTy. Value *CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name = "") { @@ -1517,7 +1517,7 @@ return V; } - /// \brief Create a SExt or Trunc from the integer value V to DestTy. Return + /// Create a SExt or Trunc from the integer value V to DestTy. Return /// the value untouched if the type of V is already DestTy. Value *CreateSExtOrTrunc(Value *V, Type *DestTy, const Twine &Name = "") { @@ -1665,7 +1665,7 @@ return Insert(CastInst::CreateFPCast(V, DestTy), Name); } - // \brief Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a + // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a // compile time error, instead of converting the string to bool for the // isSigned parameter. Value *CreateIntCast(Value *, Type *, const char *) = delete; @@ -1927,19 +1927,19 @@ // Utility creation methods //===--------------------------------------------------------------------===// - /// \brief Return an i1 value testing if \p Arg is null. + /// 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); } - /// \brief Return an i1 value testing if \p Arg is not null. + /// 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); } - /// \brief Return the i64 difference between two pointer values, dividing out + /// Return the i64 difference between two pointer values, dividing out /// the size of the pointed-to objects. /// /// This is intended to implement C-style pointer subtraction. As such, the @@ -1957,7 +1957,7 @@ Name); } - /// \brief Create an invariant.group.barrier intrinsic call, that stops + /// Create an invariant.group.barrier intrinsic call, that stops /// optimizer to propagate equality using invariant.group metadata. /// If Ptr type is different from pointer to i8, it's casted to pointer to i8 /// in the same address space before call and casted back to Ptr type after @@ -1985,7 +1985,7 @@ return Fn; } - /// \brief Return a vector value that contains \arg V broadcasted to \p + /// Return a vector value that contains \arg V broadcasted to \p /// NumElts elements. Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "") { assert(NumElts > 0 && "Cannot splat to an empty vector!"); @@ -2001,7 +2001,7 @@ return CreateShuffleVector(V, Undef, Zeros, Name + ".splat"); } - /// \brief Return a value that has been extracted from a larger integer type. + /// Return a value that has been extracted from a larger integer type. Value *CreateExtractInteger(const DataLayout &DL, Value *From, IntegerType *ExtractedTy, uint64_t Offset, const Twine &Name) { @@ -2026,7 +2026,7 @@ } private: - /// \brief Helper function that creates an assume intrinsic call that + /// Helper function that creates an assume intrinsic call that /// represents an alignment assumption on the provided Ptr, Mask, Type /// and Offset. CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL, @@ -2055,7 +2055,7 @@ } public: - /// \brief Create an assume intrinsic call that represents an alignment + /// Create an assume intrinsic call that represents an alignment /// assumption on the provided pointer. /// /// An optional offset can be provided, and if it is provided, the offset @@ -2074,7 +2074,7 @@ OffsetValue); } - /// \brief Create an assume intrinsic call that represents an alignment + /// Create an assume intrinsic call that represents an alignment /// assumption on the provided pointer. /// /// An optional offset can be provided, and if it is provided, the offset Index: llvm/trunk/include/llvm/IR/IRPrintingPasses.h =================================================================== --- llvm/trunk/include/llvm/IR/IRPrintingPasses.h +++ llvm/trunk/include/llvm/IR/IRPrintingPasses.h @@ -32,18 +32,18 @@ class raw_ostream; template class AnalysisManager; -/// \brief Create and return a pass that writes the module to the specified +/// Create and return a pass that writes the module to the specified /// \c raw_ostream. ModulePass *createPrintModulePass(raw_ostream &OS, const std::string &Banner = "", bool ShouldPreserveUseListOrder = false); -/// \brief Create and return a pass that prints functions to the specified +/// Create and return a pass that prints functions to the specified /// \c raw_ostream as they are processed. FunctionPass *createPrintFunctionPass(raw_ostream &OS, const std::string &Banner = ""); -/// \brief Create and return a pass that writes the BB to the specified +/// Create and return a pass that writes the BB to the specified /// \c raw_ostream. BasicBlockPass *createPrintBasicBlockPass(raw_ostream &OS, const std::string &Banner = ""); @@ -54,7 +54,7 @@ /// non-printable characters in it. void printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name); -/// \brief Pass for printing a Module as LLVM's text IR assembly. +/// Pass for printing a Module as LLVM's text IR assembly. /// /// Note: This pass is for use with the new pass manager. Use the create...Pass /// functions above to create passes for use with the legacy pass manager. @@ -73,7 +73,7 @@ static StringRef name() { return "PrintModulePass"; } }; -/// \brief Pass for printing a Function as LLVM's text IR assembly. +/// Pass for printing a Function as LLVM's text IR assembly. /// /// Note: This pass is for use with the new pass manager. Use the create...Pass /// functions above to create passes for use with the legacy pass manager. Index: llvm/trunk/include/llvm/IR/InstrTypes.h =================================================================== --- llvm/trunk/include/llvm/IR/InstrTypes.h +++ llvm/trunk/include/llvm/IR/InstrTypes.h @@ -81,7 +81,7 @@ return isa(V) && classof(cast(V)); } - // \brief Returns true if this terminator relates to exception handling. + // Returns true if this terminator relates to exception handling. bool isExceptional() const { switch (getOpcode()) { case Instruction::CatchSwitch: @@ -118,7 +118,7 @@ return idx < TermInst->getNumSuccessors(); } - /// \brief Proxy object to allow write access in operator[] + /// Proxy object to allow write access in operator[] class SuccessorProxy { Self it; @@ -1181,7 +1181,7 @@ /// Convenience accessors - /// \brief Return the outer EH-pad this funclet is nested within. + /// Return the outer EH-pad this funclet is nested within. /// /// Note: This returns the associated CatchSwitchInst if this FuncletPadInst /// is a CatchPadInst. @@ -1217,7 +1217,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value) -/// \brief A lightweight accessor for an operand bundle meant to be passed +/// A lightweight accessor for an operand bundle meant to be passed /// around by value. struct OperandBundleUse { ArrayRef Inputs; @@ -1226,7 +1226,7 @@ explicit OperandBundleUse(StringMapEntry *Tag, ArrayRef Inputs) : Inputs(Inputs), Tag(Tag) {} - /// \brief Return true if the operand at index \p Idx in this operand bundle + /// Return true if the operand at index \p Idx in this operand bundle /// has the attribute A. bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const { if (isDeoptOperandBundle()) @@ -1237,12 +1237,12 @@ return false; } - /// \brief Return the tag of this operand bundle as a string. + /// Return the tag of this operand bundle as a string. StringRef getTagName() const { return Tag->getKey(); } - /// \brief Return the tag of this operand bundle as an integer. + /// Return the tag of this operand bundle as an integer. /// /// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag, /// and this function returns the unique integer getOrInsertBundleTag @@ -1251,22 +1251,22 @@ return Tag->getValue(); } - /// \brief Return true if this is a "deopt" operand bundle. + /// Return true if this is a "deopt" operand bundle. bool isDeoptOperandBundle() const { return getTagID() == LLVMContext::OB_deopt; } - /// \brief Return true if this is a "funclet" operand bundle. + /// Return true if this is a "funclet" operand bundle. bool isFuncletOperandBundle() const { return getTagID() == LLVMContext::OB_funclet; } private: - /// \brief Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag. + /// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag. StringMapEntry *Tag; }; -/// \brief A container for an operand bundle being viewed as a set of values +/// A container for an operand bundle being viewed as a set of values /// rather than a set of uses. /// /// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and @@ -1301,7 +1301,7 @@ using OperandBundleDef = OperandBundleDefT; using ConstOperandBundleDef = OperandBundleDefT; -/// \brief A mixin to add operand bundle functionality to llvm instruction +/// A mixin to add operand bundle functionality to llvm instruction /// classes. /// /// OperandBundleUser uses the descriptor area co-allocated with the host User @@ -1349,21 +1349,21 @@ /// Currently operand bundle users with hung-off operands are not supported. template class OperandBundleUser { public: - /// \brief Return the number of operand bundles associated with this User. + /// Return the number of operand bundles associated with this User. unsigned getNumOperandBundles() const { return std::distance(bundle_op_info_begin(), bundle_op_info_end()); } - /// \brief Return true if this User has any operand bundles. + /// Return true if this User has any operand bundles. bool hasOperandBundles() const { return getNumOperandBundles() != 0; } - /// \brief Return the index of the first bundle operand in the Use array. + /// Return the index of the first bundle operand in the Use array. unsigned getBundleOperandsStartIndex() const { assert(hasOperandBundles() && "Don't call otherwise!"); return bundle_op_info_begin()->Begin; } - /// \brief Return the index of the last bundle operand in the Use array. + /// Return the index of the last bundle operand in the Use array. unsigned getBundleOperandsEndIndex() const { assert(hasOperandBundles() && "Don't call otherwise!"); return bundle_op_info_end()[-1].End; @@ -1375,7 +1375,7 @@ Idx < getBundleOperandsEndIndex(); } - /// \brief Return the total number operands (not operand bundles) used by + /// Return the total number operands (not operand bundles) used by /// every operand bundle in this OperandBundleUser. unsigned getNumTotalBundleOperands() const { if (!hasOperandBundles()) @@ -1388,13 +1388,13 @@ return End - Begin; } - /// \brief Return the operand bundle at a specific index. + /// Return the operand bundle at a specific index. OperandBundleUse getOperandBundleAt(unsigned Index) const { assert(Index < getNumOperandBundles() && "Index out of bounds!"); return operandBundleFromBundleOpInfo(*(bundle_op_info_begin() + Index)); } - /// \brief Return the number of operand bundles with the tag Name attached to + /// Return the number of operand bundles with the tag Name attached to /// this instruction. unsigned countOperandBundlesOfType(StringRef Name) const { unsigned Count = 0; @@ -1405,7 +1405,7 @@ return Count; } - /// \brief Return the number of operand bundles with the tag ID attached to + /// Return the number of operand bundles with the tag ID attached to /// this instruction. unsigned countOperandBundlesOfType(uint32_t ID) const { unsigned Count = 0; @@ -1416,7 +1416,7 @@ return Count; } - /// \brief Return an operand bundle by name, if present. + /// Return an operand bundle by name, if present. /// /// It is an error to call this for operand bundle types that may have /// multiple instances of them on the same instruction. @@ -1432,7 +1432,7 @@ return None; } - /// \brief Return an operand bundle by tag ID, if present. + /// Return an operand bundle by tag ID, if present. /// /// It is an error to call this for operand bundle types that may have /// multiple instances of them on the same instruction. @@ -1448,7 +1448,7 @@ return None; } - /// \brief Return the list of operand bundles attached to this instruction as + /// Return the list of operand bundles attached to this instruction as /// a vector of OperandBundleDefs. /// /// This function copies the OperandBundeUse instances associated with this @@ -1460,7 +1460,7 @@ Defs.emplace_back(getOperandBundleAt(i)); } - /// \brief Return the operand bundle for the operand at index OpIdx. + /// Return the operand bundle for the operand at index OpIdx. /// /// It is an error to call this with an OpIdx that does not correspond to an /// bundle operand. @@ -1468,7 +1468,7 @@ return operandBundleFromBundleOpInfo(getBundleOpInfoForOperand(OpIdx)); } - /// \brief Return true if this operand bundle user has operand bundles that + /// Return true if this operand bundle user has operand bundles that /// may read from the heap. bool hasReadingOperandBundles() const { // Implementation note: this is a conservative implementation of operand @@ -1477,7 +1477,7 @@ return hasOperandBundles(); } - /// \brief Return true if this operand bundle user has operand bundles that + /// Return true if this operand bundle user has operand bundles that /// may write to the heap. bool hasClobberingOperandBundles() const { for (auto &BOI : bundle_op_infos()) { @@ -1493,7 +1493,7 @@ return false; } - /// \brief Return true if the bundle operand at index \p OpIdx has the + /// Return true if the bundle operand at index \p OpIdx has the /// attribute \p A. bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const { auto &BOI = getBundleOpInfoForOperand(OpIdx); @@ -1501,7 +1501,7 @@ return OBU.operandHasAttr(OpIdx - BOI.Begin, A); } - /// \brief Return true if \p Other has the same sequence of operand bundle + /// Return true if \p Other has the same sequence of operand bundle /// tags with the same number of operands on each one of them as this /// OperandBundleUser. bool hasIdenticalOperandBundleSchema( @@ -1513,7 +1513,7 @@ Other.bundle_op_info_begin()); } - /// \brief Return true if this operand bundle user contains operand bundles + /// Return true if this operand bundle user contains operand bundles /// with tags other than those specified in \p IDs. bool hasOperandBundlesOtherThan(ArrayRef IDs) const { for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) { @@ -1525,7 +1525,7 @@ } protected: - /// \brief Is the function attribute S disallowed by some operand bundle on + /// Is the function attribute S disallowed by some operand bundle on /// this operand bundle user? bool isFnAttrDisallowedByOpBundle(StringRef S) const { // Operand bundles only possibly disallow readnone, readonly and argmenonly @@ -1533,7 +1533,7 @@ return false; } - /// \brief Is the function attribute A disallowed by some operand bundle on + /// Is the function attribute A disallowed by some operand bundle on /// this operand bundle user? bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const { switch (A) { @@ -1559,18 +1559,18 @@ llvm_unreachable("switch has a default case!"); } - /// \brief Used to keep track of an operand bundle. See the main comment on + /// Used to keep track of an operand bundle. See the main comment on /// OperandBundleUser above. struct BundleOpInfo { - /// \brief The operand bundle tag, interned by + /// The operand bundle tag, interned by /// LLVMContextImpl::getOrInsertBundleTag. StringMapEntry *Tag; - /// \brief The index in the Use& vector where operands for this operand + /// The index in the Use& vector where operands for this operand /// bundle starts. uint32_t Begin; - /// \brief The index in the Use& vector where operands for this operand + /// The index in the Use& vector where operands for this operand /// bundle ends. uint32_t End; @@ -1579,7 +1579,7 @@ } }; - /// \brief Simple helper function to map a BundleOpInfo to an + /// Simple helper function to map a BundleOpInfo to an /// OperandBundleUse. OperandBundleUse operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const { @@ -1591,7 +1591,7 @@ using bundle_op_iterator = BundleOpInfo *; using const_bundle_op_iterator = const BundleOpInfo *; - /// \brief Return the start of the list of BundleOpInfo instances associated + /// Return the start of the list of BundleOpInfo instances associated /// with this OperandBundleUser. bundle_op_iterator bundle_op_info_begin() { if (!static_cast(this)->hasDescriptor()) @@ -1601,7 +1601,7 @@ return reinterpret_cast(BytesBegin); } - /// \brief Return the start of the list of BundleOpInfo instances associated + /// Return the start of the list of BundleOpInfo instances associated /// with this OperandBundleUser. const_bundle_op_iterator bundle_op_info_begin() const { auto *NonConstThis = @@ -1609,7 +1609,7 @@ return NonConstThis->bundle_op_info_begin(); } - /// \brief Return the end of the list of BundleOpInfo instances associated + /// Return the end of the list of BundleOpInfo instances associated /// with this OperandBundleUser. bundle_op_iterator bundle_op_info_end() { if (!static_cast(this)->hasDescriptor()) @@ -1619,7 +1619,7 @@ return reinterpret_cast(BytesEnd); } - /// \brief Return the end of the list of BundleOpInfo instances associated + /// Return the end of the list of BundleOpInfo instances associated /// with this OperandBundleUser. const_bundle_op_iterator bundle_op_info_end() const { auto *NonConstThis = @@ -1627,17 +1627,17 @@ return NonConstThis->bundle_op_info_end(); } - /// \brief Return the range [\p bundle_op_info_begin, \p bundle_op_info_end). + /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end). iterator_range bundle_op_infos() { return make_range(bundle_op_info_begin(), bundle_op_info_end()); } - /// \brief Return the range [\p bundle_op_info_begin, \p bundle_op_info_end). + /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end). iterator_range bundle_op_infos() const { return make_range(bundle_op_info_begin(), bundle_op_info_end()); } - /// \brief Populate the BundleOpInfo instances and the Use& vector from \p + /// Populate the BundleOpInfo instances and the Use& vector from \p /// Bundles. Return the op_iterator pointing to the Use& one past the last /// last bundle operand use. /// @@ -1668,7 +1668,7 @@ return It; } - /// \brief Return the BundleOpInfo for the operand at index OpIdx. + /// Return the BundleOpInfo for the operand at index OpIdx. /// /// It is an error to call this with an OpIdx that does not correspond to an /// bundle operand. @@ -1680,7 +1680,7 @@ llvm_unreachable("Did not find operand bundle for operand!"); } - /// \brief Return the total number of values used in \p Bundles. + /// Return the total number of values used in \p Bundles. static unsigned CountBundleInputs(ArrayRef Bundles) { unsigned Total = 0; for (auto &B : Bundles) Index: llvm/trunk/include/llvm/IR/IntrinsicsWebAssembly.td =================================================================== --- llvm/trunk/include/llvm/IR/IntrinsicsWebAssembly.td +++ llvm/trunk/include/llvm/IR/IntrinsicsWebAssembly.td @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief This file defines all of the WebAssembly-specific intrinsics. +/// This file defines all of the WebAssembly-specific intrinsics. /// //===----------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/IR/LLVMContext.h =================================================================== --- llvm/trunk/include/llvm/IR/LLVMContext.h +++ llvm/trunk/include/llvm/IR/LLVMContext.h @@ -229,23 +229,23 @@ /// to caller. std::unique_ptr getDiagnosticHandler(); - /// \brief Return if a code hotness metric should be included in optimization + /// Return if a code hotness metric should be included in optimization /// diagnostics. bool getDiagnosticsHotnessRequested() const; - /// \brief Set if a code hotness metric should be included in optimization + /// Set if a code hotness metric should be included in optimization /// diagnostics. void setDiagnosticsHotnessRequested(bool Requested); - /// \brief Return the minimum hotness value a diagnostic would need in order + /// Return the minimum hotness value a diagnostic would need in order /// to be included in optimization diagnostics. If there is no minimum, this /// returns None. uint64_t getDiagnosticsHotnessThreshold() const; - /// \brief Set the minimum hotness value a diagnostic needs in order to be + /// Set the minimum hotness value a diagnostic needs in order to be /// included in optimization diagnostics. void setDiagnosticsHotnessThreshold(uint64_t Threshold); - /// \brief Return the YAML file used by the backend to save optimization + /// Return the YAML file used by the backend to save optimization /// diagnostics. If null, diagnostics are not saved in a file but only /// emitted via the diagnostic handler. yaml::Output *getDiagnosticsOutputFile(); @@ -256,11 +256,11 @@ /// set, the handler is invoked for each diagnostic message. void setDiagnosticsOutputFile(std::unique_ptr F); - /// \brief Get the prefix that should be printed in front of a diagnostic of + /// Get the prefix that should be printed in front of a diagnostic of /// the given \p Severity static const char *getDiagnosticMessagePrefix(DiagnosticSeverity Severity); - /// \brief Report a message to the currently installed diagnostic handler. + /// Report a message to the currently installed diagnostic handler. /// /// This function returns, in particular in the case of error reporting /// (DI.Severity == \a DS_Error), so the caller should leave the compilation @@ -272,7 +272,7 @@ /// "warning: " for \a DS_Warning, and "note: " for \a DS_Note. void diagnose(const DiagnosticInfo &DI); - /// \brief Registers a yield callback with the given context. + /// Registers a yield callback with the given context. /// /// The yield callback function may be called by LLVM to transfer control back /// to the client that invoked the LLVM compilation. This can be used to yield @@ -291,7 +291,7 @@ /// control to LLVM. Other LLVM contexts are unaffected by this restriction. void setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle); - /// \brief Calls the yield callback (if applicable). + /// Calls the yield callback (if applicable). /// /// This transfers control of the current thread back to the client, which may /// suspend the current thread. Only call this method when LLVM doesn't hold @@ -307,7 +307,7 @@ void emitError(const Instruction *I, const Twine &ErrorStr); void emitError(const Twine &ErrorStr); - /// \brief Query for a debug option's value. + /// Query for a debug option's value. /// /// This function returns typed data populated from command line parsing. template @@ -315,11 +315,11 @@ return OptionRegistry::instance().template get(); } - /// \brief Access the object which can disable optional passes and individual + /// Access the object which can disable optional passes and individual /// optimizations at compile time. OptPassGate &getOptPassGate() const; - /// \brief Set the object which can disable optional passes and individual + /// Set the object which can disable optional passes and individual /// optimizations at compile time. /// /// The lifetime of the object must be guaranteed to extend as long as the Index: llvm/trunk/include/llvm/IR/MDBuilder.h =================================================================== --- llvm/trunk/include/llvm/IR/MDBuilder.h +++ llvm/trunk/include/llvm/IR/MDBuilder.h @@ -38,17 +38,17 @@ public: MDBuilder(LLVMContext &context) : Context(context) {} - /// \brief Return the given string as metadata. + /// Return the given string as metadata. MDString *createString(StringRef Str); - /// \brief Return the given constant as metadata. + /// Return the given constant as metadata. ConstantAsMetadata *createConstant(Constant *C); //===------------------------------------------------------------------===// // FPMath metadata. //===------------------------------------------------------------------===// - /// \brief Return metadata with the given settings. The special value 0.0 + /// Return metadata with the given settings. The special value 0.0 /// for the Accuracy parameter indicates the default (maximal precision) /// setting. MDNode *createFPMath(float Accuracy); @@ -57,10 +57,10 @@ // Prof metadata. //===------------------------------------------------------------------===// - /// \brief Return metadata containing two branch weights. + /// Return metadata containing two branch weights. MDNode *createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight); - /// \brief Return metadata containing a number of branch weights. + /// Return metadata containing a number of branch weights. MDNode *createBranchWeights(ArrayRef Weights); /// Return metadata specifying that a branch or switch is unpredictable. @@ -80,17 +80,17 @@ // Range metadata. //===------------------------------------------------------------------===// - /// \brief Return metadata describing the range [Lo, Hi). + /// Return metadata describing the range [Lo, Hi). MDNode *createRange(const APInt &Lo, const APInt &Hi); - /// \brief Return metadata describing the range [Lo, Hi). + /// Return metadata describing the range [Lo, Hi). MDNode *createRange(Constant *Lo, Constant *Hi); //===------------------------------------------------------------------===// // Callees metadata. //===------------------------------------------------------------------===// - /// \brief Return metadata indicating the possible callees of indirect + /// Return metadata indicating the possible callees of indirect /// calls. MDNode *createCallees(ArrayRef Callees); @@ -99,28 +99,28 @@ //===------------------------------------------------------------------===// protected: - /// \brief Return metadata appropriate for a AA root node (scope or TBAA). + /// Return metadata appropriate for a AA root node (scope or TBAA). /// Each returned node is distinct from all other metadata and will never /// be identified (uniqued) with anything else. MDNode *createAnonymousAARoot(StringRef Name = StringRef(), MDNode *Extra = nullptr); public: - /// \brief Return metadata appropriate for a TBAA root node. Each returned + /// Return metadata appropriate for a TBAA root node. Each returned /// node is distinct from all other metadata and will never be identified /// (uniqued) with anything else. MDNode *createAnonymousTBAARoot() { return createAnonymousAARoot(); } - /// \brief Return metadata appropriate for an alias scope domain node. + /// Return metadata appropriate for an alias scope domain node. /// Each returned node is distinct from all other metadata and will never /// be identified (uniqued) with anything else. MDNode *createAnonymousAliasScopeDomain(StringRef Name = StringRef()) { return createAnonymousAARoot(Name); } - /// \brief Return metadata appropriate for an alias scope root node. + /// Return metadata appropriate for an alias scope root node. /// Each returned node is distinct from all other metadata and will never /// be identified (uniqued) with anything else. MDNode *createAnonymousAliasScope(MDNode *Domain, @@ -128,22 +128,22 @@ return createAnonymousAARoot(Name, Domain); } - /// \brief Return metadata appropriate for a TBAA root node with the given + /// Return metadata appropriate for a TBAA root node with the given /// name. This may be identified (uniqued) with other roots with the same /// name. MDNode *createTBAARoot(StringRef Name); - /// \brief Return metadata appropriate for an alias scope domain node with + /// Return metadata appropriate for an alias scope domain node with /// the given name. This may be identified (uniqued) with other roots with /// the same name. MDNode *createAliasScopeDomain(StringRef Name); - /// \brief Return metadata appropriate for an alias scope node with + /// Return metadata appropriate for an alias scope node with /// the given name. This may be identified (uniqued) with other scopes with /// the same name and domain. MDNode *createAliasScope(StringRef Name, MDNode *Domain); - /// \brief Return metadata for a non-root TBAA node with the given name, + /// Return metadata for a non-root TBAA node with the given name, /// parent in the TBAA tree, and value for 'pointsToConstantMemory'. MDNode *createTBAANode(StringRef Name, MDNode *Parent, bool isConstant = false); @@ -156,33 +156,33 @@ Offset(Offset), Size(Size), Type(Type) {} }; - /// \brief Return metadata for a tbaa.struct node with the given + /// Return metadata for a tbaa.struct node with the given /// struct field descriptions. MDNode *createTBAAStructNode(ArrayRef Fields); - /// \brief Return metadata for a TBAA struct node in the type DAG + /// Return metadata for a TBAA struct node in the type DAG /// with the given name, a list of pairs (offset, field type in the type DAG). MDNode * createTBAAStructTypeNode(StringRef Name, ArrayRef> Fields); - /// \brief Return metadata for a TBAA scalar type node with the + /// Return metadata for a TBAA scalar type node with the /// given name, an offset and a parent in the TBAA type DAG. MDNode *createTBAAScalarTypeNode(StringRef Name, MDNode *Parent, uint64_t Offset = 0); - /// \brief Return metadata for a TBAA tag node with the given + /// Return metadata for a TBAA tag node with the given /// base type, access type and offset relative to the base type. MDNode *createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType, uint64_t Offset, bool IsConstant = false); - /// \brief Return metadata for a TBAA type node in the TBAA type DAG with the + /// Return metadata for a TBAA type node in the TBAA type DAG with the /// given parent type, size in bytes, type identifier and a list of fields. MDNode *createTBAATypeNode(MDNode *Parent, uint64_t Size, Metadata *Id, ArrayRef Fields = ArrayRef()); - /// \brief Return metadata for a TBAA access tag with the given base type, + /// Return metadata for a TBAA access tag with the given base type, /// final access type, offset of the access relative to the base type, size of /// the access and flag indicating whether the accessed object can be /// considered immutable for the purposes of the TBAA analysis. @@ -190,11 +190,11 @@ uint64_t Offset, uint64_t Size, bool IsImmutable = false); - /// \brief Return mutable version of the given mutable or immutable TBAA + /// Return mutable version of the given mutable or immutable TBAA /// access tag. MDNode *createMutableTBAAAccessTag(MDNode *Tag); - /// \brief Return metadata containing an irreducible loop header weight. + /// Return metadata containing an irreducible loop header weight. MDNode *createIrrLoopHeaderWeight(uint64_t Weight); }; Index: llvm/trunk/include/llvm/IR/Metadata.h =================================================================== --- llvm/trunk/include/llvm/IR/Metadata.h +++ llvm/trunk/include/llvm/IR/Metadata.h @@ -52,20 +52,20 @@ DEBUG_METADATA_VERSION = 3 // Current debug info version number. }; -/// \brief Root of the metadata hierarchy. +/// Root of the metadata hierarchy. /// /// This is a root class for typeless data in the IR. class Metadata { friend class ReplaceableMetadataImpl; - /// \brief RTTI. + /// RTTI. const unsigned char SubclassID; protected: - /// \brief Active type of storage. + /// Active type of storage. enum StorageType { Uniqued, Distinct, Temporary }; - /// \brief Storage flag for non-uniqued, otherwise unowned, metadata. + /// Storage flag for non-uniqued, otherwise unowned, metadata. unsigned char Storage; // TODO: expose remaining bits to subclasses. @@ -86,7 +86,7 @@ ~Metadata() = default; - /// \brief Default handling of a changed operand, which asserts. + /// Default handling of a changed operand, which asserts. /// /// If subclasses pass themselves in as owners to a tracking node reference, /// they must provide an implementation of this method. @@ -97,7 +97,7 @@ public: unsigned getMetadataID() const { return SubclassID; } - /// \brief User-friendly dump. + /// User-friendly dump. /// /// If \c M is provided, metadata nodes will be numbered canonically; /// otherwise, pointer addresses are substituted. @@ -110,7 +110,7 @@ void dump(const Module *M) const; /// @} - /// \brief Print. + /// Print. /// /// Prints definition of \c this. /// @@ -123,7 +123,7 @@ bool IsForDebug = false) const; /// @} - /// \brief Print as operand. + /// Print as operand. /// /// Prints reference of \c this. /// @@ -162,7 +162,7 @@ return OS; } -/// \brief Metadata wrapper in the Value hierarchy. +/// Metadata wrapper in the Value hierarchy. /// /// A member of the \a Value hierarchy to represent a reference to metadata. /// This allows, e.g., instrinsics to have metadata as operands. @@ -177,7 +177,7 @@ MetadataAsValue(Type *Ty, Metadata *MD); - /// \brief Drop use of metadata (during teardown). + /// Drop use of metadata (during teardown). void dropUse() { MD = nullptr; } public: @@ -198,7 +198,7 @@ void untrack(); }; -/// \brief API for tracking metadata references through RAUW and deletion. +/// API for tracking metadata references through RAUW and deletion. /// /// Shared API for updating \a Metadata pointers in subclasses that support /// RAUW. @@ -207,7 +207,7 @@ /// user-friendly tracking reference. class MetadataTracking { public: - /// \brief Track the reference to metadata. + /// Track the reference to metadata. /// /// Register \c MD with \c *MD, if the subclass supports tracking. If \c *MD /// gets RAUW'ed, \c MD will be updated to the new address. If \c *MD gets @@ -220,7 +220,7 @@ return track(&MD, *MD, static_cast(nullptr)); } - /// \brief Track the reference to metadata for \a Metadata. + /// Track the reference to metadata for \a Metadata. /// /// As \a track(Metadata*&), but with support for calling back to \c Owner to /// tell it that its operand changed. This could trigger \c Owner being @@ -229,7 +229,7 @@ return track(Ref, MD, &Owner); } - /// \brief Track the reference to metadata for \a MetadataAsValue. + /// Track the reference to metadata for \a MetadataAsValue. /// /// As \a track(Metadata*&), but with support for calling back to \c Owner to /// tell it that its operand changed. This could trigger \c Owner being @@ -238,13 +238,13 @@ return track(Ref, MD, &Owner); } - /// \brief Stop tracking a reference to metadata. + /// Stop tracking a reference to metadata. /// /// Stops \c *MD from tracking \c MD. static void untrack(Metadata *&MD) { untrack(&MD, *MD); } static void untrack(void *Ref, Metadata &MD); - /// \brief Move tracking from one reference to another. + /// Move tracking from one reference to another. /// /// Semantically equivalent to \c untrack(MD) followed by \c track(New), /// except that ownership callbacks are maintained. @@ -257,19 +257,19 @@ } static bool retrack(void *Ref, Metadata &MD, void *New); - /// \brief Check whether metadata is replaceable. + /// Check whether metadata is replaceable. static bool isReplaceable(const Metadata &MD); using OwnerTy = PointerUnion; private: - /// \brief Track a reference to metadata for an owner. + /// Track a reference to metadata for an owner. /// /// Generalized version of tracking. static bool track(void *Ref, Metadata &MD, OwnerTy Owner); }; -/// \brief Shared implementation of use-lists for replaceable metadata. +/// Shared implementation of use-lists for replaceable metadata. /// /// Most metadata cannot be RAUW'ed. This is a shared implementation of /// use-lists and associated API for the two that support it (\a ValueAsMetadata @@ -294,12 +294,12 @@ LLVMContext &getContext() const { return Context; } - /// \brief Replace all uses of this with MD. + /// Replace all uses of this with MD. /// /// Replace all uses of this with \c MD, which is allowed to be null. void replaceAllUsesWith(Metadata *MD); - /// \brief Resolve all uses of this. + /// Resolve all uses of this. /// /// Resolve all uses of this, turning off RAUW permanently. If \c /// ResolveUsers, call \a MDNode::resolve() on any users whose last operand @@ -326,7 +326,7 @@ static bool isReplaceable(const Metadata &MD); }; -/// \brief Value wrapper in the Metadata hierarchy. +/// Value wrapper in the Metadata hierarchy. /// /// This is a custom value handle that allows other metadata to refer to /// classes in the Value hierarchy. @@ -340,7 +340,7 @@ Value *V; - /// \brief Drop users without RAUW (during teardown). + /// Drop users without RAUW (during teardown). void dropUsers() { ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false); } @@ -382,7 +382,7 @@ static void handleRAUW(Value *From, Value *To); protected: - /// \brief Handle collisions after \a Value::replaceAllUsesWith(). + /// Handle collisions after \a Value::replaceAllUsesWith(). /// /// RAUW isn't supported directly for \a ValueAsMetadata, but if the wrapped /// \a Value gets RAUW'ed and the target already exists, this is used to @@ -444,7 +444,7 @@ } }; -/// \brief Transitional API for extracting constants from Metadata. +/// Transitional API for extracting constants from Metadata. /// /// This namespace contains transitional functions for metadata that points to /// \a Constants. @@ -520,7 +520,7 @@ } // end namespace detail -/// \brief Check whether Metadata has a Value. +/// Check whether Metadata has a Value. /// /// As an analogue to \a isa(), check whether \c MD has an \a Value inside of /// type \c X. @@ -539,7 +539,7 @@ return hasa(&MD); } -/// \brief Extract a Value from Metadata. +/// Extract a Value from Metadata. /// /// As an analogue to \a cast(), extract the \a Value subclass \c X from \c MD. template @@ -554,7 +554,7 @@ return extract(&MD); } -/// \brief Extract a Value from Metadata, allowing null. +/// Extract a Value from Metadata, allowing null. /// /// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X /// from \c MD, allowing \c MD to be null. @@ -566,7 +566,7 @@ return nullptr; } -/// \brief Extract a Value from Metadata, if any. +/// Extract a Value from Metadata, if any. /// /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a @@ -579,7 +579,7 @@ return nullptr; } -/// \brief Extract a Value from Metadata, if any, allowing null. +/// Extract a Value from Metadata, if any, allowing null. /// /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a @@ -595,7 +595,7 @@ } // end namespace mdconst //===----------------------------------------------------------------------===// -/// \brief A single uniqued string. +/// A single uniqued string. /// /// These are used to efficiently contain a byte sequence for metadata. /// MDString is always unnamed. @@ -622,22 +622,22 @@ using iterator = StringRef::iterator; - /// \brief Pointer to the first byte of the string. + /// Pointer to the first byte of the string. iterator begin() const { return getString().begin(); } - /// \brief Pointer to one byte past the end of the string. + /// Pointer to one byte past the end of the string. iterator end() const { return getString().end(); } const unsigned char *bytes_begin() const { return getString().bytes_begin(); } const unsigned char *bytes_end() const { return getString().bytes_end(); } - /// \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 Metadata *MD) { return MD->getMetadataID() == MDStringKind; } }; -/// \brief A collection of metadata nodes that might be associated with a +/// A collection of metadata nodes that might be associated with a /// memory access used by the alias-analysis infrastructure. struct AAMDNodes { explicit AAMDNodes(MDNode *T = nullptr, MDNode *S = nullptr, @@ -652,16 +652,16 @@ explicit operator bool() const { return TBAA || Scope || NoAlias; } - /// \brief The tag for type-based alias analysis. + /// The tag for type-based alias analysis. MDNode *TBAA; - /// \brief The tag for alias scope specification (used with noalias). + /// The tag for alias scope specification (used with noalias). MDNode *Scope; - /// \brief The tag specifying the noalias scope. + /// The tag specifying the noalias scope. MDNode *NoAlias; - /// \brief Given two sets of AAMDNodes that apply to the same pointer, + /// Given two sets of AAMDNodes that apply to the same pointer, /// give the best AAMDNodes that are compatible with both (i.e. a set of /// nodes whose allowable aliasing conclusions are a subset of those /// allowable by both of the inputs). However, for efficiency @@ -699,7 +699,7 @@ } }; -/// \brief Tracking metadata reference owned by Metadata. +/// Tracking metadata reference owned by Metadata. /// /// Similar to \a TrackingMDRef, but it's expected to be owned by an instance /// of \a Metadata, which has the option of registering itself for callbacks to @@ -761,7 +761,7 @@ static SimpleType getSimplifiedValue(const MDOperand &MD) { return MD.get(); } }; -/// \brief Pointer to the context, with optional RAUW support. +/// Pointer to the context, with optional RAUW support. /// /// Either a raw (non-null) pointer to the \a LLVMContext, or an owned pointer /// to \a ReplaceableMetadataImpl (which has a reference to \a LLVMContext). @@ -785,7 +785,7 @@ operator LLVMContext &() { return getContext(); } - /// \brief Whether this contains RAUW support. + /// Whether this contains RAUW support. bool hasReplaceableUses() const { return Ptr.is(); } @@ -809,7 +809,7 @@ return getReplaceableUses(); } - /// \brief Assign RAUW support to this. + /// Assign RAUW support to this. /// /// Make this replaceable, taking ownership of \c ReplaceableUses (which must /// not be null). @@ -822,7 +822,7 @@ Ptr = ReplaceableUses.release(); } - /// \brief Drop RAUW support. + /// Drop RAUW support. /// /// Cede ownership of RAUW support, returning it. std::unique_ptr takeReplaceableUses() { @@ -843,7 +843,7 @@ #define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_LEAF(CLASS) #include "llvm/IR/Metadata.def" -/// \brief Metadata node. +/// Metadata node. /// /// Metadata nodes can be uniqued, like constants, or distinct. Temporary /// metadata nodes (with full support for RAUW) can be used to delay uniquing @@ -876,12 +876,12 @@ void *operator new(size_t Size, unsigned NumOps); void operator delete(void *Mem); - /// \brief Required by std, but never called. + /// Required by std, but never called. void operator delete(void *, unsigned) { llvm_unreachable("Constructor throws?"); } - /// \brief Required by std, but never called. + /// Required by std, but never called. void operator delete(void *, unsigned, bool) { llvm_unreachable("Constructor throws?"); } @@ -910,10 +910,10 @@ static inline TempMDTuple getTemporary(LLVMContext &Context, ArrayRef MDs); - /// \brief Create a (temporary) clone of this. + /// Create a (temporary) clone of this. TempMDNode clone() const; - /// \brief Deallocate a node created by getTemporary. + /// Deallocate a node created by getTemporary. /// /// Calls \c replaceAllUsesWith(nullptr) before deleting, so any remaining /// references will be reset. @@ -921,10 +921,10 @@ LLVMContext &getContext() const { return Context.getContext(); } - /// \brief Replace a specific operand. + /// Replace a specific operand. void replaceOperandWith(unsigned I, Metadata *New); - /// \brief Check if node is fully resolved. + /// Check if node is fully resolved. /// /// If \a isTemporary(), this always returns \c false; if \a isDistinct(), /// this always returns \c true. @@ -941,7 +941,7 @@ bool isDistinct() const { return Storage == Distinct; } bool isTemporary() const { return Storage == Temporary; } - /// \brief RAUW a temporary. + /// RAUW a temporary. /// /// \pre \a isTemporary() must be \c true. void replaceAllUsesWith(Metadata *MD) { @@ -950,7 +950,7 @@ Context.getReplaceableUses()->replaceAllUsesWith(MD); } - /// \brief Resolve cycles. + /// Resolve cycles. /// /// Once all forward declarations have been resolved, force cycles to be /// resolved. @@ -961,7 +961,7 @@ /// Resolve a unique, unresolved node. void resolve(); - /// \brief Replace a temporary node with a permanent one. + /// Replace a temporary node with a permanent one. /// /// Try to create a uniqued version of \c N -- in place, if possible -- and /// return it. If \c N cannot be uniqued, return a distinct node instead. @@ -971,7 +971,7 @@ return cast(N.release()->replaceWithPermanentImpl()); } - /// \brief Replace a temporary node with a uniqued one. + /// Replace a temporary node with a uniqued one. /// /// Create a uniqued version of \c N -- in place, if possible -- and return /// it. Takes ownership of the temporary node. @@ -983,7 +983,7 @@ return cast(N.release()->replaceWithUniquedImpl()); } - /// \brief Replace a temporary node with a distinct one. + /// Replace a temporary node with a distinct one. /// /// Create a distinct version of \c N -- in place, if possible -- and return /// it. Takes ownership of the temporary node. @@ -999,7 +999,7 @@ MDNode *replaceWithDistinctImpl(); protected: - /// \brief Set an operand. + /// Set an operand. /// /// Sets the operand directly, without worrying about uniquing. void setOperand(unsigned I, Metadata *New); @@ -1019,14 +1019,14 @@ void decrementUnresolvedOperandCount(); void countUnresolvedOperands(); - /// \brief Mutate this to be "uniqued". + /// Mutate this to be "uniqued". /// /// Mutate this so that \a isUniqued(). /// \pre \a isTemporary(). /// \pre already added to uniquing set. void makeUniqued(); - /// \brief Mutate this to be "distinct". + /// Mutate this to be "distinct". /// /// Mutate this so that \a isDistinct(). /// \pre \a isTemporary(). @@ -1069,10 +1069,10 @@ return op_begin()[I]; } - /// \brief Return number of MDNode operands. + /// Return number of MDNode operands. unsigned getNumOperands() const { return NumOperands; } - /// \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 Metadata *MD) { switch (MD->getMetadataID()) { default: @@ -1084,10 +1084,10 @@ } } - /// \brief Check whether MDNode is a vtable access. + /// Check whether MDNode is a vtable access. bool isTBAAVtableAccess() const; - /// \brief Methods for metadata merging. + /// Methods for metadata merging. static MDNode *concatenate(MDNode *A, MDNode *B); static MDNode *intersect(MDNode *A, MDNode *B); static MDNode *getMostGenericTBAA(MDNode *A, MDNode *B); @@ -1097,7 +1097,7 @@ static MDNode *getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B); }; -/// \brief Tuple of metadata. +/// Tuple of metadata. /// /// This is the simple \a MDNode arbitrary tuple. Nodes are uniqued by /// default based on their operands. @@ -1125,7 +1125,7 @@ } public: - /// \brief Get the hash, if any. + /// Get the hash, if any. unsigned getHash() const { return SubclassData32; } static MDTuple *get(LLVMContext &Context, ArrayRef MDs) { @@ -1136,14 +1136,14 @@ return getImpl(Context, MDs, Uniqued, /* ShouldCreate */ false); } - /// \brief Return a distinct node. + /// Return a distinct node. /// /// Return a distinct node -- i.e., a node that is not uniqued. static MDTuple *getDistinct(LLVMContext &Context, ArrayRef MDs) { return getImpl(Context, MDs, Distinct); } - /// \brief Return a temporary node. + /// Return a temporary node. /// /// For use in constructing cyclic MDNode structures. A temporary MDNode is /// not uniqued, may be RAUW'd, and must be manually deleted with @@ -1153,7 +1153,7 @@ return TempMDTuple(getImpl(Context, MDs, Temporary)); } - /// \brief Return a (temporary) clone of this. + /// Return a (temporary) clone of this. TempMDTuple clone() const { return cloneImpl(); } static bool classof(const Metadata *MD) { @@ -1182,7 +1182,7 @@ MDNode::deleteTemporary(Node); } -/// \brief Typed iterator through MDNode operands. +/// Typed iterator through MDNode operands. /// /// An iterator that transforms an \a MDNode::iterator into an iterator over a /// particular Metadata subclass. @@ -1213,7 +1213,7 @@ bool operator!=(const TypedMDOperandIterator &X) const { return I != X.I; } }; -/// \brief Typed, array-like tuple of metadata. +/// Typed, array-like tuple of metadata. /// /// This is a wrapper for \a MDTuple that makes it act like an array holding a /// particular type of metadata. @@ -1314,7 +1314,7 @@ }; //===----------------------------------------------------------------------===// -/// \brief A tuple of MDNodes. +/// A tuple of MDNodes. /// /// Despite its name, a NamedMDNode isn't itself an MDNode. NamedMDNodes belong /// to modules, have names, and contain lists of MDNodes. @@ -1377,7 +1377,7 @@ NamedMDNode(const NamedMDNode &) = delete; ~NamedMDNode(); - /// \brief Drop all references and remove the node from parent module. + /// Drop all references and remove the node from parent module. void eraseFromParent(); /// Remove all uses and clear node vector. @@ -1385,7 +1385,7 @@ /// Drop all references to this node's operands. void clearOperands(); - /// \brief Get the module that holds this named metadata collection. + /// Get the module that holds this named metadata collection. inline Module *getParent() { return Parent; } inline const Module *getParent() const { return Parent; } Index: llvm/trunk/include/llvm/IR/Module.h =================================================================== --- llvm/trunk/include/llvm/IR/Module.h +++ llvm/trunk/include/llvm/IR/Module.h @@ -213,7 +213,7 @@ /// contain the source file name. const std::string &getSourceFileName() const { return SourceFileName; } - /// \brief Get a short "name" for the module. + /// Get a short "name" for the module. /// /// This is useful for debugging or logging. It is essentially a convenience /// wrapper around getModuleIdentifier(). @@ -795,14 +795,14 @@ /// @name Utility functions for querying Debug information. /// @{ - /// \brief Returns the Number of Register ParametersDwarf Version by checking + /// Returns the Number of Register ParametersDwarf Version by checking /// module flags. unsigned getNumberRegisterParameters() const; - /// \brief Returns the Dwarf Version by checking module flags. + /// Returns the Dwarf Version by checking module flags. unsigned getDwarfVersion() const; - /// \brief Returns the CodeView Version by checking module flags. + /// Returns the CodeView Version by checking module flags. /// Returns zero if not present in module. unsigned getCodeViewFlag() const; @@ -810,10 +810,10 @@ /// @name Utility functions for querying and setting PIC level /// @{ - /// \brief Returns the PIC level (small or large model) + /// Returns the PIC level (small or large model) PICLevel::Level getPICLevel() const; - /// \brief Set the PIC level (small or large model) + /// Set the PIC level (small or large model) void setPICLevel(PICLevel::Level PL); /// @} @@ -821,20 +821,20 @@ /// @name Utility functions for querying and setting PIE level /// @{ - /// \brief Returns the PIE level (small or large model) + /// Returns the PIE level (small or large model) PIELevel::Level getPIELevel() const; - /// \brief Set the PIE level (small or large model) + /// Set the PIE level (small or large model) void setPIELevel(PIELevel::Level PL); /// @} /// @name Utility functions for querying and setting PGO summary /// @{ - /// \brief Attach profile summary metadata to this module. + /// Attach profile summary metadata to this module. void setProfileSummary(Metadata *M); - /// \brief Returns profile summary metadata + /// Returns profile summary metadata Metadata *getProfileSummary(); /// @} @@ -849,7 +849,7 @@ void setOwnedMemoryBuffer(std::unique_ptr MB); }; -/// \brief Given "llvm.used" or "llvm.compiler.used" as a global name, collect +/// Given "llvm.used" or "llvm.compiler.used" as a global name, collect /// the initializer elements of that global in Set and return the global itself. GlobalVariable *collectUsedGlobalVariables(const Module &M, SmallPtrSetImpl &Set, Index: llvm/trunk/include/llvm/IR/ModuleSummaryIndex.h =================================================================== --- llvm/trunk/include/llvm/IR/ModuleSummaryIndex.h +++ llvm/trunk/include/llvm/IR/ModuleSummaryIndex.h @@ -47,7 +47,7 @@ } // end namespace yaml -/// \brief Class to accumulate and hold information about a callee. +/// Class to accumulate and hold information about a callee. struct CalleeInfo { enum class HotnessType : uint8_t { Unknown = 0, @@ -218,16 +218,16 @@ static unsigned getHashValue(ValueInfo I) { return (uintptr_t)I.getRef(); } }; -/// \brief Function and variable summary information to aid decisions and +/// Function and variable summary information to aid decisions and /// implementation of importing. class GlobalValueSummary { public: - /// \brief Sububclass discriminator (for dyn_cast<> et al.) + /// Sububclass discriminator (for dyn_cast<> et al.) enum SummaryKind : unsigned { AliasKind, FunctionKind, GlobalVarKind }; /// Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield. struct GVFlags { - /// \brief The linkage type of the associated global value. + /// The linkage type of the associated global value. /// /// One use is to flag values that have local linkage types and need to /// have module identifier appended before placing into the combined @@ -269,7 +269,7 @@ /// GUID includes the module level id in the hash. GlobalValue::GUID OriginalName = 0; - /// \brief Path of module IR containing value's definition, used to locate + /// Path of module IR containing value's definition, used to locate /// module during importing. /// /// This is only used during parsing of the combined index, or when @@ -350,7 +350,7 @@ friend class ModuleSummaryIndex; }; -/// \brief Alias summary information. +/// Alias summary information. class AliasSummary : public GlobalValueSummary { GlobalValueSummary *AliaseeSummary; // AliaseeGUID is only set and accessed when we are building a combined index @@ -397,7 +397,7 @@ return this; } -/// \brief Function summary information to aid decisions and implementation of +/// Function summary information to aid decisions and implementation of /// importing. class FunctionSummary : public GlobalValueSummary { public: @@ -613,7 +613,7 @@ } }; -/// \brief Global variable summary information to aid decisions and +/// Global variable summary information to aid decisions and /// implementation of importing. /// /// Currently this doesn't add anything to the base \p GlobalValueSummary, Index: llvm/trunk/include/llvm/IR/Operator.h =================================================================== --- llvm/trunk/include/llvm/IR/Operator.h +++ llvm/trunk/include/llvm/IR/Operator.h @@ -507,7 +507,7 @@ }); } - /// \brief Accumulate the constant address offset of this GEP if possible. + /// Accumulate the constant address offset of this GEP if possible. /// /// This routine accepts an APInt into which it will accumulate the constant /// offset of this GEP if the GEP is in fact constant. If the GEP is not Index: llvm/trunk/include/llvm/IR/OptBisect.h =================================================================== --- llvm/trunk/include/llvm/IR/OptBisect.h +++ llvm/trunk/include/llvm/IR/OptBisect.h @@ -47,7 +47,7 @@ /// optimization-related problems. class OptBisect : public OptPassGate { public: - /// \brief Default constructor, initializes the OptBisect state based on the + /// Default constructor, initializes the OptBisect state based on the /// -opt-bisect-limit command line argument. /// /// By default, bisection is disabled. Index: llvm/trunk/include/llvm/IR/PassManager.h =================================================================== --- llvm/trunk/include/llvm/IR/PassManager.h +++ llvm/trunk/include/llvm/IR/PassManager.h @@ -152,17 +152,17 @@ /// ``` class PreservedAnalyses { public: - /// \brief Convenience factory function for the empty preserved set. + /// Convenience factory function for the empty preserved set. static PreservedAnalyses none() { return PreservedAnalyses(); } - /// \brief Construct a special preserved set that preserves all passes. + /// Construct a special preserved set that preserves all passes. static PreservedAnalyses all() { PreservedAnalyses PA; PA.PreservedIDs.insert(&AllAnalysesKey); return PA; } - /// \brief Construct a preserved analyses object with a single preserved set. + /// Construct a preserved analyses object with a single preserved set. template static PreservedAnalyses allInSet() { PreservedAnalyses PA; @@ -173,7 +173,7 @@ /// Mark an analysis as preserved. template void preserve() { preserve(AnalysisT::ID()); } - /// \brief Given an analysis's ID, mark the analysis as preserved, adding it + /// Given an analysis's ID, mark the analysis as preserved, adding it /// to the set. void preserve(AnalysisKey *ID) { // Clear this ID from the explicit not-preserved set if present. @@ -218,7 +218,7 @@ NotPreservedAnalysisIDs.insert(ID); } - /// \brief Intersect this set with another in place. + /// Intersect this set with another in place. /// /// This is a mutating operation on this preserved set, removing all /// preserved passes which are not also preserved in the argument. @@ -240,7 +240,7 @@ PreservedIDs.erase(ID); } - /// \brief Intersect this set with a temporary other set in place. + /// Intersect this set with a temporary other set in place. /// /// This is a mutating operation on this preserved set, removing all /// preserved passes which are not also preserved in the argument. @@ -402,7 +402,7 @@ } }; -/// \brief Manages a sequence of passes over a particular unit of IR. +/// Manages a sequence of passes over a particular unit of IR. /// /// A pass manager contains a sequence of passes to run over a particular unit /// of IR (e.g. Functions, Modules). It is itself a valid pass over that unit of @@ -420,7 +420,7 @@ class PassManager : public PassInfoMixin< PassManager> { public: - /// \brief Construct a pass manager. + /// Construct a pass manager. /// /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs(). explicit PassManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {} @@ -439,7 +439,7 @@ return *this; } - /// \brief Run all of the passes in this manager over the given unit of IR. + /// Run all of the passes in this manager over the given unit of IR. /// ExtraArgs are passed to each pass. PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) { @@ -496,21 +496,21 @@ std::vector> Passes; - /// \brief Flag indicating whether we should do debug logging. + /// Flag indicating whether we should do debug logging. bool DebugLogging; }; extern template class PassManager; -/// \brief Convenience typedef for a pass manager over modules. +/// Convenience typedef for a pass manager over modules. using ModulePassManager = PassManager; extern template class PassManager; -/// \brief Convenience typedef for a pass manager over functions. +/// Convenience typedef for a pass manager over functions. using FunctionPassManager = PassManager; -/// \brief A container for analyses that lazily runs them and caches their +/// A container for analyses that lazily runs them and caches their /// results. /// /// This class can manage analyses for any IR unit where the address of the IR @@ -527,7 +527,7 @@ detail::AnalysisPassConcept; - /// \brief List of analysis pass IDs and associated concept pointers. + /// List of analysis pass IDs and associated concept pointers. /// /// Requires iterators to be valid across appending new entries and arbitrary /// erases. Provides the analysis ID to enable finding iterators to a given @@ -536,10 +536,10 @@ using AnalysisResultListT = std::list>>; - /// \brief Map type from IRUnitT pointer to our custom list type. + /// Map type from IRUnitT pointer to our custom list type. using AnalysisResultListMapT = DenseMap; - /// \brief Map type from a pair of analysis ID and IRUnitT pointer to an + /// Map type from a pair of analysis ID and IRUnitT pointer to an /// iterator into a particular result list (which is where the actual analysis /// result is stored). using AnalysisResultMapT = @@ -634,14 +634,14 @@ const AnalysisResultMapT &Results; }; - /// \brief Construct an empty analysis manager. + /// Construct an empty analysis manager. /// /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs(). AnalysisManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {} AnalysisManager(AnalysisManager &&) = default; AnalysisManager &operator=(AnalysisManager &&) = default; - /// \brief Returns true if the analysis manager has an empty results cache. + /// Returns true if the analysis manager has an empty results cache. bool empty() const { assert(AnalysisResults.empty() == AnalysisResultLists.empty() && "The storage and index of analysis results disagree on how many " @@ -649,7 +649,7 @@ return AnalysisResults.empty(); } - /// \brief Clear any cached analysis results for a single unit of IR. + /// Clear any cached analysis results for a single unit of IR. /// /// This doesn't invalidate, but instead simply deletes, the relevant results. /// It is useful when the IR is being removed and we want to clear out all the @@ -669,7 +669,7 @@ AnalysisResultLists.erase(ResultsListI); } - /// \brief Clear all analysis results cached by this AnalysisManager. + /// Clear all analysis results cached by this AnalysisManager. /// /// Like \c clear(IRUnitT&), this doesn't invalidate the results; it simply /// deletes them. This lets you clean up the AnalysisManager when the set of @@ -680,7 +680,7 @@ AnalysisResultLists.clear(); } - /// \brief Get the result of an analysis pass for a given IR unit. + /// Get the result of an analysis pass for a given IR unit. /// /// Runs the analysis if a cached result is not available. template @@ -697,7 +697,7 @@ return static_cast(ResultConcept).Result; } - /// \brief Get the cached result of an analysis pass for a given IR unit. + /// Get the cached result of an analysis pass for a given IR unit. /// /// This method never runs the analysis. /// @@ -718,7 +718,7 @@ return &static_cast(ResultConcept)->Result; } - /// \brief Register an analysis pass with the manager. + /// Register an analysis pass with the manager. /// /// The parameter is a callable whose result is an analysis pass. This allows /// passing in a lambda to construct the analysis. @@ -752,7 +752,7 @@ return true; } - /// \brief Invalidate a specific analysis pass for an IR module. + /// Invalidate a specific analysis pass for an IR module. /// /// Note that the analysis result can disregard invalidation, if it determines /// it is in fact still valid. @@ -762,7 +762,7 @@ invalidateImpl(PassT::ID(), IR); } - /// \brief Invalidate cached analyses for an IR unit. + /// Invalidate cached analyses for an IR unit. /// /// Walk through all of the analyses pertaining to this unit of IR and /// invalidate them, unless they are preserved by the PreservedAnalyses set. @@ -829,7 +829,7 @@ } private: - /// \brief Look up a registered analysis pass. + /// Look up a registered analysis pass. PassConceptT &lookUpPass(AnalysisKey *ID) { typename AnalysisPassMapT::iterator PI = AnalysisPasses.find(ID); assert(PI != AnalysisPasses.end() && @@ -837,7 +837,7 @@ return *PI->second; } - /// \brief Look up a registered analysis pass. + /// Look up a registered analysis pass. const PassConceptT &lookUpPass(AnalysisKey *ID) const { typename AnalysisPassMapT::const_iterator PI = AnalysisPasses.find(ID); assert(PI != AnalysisPasses.end() && @@ -845,7 +845,7 @@ return *PI->second; } - /// \brief Get an analysis result, running the pass if necessary. + /// Get an analysis result, running the pass if necessary. ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR, ExtraArgTs... ExtraArgs) { typename AnalysisResultMapT::iterator RI; @@ -874,14 +874,14 @@ return *RI->second->second; } - /// \brief Get a cached analysis result or return null. + /// Get a cached analysis result or return null. ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const { typename AnalysisResultMapT::const_iterator RI = AnalysisResults.find({ID, &IR}); return RI == AnalysisResults.end() ? nullptr : &*RI->second->second; } - /// \brief Invalidate a function pass result. + /// Invalidate a function pass result. void invalidateImpl(AnalysisKey *ID, IRUnitT &IR) { typename AnalysisResultMapT::iterator RI = AnalysisResults.find({ID, &IR}); @@ -895,38 +895,38 @@ AnalysisResults.erase(RI); } - /// \brief Map type from module analysis pass ID to pass concept pointer. + /// Map type from module analysis pass ID to pass concept pointer. using AnalysisPassMapT = DenseMap>; - /// \brief Collection of module analysis passes, indexed by ID. + /// Collection of module analysis passes, indexed by ID. AnalysisPassMapT AnalysisPasses; - /// \brief Map from function to a list of function analysis results. + /// Map from function to a list of function analysis results. /// /// Provides linear time removal of all analysis results for a function and /// the ultimate storage for a particular cached analysis result. AnalysisResultListMapT AnalysisResultLists; - /// \brief Map from an analysis ID and function to a particular cached + /// Map from an analysis ID and function to a particular cached /// analysis result. AnalysisResultMapT AnalysisResults; - /// \brief Indicates whether we log to \c llvm::dbgs(). + /// Indicates whether we log to \c llvm::dbgs(). bool DebugLogging; }; extern template class AnalysisManager; -/// \brief Convenience typedef for the Module analysis manager. +/// Convenience typedef for the Module analysis manager. using ModuleAnalysisManager = AnalysisManager; extern template class AnalysisManager; -/// \brief Convenience typedef for the Function analysis manager. +/// Convenience typedef for the Function analysis manager. using FunctionAnalysisManager = AnalysisManager; -/// \brief An analysis over an "outer" IR unit that provides access to an +/// An analysis over an "outer" IR unit that provides access to an /// analysis manager over an "inner" IR unit. The inner unit must be contained /// in the outer unit. /// @@ -977,10 +977,10 @@ return *this; } - /// \brief Accessor for the analysis manager. + /// Accessor for the analysis manager. AnalysisManagerT &getManager() { return *InnerAM; } - /// \brief Handler for invalidation of the outer IR unit, \c IRUnitT. + /// Handler for invalidation of the outer IR unit, \c IRUnitT. /// /// If the proxy analysis itself is not preserved, we assume that the set of /// inner IR objects contained in IRUnit may have changed. In this case, @@ -1001,7 +1001,7 @@ explicit InnerAnalysisManagerProxy(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {} - /// \brief Run the analysis pass and create our proxy result object. + /// Run the analysis pass and create our proxy result object. /// /// This doesn't do any interesting work; it is primarily used to insert our /// proxy result object into the outer analysis cache so that we can proxy @@ -1040,7 +1040,7 @@ extern template class InnerAnalysisManagerProxy; -/// \brief An analysis over an "inner" IR unit that provides access to an +/// An analysis over an "inner" IR unit that provides access to an /// analysis manager over a "outer" IR unit. The inner unit must be contained /// in the outer unit. /// @@ -1063,7 +1063,7 @@ : public AnalysisInfoMixin< OuterAnalysisManagerProxy> { public: - /// \brief Result proxy object for \c OuterAnalysisManagerProxy. + /// Result proxy object for \c OuterAnalysisManagerProxy. class Result { public: explicit Result(const AnalysisManagerT &AM) : AM(&AM) {} @@ -1130,7 +1130,7 @@ OuterAnalysisManagerProxy(const AnalysisManagerT &AM) : AM(&AM) {} - /// \brief Run the analysis pass and create our proxy result object. + /// Run the analysis pass and create our proxy result object. /// Nothing to see here, it just forwards the \c AM reference into the /// result. Result run(IRUnitT &, AnalysisManager &, @@ -1157,7 +1157,7 @@ using ModuleAnalysisManagerFunctionProxy = OuterAnalysisManagerProxy; -/// \brief Trivial adaptor that maps from a module to its functions. +/// Trivial adaptor that maps from a module to its functions. /// /// Designed to allow composition of a FunctionPass(Manager) and /// a ModulePassManager, by running the FunctionPass(Manager) over every @@ -1187,7 +1187,7 @@ explicit ModuleToFunctionPassAdaptor(FunctionPassT Pass) : Pass(std::move(Pass)) {} - /// \brief Runs the function pass across every function in the module. + /// Runs the function pass across every function in the module. PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { FunctionAnalysisManager &FAM = AM.getResult(M).getManager(); @@ -1223,7 +1223,7 @@ FunctionPassT Pass; }; -/// \brief A function to deduce a function pass type and wrap it in the +/// A function to deduce a function pass type and wrap it in the /// templated adaptor. template ModuleToFunctionPassAdaptor @@ -1231,7 +1231,7 @@ return ModuleToFunctionPassAdaptor(std::move(Pass)); } -/// \brief A utility pass template to force an analysis result to be available. +/// A utility pass template to force an analysis result to be available. /// /// If there are extra arguments at the pass's run level there may also be /// extra arguments to the analysis manager's \c getResult routine. We can't @@ -1246,7 +1246,7 @@ struct RequireAnalysisPass : PassInfoMixin> { - /// \brief Run this pass over some unit of IR. + /// Run this pass over some unit of IR. /// /// This pass can be run over any unit of IR and use any analysis manager /// provided they satisfy the basic API requirements. When this pass is @@ -1261,12 +1261,12 @@ } }; -/// \brief A no-op pass template which simply forces a specific analysis result +/// A no-op pass template which simply forces a specific analysis result /// to be invalidated. template struct InvalidateAnalysisPass : PassInfoMixin> { - /// \brief Run this pass over some unit of IR. + /// Run this pass over some unit of IR. /// /// This pass can be run over any unit of IR and use any analysis manager, /// provided they satisfy the basic API requirements. When this pass is @@ -1280,12 +1280,12 @@ } }; -/// \brief A utility pass that does nothing, but preserves no analyses. +/// A utility pass that does nothing, but preserves no analyses. /// /// Because this preserves no analyses, any analysis passes queried after this /// pass runs will recompute fresh results. struct InvalidateAllAnalysesPass : PassInfoMixin { - /// \brief Run this pass over some unit of IR. + /// Run this pass over some unit of IR. template PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) { return PreservedAnalyses::none(); Index: llvm/trunk/include/llvm/IR/PassManagerInternal.h =================================================================== --- llvm/trunk/include/llvm/IR/PassManagerInternal.h +++ llvm/trunk/include/llvm/IR/PassManagerInternal.h @@ -29,17 +29,17 @@ template class AnalysisManager; class PreservedAnalyses; -/// \brief Implementation details of the pass manager interfaces. +/// Implementation details of the pass manager interfaces. namespace detail { -/// \brief Template for the abstract base class used to dispatch +/// Template for the abstract base class used to dispatch /// polymorphically over pass objects. template struct PassConcept { // Boiler plate necessary for the container of derived classes. virtual ~PassConcept() = default; - /// \brief The polymorphic API which runs the pass over a given IR entity. + /// The polymorphic API which runs the pass over a given IR entity. /// /// Note that actual pass object can omit the analysis manager argument if /// desired. Also that the analysis manager may be null if there is no @@ -47,11 +47,11 @@ virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) = 0; - /// \brief Polymorphic method to access the name of a pass. + /// Polymorphic method to access the name of a pass. virtual StringRef name() = 0; }; -/// \brief A template wrapper used to implement the polymorphic API. +/// A template wrapper used to implement the polymorphic API. /// /// Can be instantiated for any object which provides a \c run method accepting /// an \c IRUnitT& and an \c AnalysisManager&. It requires the pass to @@ -85,7 +85,7 @@ PassT Pass; }; -/// \brief Abstract concept of an analysis result. +/// Abstract concept of an analysis result. /// /// This concept is parameterized over the IR unit that this result pertains /// to. @@ -93,7 +93,7 @@ struct AnalysisResultConcept { virtual ~AnalysisResultConcept() = default; - /// \brief Method to try and mark a result as invalid. + /// Method to try and mark a result as invalid. /// /// When the outer analysis manager detects a change in some underlying /// unit of the IR, it will call this method on all of the results cached. @@ -112,7 +112,7 @@ InvalidatorT &Inv) = 0; }; -/// \brief SFINAE metafunction for computing whether \c ResultT provides an +/// SFINAE metafunction for computing whether \c ResultT provides an /// \c invalidate member function. template class ResultHasInvalidateMethod { using EnabledType = char; @@ -148,7 +148,7 @@ enum { Value = sizeof(check(rank<2>())) == sizeof(EnabledType) }; }; -/// \brief Wrapper to model the analysis result concept. +/// Wrapper to model the analysis result concept. /// /// By default, this will implement the invalidate method with a trivial /// implementation so that the actual analysis result doesn't need to provide @@ -160,7 +160,7 @@ ResultHasInvalidateMethod::Value> struct AnalysisResultModel; -/// \brief Specialization of \c AnalysisResultModel which provides the default +/// Specialization of \c AnalysisResultModel which provides the default /// invalidate functionality. template @@ -184,7 +184,7 @@ return *this; } - /// \brief The model bases invalidation solely on being in the preserved set. + /// The model bases invalidation solely on being in the preserved set. // // FIXME: We should actually use two different concepts for analysis results // rather than two different models, and avoid the indirect function call for @@ -199,7 +199,7 @@ ResultT Result; }; -/// \brief Specialization of \c AnalysisResultModel which delegates invalidate +/// Specialization of \c AnalysisResultModel which delegates invalidate /// handling to \c ResultT. template @@ -223,7 +223,7 @@ return *this; } - /// \brief The model delegates to the \c ResultT method. + /// The model delegates to the \c ResultT method. bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA, InvalidatorT &Inv) override { return Result.invalidate(IR, PA, Inv); @@ -232,7 +232,7 @@ ResultT Result; }; -/// \brief Abstract concept of an analysis pass. +/// Abstract concept of an analysis pass. /// /// This concept is parameterized over the IR unit that it can run over and /// produce an analysis result. @@ -241,7 +241,7 @@ struct AnalysisPassConcept { virtual ~AnalysisPassConcept() = default; - /// \brief Method to run this analysis over a unit of IR. + /// Method to run this analysis over a unit of IR. /// \returns A unique_ptr to the analysis result object to be queried by /// users. virtual std::unique_ptr< @@ -249,11 +249,11 @@ run(IRUnitT &IR, AnalysisManager &AM, ExtraArgTs... ExtraArgs) = 0; - /// \brief Polymorphic method to access the name of a pass. + /// Polymorphic method to access the name of a pass. virtual StringRef name() = 0; }; -/// \brief Wrapper to model the analysis pass concept. +/// Wrapper to model the analysis pass concept. /// /// Can wrap any type which implements a suitable \c run method. The method /// must accept an \c IRUnitT& and an \c AnalysisManager& as arguments @@ -283,7 +283,7 @@ AnalysisResultModel; - /// \brief The model delegates to the \c PassT::run method. + /// The model delegates to the \c PassT::run method. /// /// The return is wrapped in an \c AnalysisResultModel. std::unique_ptr< @@ -293,7 +293,7 @@ return llvm::make_unique(Pass.run(IR, AM, ExtraArgs...)); } - /// \brief The model delegates to a static \c PassT::name method. + /// The model delegates to a static \c PassT::name method. /// /// The returned string ref must point to constant immutable data! StringRef name() override { return PassT::name(); } Index: llvm/trunk/include/llvm/IR/ProfileSummary.h =================================================================== --- llvm/trunk/include/llvm/IR/ProfileSummary.h +++ llvm/trunk/include/llvm/IR/ProfileSummary.h @@ -51,7 +51,7 @@ SummaryEntryVector DetailedSummary; uint64_t TotalCount, MaxCount, MaxInternalCount, MaxFunctionCount; uint32_t NumCounts, NumFunctions; - /// \brief Return detailed summary as metadata. + /// Return detailed summary as metadata. Metadata *getDetailedSummaryMD(LLVMContext &Context); public: @@ -67,9 +67,9 @@ NumCounts(NumCounts), NumFunctions(NumFunctions) {} Kind getKind() const { return PSK; } - /// \brief Return summary information as metadata. + /// Return summary information as metadata. Metadata *getMD(LLVMContext &Context); - /// \brief Construct profile summary from metdata. + /// Construct profile summary from metdata. static ProfileSummary *getFromMD(Metadata *MD); SummaryEntryVector &getDetailedSummary() { return DetailedSummary; } uint32_t getNumFunctions() { return NumFunctions; } Index: llvm/trunk/include/llvm/IR/Statepoint.h =================================================================== --- llvm/trunk/include/llvm/IR/Statepoint.h +++ llvm/trunk/include/llvm/IR/Statepoint.h @@ -196,7 +196,7 @@ return make_range(arg_begin(), arg_end()); } - /// \brief Return true if the call or the callee has the given attribute. + /// Return true if the call or the callee has the given attribute. bool paramHasAttr(unsigned i, Attribute::AttrKind A) const { Function *F = getCalledFunction(); return getCallSite().paramHasAttr(i + CallArgsBeginPos, A) || Index: llvm/trunk/include/llvm/IR/TrackingMDRef.h =================================================================== --- llvm/trunk/include/llvm/IR/TrackingMDRef.h +++ llvm/trunk/include/llvm/IR/TrackingMDRef.h @@ -20,7 +20,7 @@ namespace llvm { -/// \brief Tracking metadata reference. +/// Tracking metadata reference. /// /// This class behaves like \a TrackingVH, but for metadata. class TrackingMDRef { @@ -70,7 +70,7 @@ track(); } - /// \brief Check whether this has a trivial destructor. + /// Check whether this has a trivial destructor. /// /// If \c MD isn't replaceable, the destructor will be a no-op. bool hasTrivialDestructor() const { @@ -100,7 +100,7 @@ } }; -/// \brief Typed tracking ref. +/// Typed tracking ref. /// /// Track refererences of a particular type. It's useful to use this for \a /// MDNode and \a ValueAsMetadata. @@ -135,7 +135,7 @@ void reset() { Ref.reset(); } void reset(T *MD) { Ref.reset(static_cast(MD)); } - /// \brief Check whether this has a trivial destructor. + /// Check whether this has a trivial destructor. bool hasTrivialDestructor() const { return Ref.hasTrivialDestructor(); } }; Index: llvm/trunk/include/llvm/IR/Use.h =================================================================== --- llvm/trunk/include/llvm/IR/Use.h +++ llvm/trunk/include/llvm/IR/Use.h @@ -36,7 +36,7 @@ class User; class Value; -/// \brief A Use represents the edge between a Value definition and its users. +/// A Use represents the edge between a Value definition and its users. /// /// This is notionally a two-dimensional linked list. It supports traversing /// all of the uses for a particular value definition. It also supports jumping @@ -57,7 +57,7 @@ public: Use(const Use &U) = delete; - /// \brief Provide a fast substitute to std::swap + /// Provide a fast substitute to std::swap /// that also works with less standard-compliant compilers void swap(Use &RHS); @@ -107,7 +107,7 @@ operator Value *() const { return Val; } Value *get() const { return Val; } - /// \brief Returns the User that contains this Use. + /// Returns the User that contains this Use. /// /// For an instruction operand, for example, this will return the /// instruction. @@ -123,16 +123,16 @@ Use *getNext() const { return Next; } - /// \brief Return the operand # of this use in its User. + /// Return the operand # of this use in its User. unsigned getOperandNo() const; - /// \brief Initializes the waymarking tags on an array of Uses. + /// Initializes the waymarking tags on an array of Uses. /// /// This sets up the array of Uses such that getUser() can find the User from /// any of those Uses. static Use *initTags(Use *Start, Use *Stop); - /// \brief Destroys Use operands when the number of operands of + /// Destroys Use operands when the number of operands of /// a User changes. static void zap(Use *Start, const Use *Stop, bool del = false); @@ -161,7 +161,7 @@ } }; -/// \brief Allow clients to treat uses just like values when using +/// Allow clients to treat uses just like values when using /// casting operators. template <> struct simplify_type { using SimpleType = Value *; Index: llvm/trunk/include/llvm/IR/UseListOrder.h =================================================================== --- llvm/trunk/include/llvm/IR/UseListOrder.h +++ llvm/trunk/include/llvm/IR/UseListOrder.h @@ -23,7 +23,7 @@ class Function; class Value; -/// \brief Structure to hold a use-list order. +/// Structure to hold a use-list order. struct UseListOrder { const Value *V = nullptr; const Function *F = nullptr; Index: llvm/trunk/include/llvm/IR/User.h =================================================================== --- llvm/trunk/include/llvm/IR/User.h +++ llvm/trunk/include/llvm/IR/User.h @@ -36,7 +36,7 @@ template class ArrayRef; template class MutableArrayRef; -/// \brief Compile-time customization of User operands. +/// Compile-time customization of User operands. /// /// Customizes operand-related allocators and accessors. template @@ -81,13 +81,13 @@ "Error in initializing hung off uses for User"); } - /// \brief Allocate the array of Uses, followed by a pointer + /// Allocate the array of Uses, followed by a pointer /// (with bottom bit set) to the User. /// \param IsPhi identifies callers which are phi nodes and which need /// N BasicBlock* allocated along with N void allocHungoffUses(unsigned N, bool IsPhi = false); - /// \brief Grow the number of hung off uses. Note that allocHungoffUses + /// Grow the number of hung off uses. Note that allocHungoffUses /// should be called if there are no uses. void growHungoffUses(unsigned N, bool IsPhi = false); @@ -97,9 +97,9 @@ public: User(const User &) = delete; - /// \brief Free memory allocated for User and Use objects. + /// Free memory allocated for User and Use objects. void operator delete(void *Usr); - /// \brief Placement delete - required by std, called if the ctor throws. + /// Placement delete - required by std, called if the ctor throws. void operator delete(void *Usr, unsigned) { // Note: If a subclass manipulates the information which is required to calculate the // Usr memory pointer, e.g. NumUserOperands, the operator delete of that subclass has @@ -111,7 +111,7 @@ llvm_unreachable("Constructor throws?"); #endif } - /// \brief Placement delete - required by std, called if the ctor throws. + /// Placement delete - required by std, called if the ctor throws. void operator delete(void *Usr, unsigned, bool) { // Note: If a subclass manipulates the information which is required to calculate the // Usr memory pointer, e.g. NumUserOperands, the operator delete of that subclass has @@ -210,7 +210,7 @@ NumUserOperands = NumOps; } - /// \brief Subclasses with hung off uses need to manage the operand count + /// Subclasses with hung off uses need to manage the operand count /// themselves. In these instances, the operand count isn't used to find the /// OperandList, so there's no issue in having the operand count change. void setNumHungOffUseOperands(unsigned NumOps) { @@ -242,7 +242,7 @@ return const_op_range(op_begin(), op_end()); } - /// \brief Iterator for directly iterating over the operand Values. + /// Iterator for directly iterating over the operand Values. struct value_op_iterator : iterator_adaptor_basedump() + /// Support for debugging, callable in GDB: V->dump() void dump() const; - /// \brief Implement operator<< on Value. + /// Implement operator<< on Value. /// @{ void print(raw_ostream &O, bool IsForDebug = false) const; void print(raw_ostream &O, ModuleSlotTracker &MST, bool IsForDebug = false) const; /// @} - /// \brief Print the name of this Value out to the specified raw_ostream. + /// Print the name of this Value out to the specified raw_ostream. /// /// This is useful when you just want to print 'int %reg126', not the /// instruction that generated it. If you specify a Module for context, then @@ -241,13 +241,13 @@ ModuleSlotTracker &MST) const; /// @} - /// \brief All values are typed, get the type of this value. + /// All values are typed, get the type of this value. Type *getType() const { return VTy; } - /// \brief All values hold a context through their type. + /// All values hold a context through their type. LLVMContext &getContext() const; - // \brief All values can potentially be named. + // All values can potentially be named. bool hasName() const { return HasName; } ValueName *getValueName() const; void setValueName(ValueName *VN); @@ -258,35 +258,35 @@ void setNameImpl(const Twine &Name); public: - /// \brief Return a constant reference to the value's name. + /// Return a constant reference to the value's name. /// /// This guaranteed to return the same reference as long as the value is not /// modified. If the value has a name, this does a hashtable lookup, so it's /// not free. StringRef getName() const; - /// \brief Change the name of the value. + /// Change the name of the value. /// /// Choose a new unique name if the provided name is taken. /// /// \param Name The new name; or "" if the value's name should be removed. void setName(const Twine &Name); - /// \brief Transfer the name from V to this value. + /// Transfer the name from V to this value. /// /// After taking V's name, sets V's name to empty. /// /// \note It is an error to call V->takeName(V). void takeName(Value *V); - /// \brief Change all uses of this to point to a new Value. + /// Change all uses of this to point to a new Value. /// /// Go through the uses list for this definition and make each use point to /// "V" instead of "this". After this completes, 'this's use list is /// guaranteed to be empty. void replaceAllUsesWith(Value *V); - /// \brief Change non-metadata uses of this to point to a new Value. + /// Change non-metadata uses of this to point to a new Value. /// /// Go through the uses list for this definition and make each use point to /// "V" instead of "this". This function skips metadata entries in the list. @@ -411,7 +411,7 @@ return materialized_users(); } - /// \brief Return true if there is exactly one user of this value. + /// Return true if there is exactly one user of this value. /// /// This is specialized because it is a common request and does not require /// traversing the whole use list. @@ -421,27 +421,27 @@ return ++I == E; } - /// \brief Return true if this Value has exactly N users. + /// Return true if this Value has exactly N users. bool hasNUses(unsigned N) const; - /// \brief Return true if this value has N users or more. + /// Return true if this value has N users or more. /// /// This is logically equivalent to getNumUses() >= N. bool hasNUsesOrMore(unsigned N) const; - /// \brief Check if this value is used in the specified basic block. + /// Check if this value is used in the specified basic block. bool isUsedInBasicBlock(const BasicBlock *BB) const; - /// \brief This method computes the number of uses of this Value. + /// This method computes the number of uses of this Value. /// /// This is a linear time operation. Use hasOneUse, hasNUses, or /// hasNUsesOrMore to check for specific values. unsigned getNumUses() const; - /// \brief This method should only be used by the Use class. + /// This method should only be used by the Use class. void addUse(Use &U) { U.addToList(&UseList); } - /// \brief Concrete subclass of this. + /// Concrete subclass of this. /// /// An enumeration for keeping track of the concrete subclass of Value that /// is actually instantiated. Values of this enumeration are kept in the @@ -456,7 +456,7 @@ #include "llvm/IR/Value.def" }; - /// \brief Return an ID for the concrete type of this object. + /// Return an ID for the concrete type of this object. /// /// This is used to implement the classof checks. This should not be used /// for any other purpose, as the values may change as LLVM evolves. Also, @@ -470,36 +470,36 @@ return SubclassID; } - /// \brief Return the raw optional flags value contained in this value. + /// Return the raw optional flags value contained in this value. /// /// This should only be used when testing two Values for equivalence. unsigned getRawSubclassOptionalData() const { return SubclassOptionalData; } - /// \brief Clear the optional flags contained in this value. + /// Clear the optional flags contained in this value. void clearSubclassOptionalData() { SubclassOptionalData = 0; } - /// \brief Check the optional flags for equality. + /// Check the optional flags for equality. bool hasSameSubclassOptionalData(const Value *V) const { return SubclassOptionalData == V->SubclassOptionalData; } - /// \brief Return true if there is a value handle associated with this value. + /// Return true if there is a value handle associated with this value. bool hasValueHandle() const { return HasValueHandle; } - /// \brief Return true if there is metadata referencing this value. + /// Return true if there is metadata referencing this value. bool isUsedByMetadata() const { return IsUsedByMD; } - /// \brief Return true if this value is a swifterror value. + /// Return true if this value is a swifterror value. /// /// swifterror values can be either a function argument or an alloca with a /// swifterror attribute. bool isSwiftError() const; - /// \brief Strip off pointer casts, all-zero GEPs, and aliases. + /// Strip off pointer casts, all-zero GEPs, and aliases. /// /// Returns the original uncasted value. If this is called on a non-pointer /// value, it returns 'this'. @@ -509,7 +509,7 @@ static_cast(this)->stripPointerCasts()); } - /// \brief Strip off pointer casts, all-zero GEPs, aliases and barriers. + /// Strip off pointer casts, all-zero GEPs, aliases and barriers. /// /// Returns the original uncasted value. If this is called on a non-pointer /// value, it returns 'this'. This function should be used only in @@ -520,7 +520,7 @@ static_cast(this)->stripPointerCastsAndBarriers()); } - /// \brief Strip off pointer casts and all-zero GEPs. + /// Strip off pointer casts and all-zero GEPs. /// /// Returns the original uncasted value. If this is called on a non-pointer /// value, it returns 'this'. @@ -530,7 +530,7 @@ static_cast(this)->stripPointerCastsNoFollowAliases()); } - /// \brief Strip off pointer casts and all-constant inbounds GEPs. + /// Strip off pointer casts and all-constant inbounds GEPs. /// /// Returns the original pointer value. If this is called on a non-pointer /// value, it returns 'this'. @@ -540,7 +540,7 @@ static_cast(this)->stripInBoundsConstantOffsets()); } - /// \brief Accumulate offsets from \a stripInBoundsConstantOffsets(). + /// Accumulate offsets from \a stripInBoundsConstantOffsets(). /// /// Stores the resulting constant offset stripped into the APInt provided. /// The provided APInt will be extended or truncated as needed to be the @@ -555,7 +555,7 @@ ->stripAndAccumulateInBoundsConstantOffsets(DL, Offset)); } - /// \brief Strip off pointer casts and inbounds GEPs. + /// Strip off pointer casts and inbounds GEPs. /// /// Returns the original pointer value. If this is called on a non-pointer /// value, it returns 'this'. @@ -565,7 +565,7 @@ static_cast(this)->stripInBoundsOffsets()); } - /// \brief Returns the number of bytes known to be dereferenceable for the + /// Returns the number of bytes known to be dereferenceable for the /// pointer value. /// /// If CanBeNull is set by this function the pointer can either be null or be @@ -573,13 +573,13 @@ uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull) const; - /// \brief Returns an alignment of the pointer value. + /// Returns an alignment of the pointer value. /// /// Returns an alignment which is either specified explicitly, e.g. via /// align attribute of a function argument, or guaranteed by DataLayout. unsigned getPointerAlignment(const DataLayout &DL) const; - /// \brief Translate PHI node to its predecessor from the given basic block. + /// Translate PHI node to its predecessor from the given basic block. /// /// If this value is a PHI node with CurBB as its parent, return the value in /// the PHI node corresponding to PredBB. If not, return ourself. This is @@ -592,14 +592,14 @@ static_cast(this)->DoPHITranslation(CurBB, PredBB)); } - /// \brief The maximum alignment for instructions. + /// The maximum alignment for instructions. /// /// This is the greatest alignment value supported by load, store, and alloca /// instructions, and global values. static const unsigned MaxAlignmentExponent = 29; static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent; - /// \brief Mutate the type of this Value to be of the specified type. + /// Mutate the type of this Value to be of the specified type. /// /// Note that this is an extremely dangerous operation which can create /// completely invalid IR very easily. It is strongly recommended that you @@ -609,17 +609,17 @@ VTy = Ty; } - /// \brief Sort the use-list. + /// Sort the use-list. /// /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is /// expected to compare two \a Use references. template void sortUseList(Compare Cmp); - /// \brief Reverse the use-list. + /// Reverse the use-list. void reverseUseList(); private: - /// \brief Merge two lists together. + /// Merge two lists together. /// /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes /// "equal" items from L before items from R. Index: llvm/trunk/include/llvm/IR/ValueHandle.h =================================================================== --- llvm/trunk/include/llvm/IR/ValueHandle.h +++ llvm/trunk/include/llvm/IR/ValueHandle.h @@ -22,7 +22,7 @@ namespace llvm { -/// \brief This is the common base class of value handles. +/// This is the common base class of value handles. /// /// ValueHandle's are smart pointers to Value's that have special behavior when /// the value is deleted or ReplaceAllUsesWith'd. See the specific handles @@ -31,7 +31,7 @@ friend class Value; protected: - /// \brief This indicates what sub class the handle actually is. + /// This indicates what sub class the handle actually is. /// /// This is to avoid having a vtable for the light-weight handle pointers. The /// fully general Callback version does have a vtable. @@ -101,10 +101,10 @@ V != DenseMapInfo::getTombstoneKey(); } - /// \brief Remove this ValueHandle from its current use list. + /// Remove this ValueHandle from its current use list. void RemoveFromUseList(); - /// \brief Clear the underlying pointer without clearing the use list. + /// Clear the underlying pointer without clearing the use list. /// /// This should only be used if a derived class has manually removed the /// handle from the use list. @@ -121,20 +121,20 @@ HandleBaseKind getKind() const { return PrevPair.getInt(); } void setPrevPtr(ValueHandleBase **Ptr) { PrevPair.setPointer(Ptr); } - /// \brief Add this ValueHandle to the use list for V. + /// Add this ValueHandle to the use list for V. /// /// List is the address of either the head of the list or a Next node within /// the existing use list. void AddToExistingUseList(ValueHandleBase **List); - /// \brief Add this ValueHandle to the use list after Node. + /// Add this ValueHandle to the use list after Node. void AddToExistingUseListAfter(ValueHandleBase *Node); - /// \brief Add this ValueHandle to the use list for V. + /// Add this ValueHandle to the use list for V. void AddToUseList(); }; -/// \brief A nullable Value handle that is nullable. +/// A nullable Value handle that is nullable. /// /// This is a value handle that points to a value, and nulls itself /// out if that value is deleted. @@ -172,7 +172,7 @@ static SimpleType getSimplifiedValue(const WeakVH &WVH) { return WVH; } }; -/// \brief Value handle that is nullable, but tries to track the Value. +/// Value handle that is nullable, but tries to track the Value. /// /// This is a value handle that tries hard to point to a Value, even across /// RAUW operations, but will null itself out if the value is destroyed. this @@ -219,7 +219,7 @@ } }; -/// \brief Value handle that asserts if the Value is deleted. +/// Value handle that asserts if the Value is deleted. /// /// This is a Value Handle that points to a value and asserts out if the value /// is destroyed while the handle is still live. This is very useful for @@ -318,7 +318,7 @@ #endif }; -/// \brief Value handle that tracks a Value across RAUW. +/// Value handle that tracks a Value across RAUW. /// /// TrackingVH is designed for situations where a client needs to hold a handle /// to a Value (or subclass) across some operations which may move that value, @@ -379,7 +379,7 @@ ValueTy &operator*() const { return *getValPtr(); } }; -/// \brief Value handle with callbacks on RAUW and destruction. +/// Value handle with callbacks on RAUW and destruction. /// /// This is a value handle that allows subclasses to define callbacks that run /// when the underlying Value has RAUW called on it or is destroyed. This @@ -405,7 +405,7 @@ return getValPtr(); } - /// \brief Callback for Value destruction. + /// Callback for Value destruction. /// /// Called when this->getValPtr() is destroyed, inside ~Value(), so you /// may call any non-virtual Value method on getValPtr(), but no subclass @@ -418,7 +418,7 @@ /// Value that's being destroyed. virtual void deleted() { setValPtr(nullptr); } - /// \brief Callback for Value RAUW. + /// Callback for Value RAUW. /// /// Called when this->getValPtr()->replaceAllUsesWith(new_value) is called, /// _before_ any of the uses have actually been replaced. If WeakTrackingVH Index: llvm/trunk/include/llvm/IR/Verifier.h =================================================================== --- llvm/trunk/include/llvm/IR/Verifier.h +++ llvm/trunk/include/llvm/IR/Verifier.h @@ -80,7 +80,7 @@ bool visitTBAAMetadata(Instruction &I, const MDNode *MD); }; -/// \brief Check a function for errors, useful for use when debugging a +/// Check a function for errors, useful for use when debugging a /// pass. /// /// If there are no errors, the function returns false. If an error is found, @@ -88,7 +88,7 @@ /// returned. bool verifyFunction(const Function &F, raw_ostream *OS = nullptr); -/// \brief Check a module for errors. +/// Check a module for errors. /// /// If there are no errors, the function returns false. If an error is /// found, a message describing the error is written to OS (if @@ -124,7 +124,7 @@ /// "recovered" from by stripping the debug info. bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS); -/// \brief Create a verifier pass. +/// Create a verifier pass. /// /// Check a module or function for validity. This is essentially a pass wrapped /// around the above verifyFunction and verifyModule routines and Index: llvm/trunk/include/llvm/Linker/Linker.h =================================================================== --- llvm/trunk/include/llvm/Linker/Linker.h +++ llvm/trunk/include/llvm/Linker/Linker.h @@ -34,7 +34,7 @@ Linker(Module &M); - /// \brief Link \p Src into the composite. + /// Link \p Src into the composite. /// /// Passing OverrideSymbols as true will have symbols from Src /// shadow those in the Dest. Index: llvm/trunk/include/llvm/MC/MCAsmBackend.h =================================================================== --- llvm/trunk/include/llvm/MC/MCAsmBackend.h +++ llvm/trunk/include/llvm/MC/MCAsmBackend.h @@ -136,7 +136,7 @@ /// Handle any target-specific assembler flags. By default, do nothing. virtual void handleAssemblerFlag(MCAssemblerFlag Flag) {} - /// \brief Generate the compact unwind encoding for the CFI instructions. + /// Generate the compact unwind encoding for the CFI instructions. virtual uint32_t generateCompactUnwindEncoding(ArrayRef) const { return 0; Index: llvm/trunk/include/llvm/MC/MCAsmInfo.h =================================================================== --- llvm/trunk/include/llvm/MC/MCAsmInfo.h +++ llvm/trunk/include/llvm/MC/MCAsmInfo.h @@ -420,7 +420,7 @@ return nullptr; } - /// \brief True if the section is atomized using the symbols in it. + /// True if the section is atomized using the symbols in it. /// This is false if the section is not atomized at all (most ELF sections) or /// if it is atomized based on its contents (MachO' __TEXT,__cstring for /// example). Index: llvm/trunk/include/llvm/MC/MCAsmLayout.h =================================================================== --- llvm/trunk/include/llvm/MC/MCAsmLayout.h +++ llvm/trunk/include/llvm/MC/MCAsmLayout.h @@ -37,11 +37,11 @@ /// lower ordinal will be valid. mutable DenseMap LastValidFragment; - /// \brief Make sure that the layout for the given fragment is valid, lazily + /// Make sure that the layout for the given fragment is valid, lazily /// computing it if necessary. void ensureValid(const MCFragment *F) const; - /// \brief Is the layout for this fragment valid? + /// Is the layout for this fragment valid? bool isFragmentValid(const MCFragment *F) const; public: @@ -50,12 +50,12 @@ /// Get the assembler object this is a layout for. MCAssembler &getAssembler() const { return Assembler; } - /// \brief Invalidate the fragments starting with F because it has been + /// Invalidate the fragments starting with F because it has been /// resized. The fragment's size should have already been updated, but /// its bundle padding will be recomputed. void invalidateFragmentsFrom(MCFragment *F); - /// \brief Perform layout for a single fragment, assuming that the previous + /// Perform layout for a single fragment, assuming that the previous /// fragment has already been laid out correctly, and the parent section has /// been initialized. void layoutFragment(MCFragment *Fragment); @@ -72,31 +72,31 @@ /// \name Fragment Layout Data /// @{ - /// \brief Get the offset of the given fragment inside its containing section. + /// Get the offset of the given fragment inside its containing section. uint64_t getFragmentOffset(const MCFragment *F) const; /// @} /// \name Utility Functions /// @{ - /// \brief Get the address space size of the given section, as it effects + /// Get the address space size of the given section, as it effects /// layout. This may differ from the size reported by \see getSectionSize() by /// not including section tail padding. uint64_t getSectionAddressSize(const MCSection *Sec) const; - /// \brief Get the data size of the given section, as emitted to the object + /// Get the data size of the given section, as emitted to the object /// file. This may include additional padding, or be 0 for virtual sections. uint64_t getSectionFileSize(const MCSection *Sec) const; - /// \brief Get the offset of the given symbol, as computed in the current + /// Get the offset of the given symbol, as computed in the current /// layout. /// \return True on success. bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const; - /// \brief Variant that reports a fatal error if the offset is not computable. + /// Variant that reports a fatal error if the offset is not computable. uint64_t getSymbolOffset(const MCSymbol &S) const; - /// \brief If this symbol is equivalent to A + Constant, return A. + /// If this symbol is equivalent to A + Constant, return A. const MCSymbol *getBaseSymbol(const MCSymbol &Symbol) const; /// @} Index: llvm/trunk/include/llvm/MC/MCAssembler.h =================================================================== --- llvm/trunk/include/llvm/MC/MCAssembler.h +++ llvm/trunk/include/llvm/MC/MCAssembler.h @@ -130,7 +130,7 @@ // refactoring too. mutable SmallPtrSet ThumbFuncs; - /// \brief The bundle alignment size currently set in the assembler. + /// The bundle alignment size currently set in the assembler. /// /// By default it's 0, which means bundling is disabled. unsigned BundleAlignSize; @@ -178,11 +178,11 @@ bool fragmentNeedsRelaxation(const MCRelaxableFragment *IF, const MCAsmLayout &Layout) const; - /// \brief Perform one layout iteration and return true if any offsets + /// Perform one layout iteration and return true if any offsets /// were adjusted. bool layoutOnce(MCAsmLayout &Layout); - /// \brief Perform one layout iteration of the given section and return true + /// Perform one layout iteration of the given section and return true /// if any offsets were adjusted. bool layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec); @@ -431,7 +431,7 @@ FileNames.push_back(FileName); } - /// \brief Write the necessary bundle padding to the given object writer. + /// Write the necessary bundle padding to the given object writer. /// Expects a fragment \p F containing instructions and its size \p FSize. void writeFragmentPadding(const MCFragment &F, uint64_t FSize, MCObjectWriter *OW) const; @@ -441,7 +441,7 @@ void dump() const; }; -/// \brief Compute the amount of padding required before the fragment \p F to +/// Compute the amount of padding required before the fragment \p F to /// obey bundling restrictions, where \p FOffset is the fragment's offset in /// its section and \p FSize is the fragment's size. uint64_t computeBundlePadding(const MCAssembler &Assembler, const MCFragment *F, Index: llvm/trunk/include/llvm/MC/MCCodeView.h =================================================================== --- llvm/trunk/include/llvm/MC/MCCodeView.h +++ llvm/trunk/include/llvm/MC/MCCodeView.h @@ -27,7 +27,7 @@ class MCStreamer; class CodeViewContext; -/// \brief Instances of this class represent the information from a +/// Instances of this class represent the information from a /// .cv_loc directive. class MCCVLoc { uint32_t FunctionId; @@ -50,13 +50,13 @@ public: unsigned getFunctionId() const { return FunctionId; } - /// \brief Get the FileNum of this MCCVLoc. + /// Get the FileNum of this MCCVLoc. unsigned getFileNum() const { return FileNum; } - /// \brief Get the Line of this MCCVLoc. + /// Get the Line of this MCCVLoc. unsigned getLine() const { return Line; } - /// \brief Get the Column of this MCCVLoc. + /// Get the Column of this MCCVLoc. unsigned getColumn() const { return Column; } bool isPrologueEnd() const { return PrologueEnd; } @@ -64,13 +64,13 @@ void setFunctionId(unsigned FID) { FunctionId = FID; } - /// \brief Set the FileNum of this MCCVLoc. + /// Set the FileNum of this MCCVLoc. void setFileNum(unsigned fileNum) { FileNum = fileNum; } - /// \brief Set the Line of this MCCVLoc. + /// Set the Line of this MCCVLoc. void setLine(unsigned line) { Line = line; } - /// \brief Set the Column of this MCCVLoc. + /// Set the Column of this MCCVLoc. void setColumn(unsigned column) { assert(column <= UINT16_MAX); Column = column; @@ -80,7 +80,7 @@ void setIsStmt(bool IS) { IsStmt = IS; } }; -/// \brief Instances of this class represent the line information for +/// Instances of this class represent the line information for /// the CodeView line table entries. Which is created after a machine /// instruction is assembled and uses an address from a temporary label /// created at the current address in the current section and the info from @@ -201,7 +201,7 @@ bool isValidCVFileNumber(unsigned FileNumber); - /// \brief Add a line entry. + /// Add a line entry. void addLineEntry(const MCCVLineEntry &LineEntry); std::vector getFunctionLineEntries(unsigned FuncId); Index: llvm/trunk/include/llvm/MC/MCContext.h =================================================================== --- llvm/trunk/include/llvm/MC/MCContext.h +++ llvm/trunk/include/llvm/MC/MCContext.h @@ -272,7 +272,7 @@ unsigned UniqueID, const MCSymbolELF *Associated); - /// \brief Map of currently defined macros. + /// Map of currently defined macros. StringMap MacroMap; public: @@ -482,20 +482,20 @@ /// \name Dwarf Management /// @{ - /// \brief Get the compilation directory for DW_AT_comp_dir + /// Get the compilation directory for DW_AT_comp_dir /// The compilation directory should be set with \c setCompilationDir before /// calling this function. If it is unset, an empty string will be returned. StringRef getCompilationDir() const { return CompilationDir; } - /// \brief Set the compilation directory for DW_AT_comp_dir + /// Set the compilation directory for DW_AT_comp_dir void setCompilationDir(StringRef S) { CompilationDir = S.str(); } - /// \brief Get the main file name for use in error messages and debug + /// Get the main file name for use in error messages and debug /// info. This can be set to ensure we've got the correct file name /// after preprocessing or for -save-temps. const std::string &getMainFileName() const { return MainFileName; } - /// \brief Set the main file name and override the default. + /// Set the main file name and override the default. void setMainFileName(StringRef S) { MainFileName = S; } /// Creates an entry in the dwarf file and directory tables. @@ -653,7 +653,7 @@ // operator new and delete aren't allowed inside namespaces. // The throw specifications are mandated by the standard. -/// \brief Placement new for using the MCContext's allocator. +/// Placement new for using the MCContext's allocator. /// /// This placement form of operator new uses the MCContext's allocator for /// obtaining memory. It is a non-throwing new, which means that it returns @@ -679,7 +679,7 @@ size_t Alignment = 8) noexcept { return C.allocate(Bytes, Alignment); } -/// \brief Placement delete companion to the new above. +/// Placement delete companion to the new above. /// /// This operator is just a companion to the new above. There is no way of /// invoking it directly; see the new operator for more details. This operator @@ -713,7 +713,7 @@ return C.allocate(Bytes, Alignment); } -/// \brief Placement delete[] companion to the new[] above. +/// Placement delete[] companion to the new[] above. /// /// This operator is just a companion to the new[] above. There is no way of /// invoking it directly; see the new[] operator for more details. This operator Index: llvm/trunk/include/llvm/MC/MCDisassembler/MCExternalSymbolizer.h =================================================================== --- llvm/trunk/include/llvm/MC/MCDisassembler/MCExternalSymbolizer.h +++ llvm/trunk/include/llvm/MC/MCDisassembler/MCExternalSymbolizer.h @@ -22,7 +22,7 @@ namespace llvm { -/// \brief Symbolize using user-provided, C API, callbacks. +/// Symbolize using user-provided, C API, callbacks. /// /// See llvm-c/Disassembler.h. class MCExternalSymbolizer : public MCSymbolizer { Index: llvm/trunk/include/llvm/MC/MCDisassembler/MCRelocationInfo.h =================================================================== --- llvm/trunk/include/llvm/MC/MCDisassembler/MCRelocationInfo.h +++ llvm/trunk/include/llvm/MC/MCDisassembler/MCRelocationInfo.h @@ -21,7 +21,7 @@ class MCContext; class MCExpr; -/// \brief Create MCExprs from relocations found in an object file. +/// Create MCExprs from relocations found in an object file. class MCRelocationInfo { protected: MCContext &Ctx; @@ -32,7 +32,7 @@ MCRelocationInfo &operator=(const MCRelocationInfo &) = delete; virtual ~MCRelocationInfo(); - /// \brief Create an MCExpr for the target-specific \p VariantKind. + /// Create an MCExpr for the target-specific \p VariantKind. /// The VariantKinds are defined in llvm-c/Disassembler.h. /// Used by MCExternalSymbolizer. /// \returns If possible, an MCExpr corresponding to VariantKind, else 0. Index: llvm/trunk/include/llvm/MC/MCDisassembler/MCSymbolizer.h =================================================================== --- llvm/trunk/include/llvm/MC/MCDisassembler/MCSymbolizer.h +++ llvm/trunk/include/llvm/MC/MCDisassembler/MCSymbolizer.h @@ -27,7 +27,7 @@ class MCInst; class raw_ostream; -/// \brief Symbolize and annotate disassembled instructions. +/// Symbolize and annotate disassembled instructions. /// /// For now this mimics the old symbolization logic (from both ARM and x86), that /// relied on user-provided (C API) callbacks to do the actual symbol lookup in @@ -42,7 +42,7 @@ std::unique_ptr RelInfo; public: - /// \brief Construct an MCSymbolizer, taking ownership of \p RelInfo. + /// Construct an MCSymbolizer, taking ownership of \p RelInfo. MCSymbolizer(MCContext &Ctx, std::unique_ptr RelInfo) : Ctx(Ctx), RelInfo(std::move(RelInfo)) { } @@ -51,7 +51,7 @@ MCSymbolizer &operator=(const MCSymbolizer &) = delete; virtual ~MCSymbolizer(); - /// \brief Try to add a symbolic operand instead of \p Value to the MCInst. + /// Try to add a symbolic operand instead of \p Value to the MCInst. /// /// Instead of having a difficult to read immediate, a symbolic operand would /// represent this immediate in a more understandable way, for instance as a @@ -70,7 +70,7 @@ bool IsBranch, uint64_t Offset, uint64_t InstSize) = 0; - /// \brief Try to add a comment on the PC-relative load. + /// Try to add a comment on the PC-relative load. /// For instance, in Mach-O, this is used to add annotations to instructions /// that use C string literals, as found in __cstring. virtual void tryAddingPcLoadReferenceComment(raw_ostream &cStream, Index: llvm/trunk/include/llvm/MC/MCDwarf.h =================================================================== --- llvm/trunk/include/llvm/MC/MCDwarf.h +++ llvm/trunk/include/llvm/MC/MCDwarf.h @@ -42,16 +42,16 @@ class SMLoc; class SourceMgr; -/// \brief Instances of this class represent the name of the dwarf +/// Instances of this class represent the name of the dwarf /// .file directive and its associated dwarf file number in the MC file, /// and MCDwarfFile's are created and uniqued by the MCContext class where /// the file number for each is its index into the vector of DwarfFiles (note /// index 0 is not used and not a valid dwarf file number). struct MCDwarfFile { - // \brief The base name of the file without its directory path. + // The base name of the file without its directory path. std::string Name; - // \brief The index into the list of directory names for this file name. + // The index into the list of directory names for this file name. unsigned DirIndex; /// The MD5 checksum, if there is one. Non-owning pointer to data allocated @@ -63,7 +63,7 @@ Optional Source; }; -/// \brief Instances of this class represent the information from a +/// Instances of this class represent the information from a /// dwarf .loc directive. class MCDwarfLoc { uint32_t FileNum; @@ -95,55 +95,55 @@ // for an MCDwarfLoc object. public: - /// \brief Get the FileNum of this MCDwarfLoc. + /// Get the FileNum of this MCDwarfLoc. unsigned getFileNum() const { return FileNum; } - /// \brief Get the Line of this MCDwarfLoc. + /// Get the Line of this MCDwarfLoc. unsigned getLine() const { return Line; } - /// \brief Get the Column of this MCDwarfLoc. + /// Get the Column of this MCDwarfLoc. unsigned getColumn() const { return Column; } - /// \brief Get the Flags of this MCDwarfLoc. + /// Get the Flags of this MCDwarfLoc. unsigned getFlags() const { return Flags; } - /// \brief Get the Isa of this MCDwarfLoc. + /// Get the Isa of this MCDwarfLoc. unsigned getIsa() const { return Isa; } - /// \brief Get the Discriminator of this MCDwarfLoc. + /// Get the Discriminator of this MCDwarfLoc. unsigned getDiscriminator() const { return Discriminator; } - /// \brief Set the FileNum of this MCDwarfLoc. + /// Set the FileNum of this MCDwarfLoc. void setFileNum(unsigned fileNum) { FileNum = fileNum; } - /// \brief Set the Line of this MCDwarfLoc. + /// Set the Line of this MCDwarfLoc. void setLine(unsigned line) { Line = line; } - /// \brief Set the Column of this MCDwarfLoc. + /// Set the Column of this MCDwarfLoc. void setColumn(unsigned column) { assert(column <= UINT16_MAX); Column = column; } - /// \brief Set the Flags of this MCDwarfLoc. + /// Set the Flags of this MCDwarfLoc. void setFlags(unsigned flags) { assert(flags <= UINT8_MAX); Flags = flags; } - /// \brief Set the Isa of this MCDwarfLoc. + /// Set the Isa of this MCDwarfLoc. void setIsa(unsigned isa) { assert(isa <= UINT8_MAX); Isa = isa; } - /// \brief Set the Discriminator of this MCDwarfLoc. + /// Set the Discriminator of this MCDwarfLoc. void setDiscriminator(unsigned discriminator) { Discriminator = discriminator; } }; -/// \brief Instances of this class represent the line information for +/// Instances of this class represent the line information for /// the dwarf line table entries. Which is created after a machine /// instruction is assembled and uses an address from a temporary label /// created at the current address in the current section and the info from @@ -168,13 +168,13 @@ static void Make(MCObjectStreamer *MCOS, MCSection *Section); }; -/// \brief Instances of this class represent the line information for a compile +/// Instances of this class represent the line information for a compile /// unit where machine instructions have been assembled after seeing .loc /// directives. This is the information used to build the dwarf line /// table for a section. class MCLineSection { public: - // \brief Add an entry to this MCLineSection's line entries. + // Add an entry to this MCLineSection's line entries. void addLineEntry(const MCDwarfLineEntry &LineEntry, MCSection *Sec) { MCLineDivisions[Sec].push_back(LineEntry); } @@ -422,41 +422,41 @@ } public: - /// \brief .cfi_def_cfa defines a rule for computing CFA as: take address from + /// .cfi_def_cfa defines a rule for computing CFA as: take address from /// Register and add Offset to it. static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register, int Offset) { return MCCFIInstruction(OpDefCfa, L, Register, -Offset, ""); } - /// \brief .cfi_def_cfa_register modifies a rule for computing CFA. From now + /// .cfi_def_cfa_register modifies a rule for computing CFA. From now /// on Register will be used instead of the old one. Offset remains the same. static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register) { return MCCFIInstruction(OpDefCfaRegister, L, Register, 0, ""); } - /// \brief .cfi_def_cfa_offset modifies a rule for computing CFA. Register + /// .cfi_def_cfa_offset modifies a rule for computing CFA. Register /// remains the same, but offset is new. Note that it is the absolute offset /// that will be added to a defined register to the compute CFA address. static MCCFIInstruction createDefCfaOffset(MCSymbol *L, int Offset) { return MCCFIInstruction(OpDefCfaOffset, L, 0, -Offset, ""); } - /// \brief .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but + /// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but /// Offset is a relative value that is added/subtracted from the previous /// offset. static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment) { return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, ""); } - /// \brief .cfi_offset Previous value of Register is saved at offset Offset + /// .cfi_offset Previous value of Register is saved at offset Offset /// from CFA. static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int Offset) { return MCCFIInstruction(OpOffset, L, Register, Offset, ""); } - /// \brief .cfi_rel_offset Previous value of Register is saved at offset + /// .cfi_rel_offset Previous value of Register is saved at offset /// Offset from the current CFA register. This is transformed to .cfi_offset /// using the known displacement of the CFA register from the CFA. static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register, @@ -464,54 +464,54 @@ return MCCFIInstruction(OpRelOffset, L, Register, Offset, ""); } - /// \brief .cfi_register Previous value of Register1 is saved in + /// .cfi_register Previous value of Register1 is saved in /// register Register2. static MCCFIInstruction createRegister(MCSymbol *L, unsigned Register1, unsigned Register2) { return MCCFIInstruction(OpRegister, L, Register1, Register2); } - /// \brief .cfi_window_save SPARC register window is saved. + /// .cfi_window_save SPARC register window is saved. static MCCFIInstruction createWindowSave(MCSymbol *L) { return MCCFIInstruction(OpWindowSave, L, 0, 0, ""); } - /// \brief .cfi_restore says that the rule for Register is now the same as it + /// .cfi_restore says that the rule for Register is now the same as it /// was at the beginning of the function, after all initial instructions added /// by .cfi_startproc were executed. static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register) { return MCCFIInstruction(OpRestore, L, Register, 0, ""); } - /// \brief .cfi_undefined From now on the previous value of Register can't be + /// .cfi_undefined From now on the previous value of Register can't be /// restored anymore. static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register) { return MCCFIInstruction(OpUndefined, L, Register, 0, ""); } - /// \brief .cfi_same_value Current value of Register is the same as in the + /// .cfi_same_value Current value of Register is the same as in the /// previous frame. I.e., no restoration is needed. static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register) { return MCCFIInstruction(OpSameValue, L, Register, 0, ""); } - /// \brief .cfi_remember_state Save all current rules for all registers. + /// .cfi_remember_state Save all current rules for all registers. static MCCFIInstruction createRememberState(MCSymbol *L) { return MCCFIInstruction(OpRememberState, L, 0, 0, ""); } - /// \brief .cfi_restore_state Restore the previously saved state. + /// .cfi_restore_state Restore the previously saved state. static MCCFIInstruction createRestoreState(MCSymbol *L) { return MCCFIInstruction(OpRestoreState, L, 0, 0, ""); } - /// \brief .cfi_escape Allows the user to add arbitrary bytes to the unwind + /// .cfi_escape Allows the user to add arbitrary bytes to the unwind /// info. static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals) { return MCCFIInstruction(OpEscape, L, 0, 0, Vals); } - /// \brief A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE + /// A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int Size) { return MCCFIInstruction(OpGnuArgsSize, L, 0, Size, ""); } Index: llvm/trunk/include/llvm/MC/MCELFObjectWriter.h =================================================================== --- llvm/trunk/include/llvm/MC/MCELFObjectWriter.h +++ llvm/trunk/include/llvm/MC/MCELFObjectWriter.h @@ -132,7 +132,7 @@ } }; -/// \brief Construct a new ELF writer instance. +/// Construct a new ELF writer instance. /// /// \param MOTW - The target specific ELF writer subclass. /// \param OS - The stream to write to. Index: llvm/trunk/include/llvm/MC/MCELFStreamer.h =================================================================== --- llvm/trunk/include/llvm/MC/MCELFStreamer.h +++ llvm/trunk/include/llvm/MC/MCELFStreamer.h @@ -81,7 +81,7 @@ void fixSymbolsInTLSFixups(const MCExpr *expr); - /// \brief Merge the content of the fragment \p EF into the fragment \p DF. + /// Merge the content of the fragment \p EF into the fragment \p DF. void mergeFragment(MCDataFragment *, MCDataFragment *); bool SeenIdent = false; Index: llvm/trunk/include/llvm/MC/MCExpr.h =================================================================== --- llvm/trunk/include/llvm/MC/MCExpr.h +++ llvm/trunk/include/llvm/MC/MCExpr.h @@ -31,7 +31,7 @@ using SectionAddrMap = DenseMap; -/// \brief Base class for the full range of assembler expressions which are +/// Base class for the full range of assembler expressions which are /// needed for parsing. class MCExpr { public: @@ -85,7 +85,7 @@ /// \name Expression Evaluation /// @{ - /// \brief Try to evaluate the expression to an absolute value. + /// Try to evaluate the expression to an absolute value. /// /// \param Res - The absolute value, if evaluation succeeds. /// \param Layout - The assembler layout object to use for evaluating symbol @@ -101,7 +101,7 @@ bool evaluateKnownAbsolute(int64_t &Res, const MCAsmLayout &Layout) const; - /// \brief Try to evaluate the expression to a relocatable value, i.e. an + /// Try to evaluate the expression to a relocatable value, i.e. an /// expression of the fixed form (a - b + constant). /// /// \param Res - The relocatable value, if evaluation succeeds. @@ -111,14 +111,14 @@ bool evaluateAsRelocatable(MCValue &Res, const MCAsmLayout *Layout, const MCFixup *Fixup) const; - /// \brief Try to evaluate the expression to the form (a - b + constant) where + /// Try to evaluate the expression to the form (a - b + constant) where /// neither a nor b are variables. /// /// This is a more aggressive variant of evaluateAsRelocatable. The intended /// use is for when relocations are not available, like the .size directive. bool evaluateAsValue(MCValue &Res, const MCAsmLayout &Layout) const; - /// \brief Find the "associated section" for this expression, which is + /// Find the "associated section" for this expression, which is /// currently defined as the absolute section for constants, or /// otherwise the section associated with the first defined symbol in the /// expression. @@ -132,7 +132,7 @@ return OS; } -//// \brief Represent a constant integer expression. +//// Represent a constant integer expression. class MCConstantExpr : public MCExpr { int64_t Value; @@ -158,7 +158,7 @@ } }; -/// \brief Represent a reference to a symbol from inside an expression. +/// Represent a reference to a symbol from inside an expression. /// /// A symbol reference in an expression may be a use of a label, a use of an /// assembler variable (defined constant), or constitute an implicit definition @@ -347,7 +347,7 @@ } }; -/// \brief Unary assembler expressions. +/// Unary assembler expressions. class MCUnaryExpr : public MCExpr { public: enum Opcode { @@ -391,10 +391,10 @@ /// \name Accessors /// @{ - /// \brief Get the kind of this unary expression. + /// Get the kind of this unary expression. Opcode getOpcode() const { return Op; } - /// \brief Get the child of this unary expression. + /// Get the child of this unary expression. const MCExpr *getSubExpr() const { return Expr; } /// @} @@ -404,7 +404,7 @@ } }; -/// \brief Binary assembler expressions. +/// Binary assembler expressions. class MCBinaryExpr : public MCExpr { public: enum Opcode { @@ -548,13 +548,13 @@ /// \name Accessors /// @{ - /// \brief Get the kind of this binary expression. + /// Get the kind of this binary expression. Opcode getOpcode() const { return Op; } - /// \brief Get the left-hand side expression of the binary operator. + /// Get the left-hand side expression of the binary operator. const MCExpr *getLHS() const { return LHS; } - /// \brief Get the right-hand side expression of the binary operator. + /// Get the right-hand side expression of the binary operator. const MCExpr *getRHS() const { return RHS; } /// @} @@ -564,7 +564,7 @@ } }; -/// \brief This is an extension point for target-specific MCExpr subclasses to +/// This is an extension point for target-specific MCExpr subclasses to /// implement. /// /// NOTE: All subclasses are required to have trivial destructors because Index: llvm/trunk/include/llvm/MC/MCFixup.h =================================================================== --- llvm/trunk/include/llvm/MC/MCFixup.h +++ llvm/trunk/include/llvm/MC/MCFixup.h @@ -19,7 +19,7 @@ namespace llvm { class MCExpr; -/// \brief Extensible enumeration to represent the type of a fixup. +/// Extensible enumeration to represent the type of a fixup. enum MCFixupKind { FK_Data_1 = 0, ///< A one-byte fixup. FK_Data_2, ///< A two-byte fixup. @@ -49,7 +49,7 @@ MaxTargetFixupKind = (1 << 8) }; -/// \brief Encode information on a single operation to perform on a byte +/// Encode information on a single operation to perform on a byte /// sequence (e.g., an encoded instruction) which requires assemble- or run- /// time patching. /// @@ -97,7 +97,7 @@ const MCExpr *getValue() const { return Value; } - /// \brief Return the generic fixup kind for a value with the given size. It + /// Return the generic fixup kind for a value with the given size. It /// is an error to pass an unsupported size. static MCFixupKind getKindForSize(unsigned Size, bool isPCRel) { switch (Size) { Index: llvm/trunk/include/llvm/MC/MCFixupKindInfo.h =================================================================== --- llvm/trunk/include/llvm/MC/MCFixupKindInfo.h +++ llvm/trunk/include/llvm/MC/MCFixupKindInfo.h @@ -12,7 +12,7 @@ namespace llvm { -/// \brief Target independent information on a fixup kind. +/// Target independent information on a fixup kind. struct MCFixupKindInfo { enum FixupKindFlags { /// Is this fixup kind PCrelative? This is used by the assembler backend to Index: llvm/trunk/include/llvm/MC/MCFragment.h =================================================================== --- llvm/trunk/include/llvm/MC/MCFragment.h +++ llvm/trunk/include/llvm/MC/MCFragment.h @@ -56,7 +56,7 @@ bool HasInstructions; private: - /// \brief Should this fragment be aligned to the end of a bundle? + /// Should this fragment be aligned to the end of a bundle? bool AlignToBundleEnd; uint8_t BundlePadding; @@ -110,26 +110,26 @@ unsigned getLayoutOrder() const { return LayoutOrder; } void setLayoutOrder(unsigned Value) { LayoutOrder = Value; } - /// \brief Does this fragment have instructions emitted into it? By default + /// Does this fragment have instructions emitted into it? By default /// this is false, but specific fragment types may set it to true. bool hasInstructions() const { return HasInstructions; } - /// \brief Should this fragment be placed at the end of an aligned bundle? + /// Should this fragment be placed at the end of an aligned bundle? bool alignToBundleEnd() const { return AlignToBundleEnd; } void setAlignToBundleEnd(bool V) { AlignToBundleEnd = V; } - /// \brief Get the padding size that must be inserted before this fragment. + /// Get the padding size that must be inserted before this fragment. /// Used for bundling. By default, no padding is inserted. /// Note that padding size is restricted to 8 bits. This is an optimization /// to reduce the amount of space used for each fragment. In practice, larger /// padding should never be required. uint8_t getBundlePadding() const { return BundlePadding; } - /// \brief Set the padding size for this fragment. By default it's a no-op, + /// Set the padding size for this fragment. By default it's a no-op, /// and only some fragments have a meaningful implementation. void setBundlePadding(uint8_t N) { BundlePadding = N; } - /// \brief Return true if given frgment has FT_Dummy type. + /// Return true if given frgment has FT_Dummy type. bool isDummy() const { return Kind == FT_Dummy; } void dump() const; Index: llvm/trunk/include/llvm/MC/MCInst.h =================================================================== --- llvm/trunk/include/llvm/MC/MCInst.h +++ llvm/trunk/include/llvm/MC/MCInst.h @@ -30,7 +30,7 @@ class MCInstPrinter; class raw_ostream; -/// \brief Instances of this class represent operands of the MCInst class. +/// Instances of this class represent operands of the MCInst class. /// This is a simple discriminated union. class MCOperand { enum MachineOperandType : unsigned char { @@ -61,13 +61,13 @@ bool isExpr() const { return Kind == kExpr; } bool isInst() const { return Kind == kInst; } - /// \brief Returns the register number. + /// Returns the register number. unsigned getReg() const { assert(isReg() && "This is not a register operand!"); return RegVal; } - /// \brief Set the register number. + /// Set the register number. void setReg(unsigned Reg) { assert(isReg() && "This is not a register operand!"); RegVal = Reg; @@ -156,7 +156,7 @@ template <> struct isPodLike { static const bool value = true; }; -/// \brief Instances of this class represent a single low-level machine +/// Instances of this class represent a single low-level machine /// instruction. class MCInst { unsigned Opcode = 0; @@ -203,7 +203,7 @@ void print(raw_ostream &OS) const; void dump() const; - /// \brief Dump the MCInst as prettily as possible using the additional MC + /// Dump the MCInst as prettily as possible using the additional MC /// structures, if given. Operators are separated by the \p Separator /// string. void dump_pretty(raw_ostream &OS, const MCInstPrinter *Printer = nullptr, Index: llvm/trunk/include/llvm/MC/MCInstBuilder.h =================================================================== --- llvm/trunk/include/llvm/MC/MCInstBuilder.h +++ llvm/trunk/include/llvm/MC/MCInstBuilder.h @@ -23,42 +23,42 @@ MCInst Inst; public: - /// \brief Create a new MCInstBuilder for an MCInst with a specific opcode. + /// Create a new MCInstBuilder for an MCInst with a specific opcode. MCInstBuilder(unsigned Opcode) { Inst.setOpcode(Opcode); } - /// \brief Add a new register operand. + /// Add a new register operand. MCInstBuilder &addReg(unsigned Reg) { Inst.addOperand(MCOperand::createReg(Reg)); return *this; } - /// \brief Add a new integer immediate operand. + /// Add a new integer immediate operand. MCInstBuilder &addImm(int64_t Val) { Inst.addOperand(MCOperand::createImm(Val)); return *this; } - /// \brief Add a new floating point immediate operand. + /// Add a new floating point immediate operand. MCInstBuilder &addFPImm(double Val) { Inst.addOperand(MCOperand::createFPImm(Val)); return *this; } - /// \brief Add a new MCExpr operand. + /// Add a new MCExpr operand. MCInstBuilder &addExpr(const MCExpr *Val) { Inst.addOperand(MCOperand::createExpr(Val)); return *this; } - /// \brief Add a new MCInst operand. + /// Add a new MCInst operand. MCInstBuilder &addInst(const MCInst *Val) { Inst.addOperand(MCOperand::createInst(Val)); return *this; } - /// \brief Add an operand. + /// Add an operand. MCInstBuilder &addOperand(const MCOperand &Op) { Inst.addOperand(Op); return *this; Index: llvm/trunk/include/llvm/MC/MCInstPrinter.h =================================================================== --- llvm/trunk/include/llvm/MC/MCInstPrinter.h +++ llvm/trunk/include/llvm/MC/MCInstPrinter.h @@ -36,11 +36,11 @@ } // end namespace HexStyle -/// \brief This is an instance of a target assembly language printer that +/// This is an instance of a target assembly language printer that /// converts an MCInst to valid target assembly syntax. class MCInstPrinter { protected: - /// \brief A stream that comments can be emitted to if desired. Each comment + /// A stream that comments can be emitted to if desired. Each comment /// must end with a newline. This will be null if verbose assembly emission /// is disable. raw_ostream *CommentStream = nullptr; @@ -66,18 +66,18 @@ virtual ~MCInstPrinter(); - /// \brief Specify a stream to emit comments to. + /// Specify a stream to emit comments to. void setCommentStream(raw_ostream &OS) { CommentStream = &OS; } - /// \brief Print the specified MCInst to the specified raw_ostream. + /// Print the specified MCInst to the specified raw_ostream. virtual void printInst(const MCInst *MI, raw_ostream &OS, StringRef Annot, const MCSubtargetInfo &STI) = 0; - /// \brief Return the name of the specified opcode enum (e.g. "MOV32ri") or + /// Return the name of the specified opcode enum (e.g. "MOV32ri") or /// empty if we can't resolve it. StringRef getOpcodeName(unsigned Opcode) const; - /// \brief Print the assembler register name. + /// Print the assembler register name. virtual void printRegName(raw_ostream &OS, unsigned RegNo) const; bool getUseMarkup() const { return UseMarkup; } Index: llvm/trunk/include/llvm/MC/MCInstrAnalysis.h =================================================================== --- llvm/trunk/include/llvm/MC/MCInstrAnalysis.h +++ llvm/trunk/include/llvm/MC/MCInstrAnalysis.h @@ -60,7 +60,7 @@ return Info->get(Inst.getOpcode()).isTerminator(); } - /// \brief Given a branch instruction try to get the address the branch + /// Given a branch instruction try to get the address the branch /// targets. Return true on success, and the address in Target. virtual bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size, Index: llvm/trunk/include/llvm/MC/MCInstrDesc.h =================================================================== --- llvm/trunk/include/llvm/MC/MCInstrDesc.h +++ llvm/trunk/include/llvm/MC/MCInstrDesc.h @@ -35,12 +35,12 @@ EARLY_CLOBBER // Operand is an early clobber register operand }; -/// \brief These are flags set on operands, but should be considered +/// These are flags set on operands, but should be considered /// private, all access should go through the MCOperandInfo accessors. /// See the accessors for a description of what these are. enum OperandFlags { LookupPtrRegClass = 0, Predicate, OptionalDef }; -/// \brief Operands are tagged with one of the values of this enum. +/// Operands are tagged with one of the values of this enum. enum OperandType { OPERAND_UNKNOWN = 0, OPERAND_IMMEDIATE = 1, @@ -65,37 +65,37 @@ } -/// \brief This holds information about one operand of a machine instruction, +/// This holds information about one operand of a machine instruction, /// indicating the register class for register operands, etc. class MCOperandInfo { public: - /// \brief This specifies the register class enumeration of the operand + /// This specifies the register class enumeration of the operand /// if the operand is a register. If isLookupPtrRegClass is set, then this is /// an index that is passed to TargetRegisterInfo::getPointerRegClass(x) to /// get a dynamic register class. int16_t RegClass; - /// \brief These are flags from the MCOI::OperandFlags enum. + /// These are flags from the MCOI::OperandFlags enum. uint8_t Flags; - /// \brief Information about the type of the operand. + /// Information about the type of the operand. uint8_t OperandType; - /// \brief The lower 16 bits are used to specify which constraints are set. + /// The lower 16 bits are used to specify which constraints are set. /// The higher 16 bits are used to specify the value of constraints (4 bits /// each). uint32_t Constraints; - /// \brief Set if this operand is a pointer value and it requires a callback + /// Set if this operand is a pointer value and it requires a callback /// to look up its register class. bool isLookupPtrRegClass() const { return Flags & (1 << MCOI::LookupPtrRegClass); } - /// \brief Set if this is one of the operands that made up of the predicate + /// Set if this is one of the operands that made up of the predicate /// operand that controls an isPredicable() instruction. bool isPredicate() const { return Flags & (1 << MCOI::Predicate); } - /// \brief Set if this operand is a optional def. + /// Set if this operand is a optional def. bool isOptionalDef() const { return Flags & (1 << MCOI::OptionalDef); } bool isGenericType() const { @@ -114,7 +114,7 @@ //===----------------------------------------------------------------------===// namespace MCID { -/// \brief These should be considered private to the implementation of the +/// These should be considered private to the implementation of the /// MCInstrDesc class. Clients should use the predicate methods on MCInstrDesc, /// not use these directly. These all correspond to bitfields in the /// MCInstrDesc::Flags field. @@ -155,7 +155,7 @@ }; } -/// \brief Describe properties that are true of each instruction in the target +/// Describe properties that are true of each instruction in the target /// description file. This captures information about side effects, register /// use and many other things. There is one instance of this struct for each /// target instruction class, and the MachineInstr class points to this struct @@ -182,7 +182,7 @@ bool (*ComplexDeprecationInfo)(MCInst &, const MCSubtargetInfo &, std::string &); - /// \brief Returns the value of the specific constraint if + /// Returns the value of the specific constraint if /// it is set. Returns -1 if it is not set. int getOperandConstraint(unsigned OpNum, MCOI::OperandConstraint Constraint) const { @@ -194,15 +194,15 @@ return -1; } - /// \brief Returns true if a certain instruction is deprecated and if so + /// Returns true if a certain instruction is deprecated and if so /// returns the reason in \p Info. bool getDeprecatedInfo(MCInst &MI, const MCSubtargetInfo &STI, std::string &Info) const; - /// \brief Return the opcode number for this descriptor. + /// Return the opcode number for this descriptor. unsigned getOpcode() const { return Opcode; } - /// \brief Return the number of declared MachineOperands for this + /// Return the number of declared MachineOperands for this /// MachineInstruction. Note that variadic (isVariadic() returns true) /// instructions may have additional operands at the end of the list, and note /// that the machine instruction may include implicit register def/uses as @@ -218,44 +218,44 @@ return make_range(opInfo_begin(), opInfo_end()); } - /// \brief Return the number of MachineOperands that are register + /// Return the number of MachineOperands that are register /// definitions. Register definitions always occur at the start of the /// machine operand list. This is the number of "outs" in the .td file, /// and does not include implicit defs. unsigned getNumDefs() const { return NumDefs; } - /// \brief Return flags of this instruction. + /// Return flags of this instruction. uint64_t getFlags() const { return Flags; } - /// \brief Return true if this instruction can have a variable number of + /// Return true if this instruction can have a variable number of /// operands. In this case, the variable operands will be after the normal /// operands but before the implicit definitions and uses (if any are /// present). bool isVariadic() const { return Flags & (1ULL << MCID::Variadic); } - /// \brief Set if this instruction has an optional definition, e.g. + /// Set if this instruction has an optional definition, e.g. /// ARM instructions which can set condition code if 's' bit is set. bool hasOptionalDef() const { return Flags & (1ULL << MCID::HasOptionalDef); } - /// \brief Return true if this is a pseudo instruction that doesn't + /// Return true if this is a pseudo instruction that doesn't /// correspond to a real machine instruction. bool isPseudo() const { return Flags & (1ULL << MCID::Pseudo); } - /// \brief Return true if the instruction is a return. + /// Return true if the instruction is a return. bool isReturn() const { return Flags & (1ULL << MCID::Return); } - /// \brief Return true if the instruction is an add instruction. + /// Return true if the instruction is an add instruction. bool isAdd() const { return Flags & (1ULL << MCID::Add); } - /// \brief Return true if the instruction is a call. + /// Return true if the instruction is a call. bool isCall() const { return Flags & (1ULL << MCID::Call); } - /// \brief Returns true if the specified instruction stops control flow + /// Returns true if the specified instruction stops control flow /// from executing the instruction immediately following it. Examples include /// unconditional branches and return instructions. bool isBarrier() const { return Flags & (1ULL << MCID::Barrier); } - /// \brief Returns true if this instruction part of the terminator for + /// Returns true if this instruction part of the terminator for /// a basic block. Typically this is things like return and branch /// instructions. /// @@ -263,17 +263,17 @@ /// but before control flow occurs. bool isTerminator() const { return Flags & (1ULL << MCID::Terminator); } - /// \brief Returns true if this is a conditional, unconditional, or + /// Returns true if this is a conditional, unconditional, or /// indirect branch. Predicates below can be used to discriminate between /// these cases, and the TargetInstrInfo::AnalyzeBranch method can be used to /// get more information. bool isBranch() const { return Flags & (1ULL << MCID::Branch); } - /// \brief Return true if this is an indirect branch, such as a + /// Return true if this is an indirect branch, such as a /// branch through a register. bool isIndirectBranch() const { return Flags & (1ULL << MCID::IndirectBranch); } - /// \brief Return true if this is a branch which may fall + /// Return true if this is a branch which may fall /// through to the next instruction or may transfer control flow to some other /// block. The TargetInstrInfo::AnalyzeBranch method can be used to get more /// information about this branch. @@ -281,7 +281,7 @@ return isBranch() & !isBarrier() & !isIndirectBranch(); } - /// \brief Return true if this is a branch which always + /// Return true if this is a branch which always /// transfers control flow to some other block. The /// TargetInstrInfo::AnalyzeBranch method can be used to get more information /// about this branch. @@ -289,40 +289,40 @@ return isBranch() & isBarrier() & !isIndirectBranch(); } - /// \brief Return true if this is a branch or an instruction which directly + /// Return true if this is a branch or an instruction which directly /// writes to the program counter. Considered 'may' affect rather than /// 'does' affect as things like predication are not taken into account. bool mayAffectControlFlow(const MCInst &MI, const MCRegisterInfo &RI) const; - /// \brief Return true if this instruction has a predicate operand + /// Return true if this instruction has a predicate operand /// that controls execution. It may be set to 'always', or may be set to other /// values. There are various methods in TargetInstrInfo that can be used to /// control and modify the predicate in this instruction. bool isPredicable() const { return Flags & (1ULL << MCID::Predicable); } - /// \brief Return true if this instruction is a comparison. + /// Return true if this instruction is a comparison. bool isCompare() const { return Flags & (1ULL << MCID::Compare); } - /// \brief Return true if this instruction is a move immediate + /// Return true if this instruction is a move immediate /// (including conditional moves) instruction. bool isMoveImmediate() const { return Flags & (1ULL << MCID::MoveImm); } - /// \brief Return true if this instruction is a bitcast instruction. + /// Return true if this instruction is a bitcast instruction. bool isBitcast() const { return Flags & (1ULL << MCID::Bitcast); } - /// \brief Return true if this is a select instruction. + /// Return true if this is a select instruction. bool isSelect() const { return Flags & (1ULL << MCID::Select); } - /// \brief Return true if this instruction cannot be safely + /// Return true if this instruction cannot be safely /// duplicated. For example, if the instruction has a unique labels attached /// to it, duplicating it would cause multiple definition errors. bool isNotDuplicable() const { return Flags & (1ULL << MCID::NotDuplicable); } - /// \brief Returns true if the specified instruction has a delay slot which + /// Returns true if the specified instruction has a delay slot which /// must be filled by the code generator. bool hasDelaySlot() const { return Flags & (1ULL << MCID::DelaySlot); } - /// \brief Return true for instructions that can be folded as memory operands + /// Return true for instructions that can be folded as memory operands /// in other instructions. The most common use for this is instructions that /// are simple loads from memory that don't modify the loaded value in any /// way, but it can also be used for instructions that can be expressed as @@ -331,7 +331,7 @@ /// that return a value in their only virtual register definition. bool canFoldAsLoad() const { return Flags & (1ULL << MCID::FoldableAsLoad); } - /// \brief Return true if this instruction behaves + /// Return true if this instruction behaves /// the same way as the generic REG_SEQUENCE instructions. /// E.g., on ARM, /// dX VMOVDRR rY, rZ @@ -343,7 +343,7 @@ /// override accordingly. bool isRegSequenceLike() const { return Flags & (1ULL << MCID::RegSequence); } - /// \brief Return true if this instruction behaves + /// Return true if this instruction behaves /// the same way as the generic EXTRACT_SUBREG instructions. /// E.g., on ARM, /// rX, rY VMOVRRD dZ @@ -358,7 +358,7 @@ return Flags & (1ULL << MCID::ExtractSubreg); } - /// \brief Return true if this instruction behaves + /// Return true if this instruction behaves /// the same way as the generic INSERT_SUBREG instructions. /// E.g., on ARM, /// dX = VSETLNi32 dY, rZ, Imm @@ -371,7 +371,7 @@ bool isInsertSubregLike() const { return Flags & (1ULL << MCID::InsertSubreg); } - /// \brief Return true if this instruction is convergent. + /// Return true if this instruction is convergent. /// /// Convergent instructions may not be made control-dependent on any /// additional values. @@ -381,18 +381,18 @@ // Side Effect Analysis //===--------------------------------------------------------------------===// - /// \brief Return true if this instruction could possibly read memory. + /// Return true if this instruction could possibly read memory. /// Instructions with this flag set are not necessarily simple load /// instructions, they may load a value and modify it, for example. bool mayLoad() const { return Flags & (1ULL << MCID::MayLoad); } - /// \brief Return true if this instruction could possibly modify memory. + /// Return true if this instruction could possibly modify memory. /// Instructions with this flag set are not necessarily simple store /// instructions, they may store a modified value based on their operands, or /// may not actually modify anything, for example. bool mayStore() const { return Flags & (1ULL << MCID::MayStore); } - /// \brief Return true if this instruction has side + /// Return true if this instruction has side /// effects that are not modeled by other flags. This does not return true /// for instructions whose effects are captured by: /// @@ -412,7 +412,7 @@ // Flags that indicate whether an instruction can be modified by a method. //===--------------------------------------------------------------------===// - /// \brief Return true if this may be a 2- or 3-address instruction (of the + /// Return true if this may be a 2- or 3-address instruction (of the /// form "X = op Y, Z, ..."), which produces the same result if Y and Z are /// exchanged. If this flag is set, then the /// TargetInstrInfo::commuteInstruction method may be used to hack on the @@ -424,7 +424,7 @@ /// commute them. bool isCommutable() const { return Flags & (1ULL << MCID::Commutable); } - /// \brief Return true if this is a 2-address instruction which can be changed + /// Return true if this is a 2-address instruction which can be changed /// into a 3-address instruction if needed. Doing this transformation can be /// profitable in the register allocator, because it means that the /// instruction can use a 2-address form if possible, but degrade into a less @@ -442,7 +442,7 @@ return Flags & (1ULL << MCID::ConvertibleTo3Addr); } - /// \brief Return true if this instruction requires custom insertion support + /// Return true if this instruction requires custom insertion support /// when the DAG scheduler is inserting it into a machine basic block. If /// this is true for the instruction, it basically means that it is a pseudo /// instruction used at SelectionDAG time that is expanded out into magic code @@ -454,13 +454,13 @@ return Flags & (1ULL << MCID::UsesCustomInserter); } - /// \brief Return true if this instruction requires *adjustment* after + /// Return true if this instruction requires *adjustment* after /// instruction selection by calling a target hook. For example, this can be /// used to fill in ARM 's' optional operand depending on whether the /// conditional flag register is used. bool hasPostISelHook() const { return Flags & (1ULL << MCID::HasPostISelHook); } - /// \brief Returns true if this instruction is a candidate for remat. This + /// Returns true if this instruction is a candidate for remat. This /// flag is only used in TargetInstrInfo method isTriviallyRematerializable. /// /// If this flag is set, the isReallyTriviallyReMaterializable() @@ -470,7 +470,7 @@ return Flags & (1ULL << MCID::Rematerializable); } - /// \brief Returns true if this instruction has the same cost (or less) than a + /// Returns true if this instruction has the same cost (or less) than a /// move instruction. This is useful during certain types of optimizations /// (e.g., remat during two-address conversion or machine licm) where we would /// like to remat or hoist the instruction, but not if it costs more than @@ -481,7 +481,7 @@ /// for different subtargets. bool isAsCheapAsAMove() const { return Flags & (1ULL << MCID::CheapAsAMove); } - /// \brief Returns true if this instruction source operands have special + /// Returns true if this instruction source operands have special /// register allocation requirements that are not captured by the operand /// register classes. e.g. ARM::STRD's two source registers must be an even / /// odd pair, ARM::STM registers have to be in ascending order. Post-register @@ -491,7 +491,7 @@ return Flags & (1ULL << MCID::ExtraSrcRegAllocReq); } - /// \brief Returns true if this instruction def operands have special register + /// Returns true if this instruction def operands have special register /// allocation requirements that are not captured by the operand register /// classes. e.g. ARM::LDRD's two def registers must be an even / odd pair, /// ARM::LDM registers have to be in ascending order. Post-register @@ -501,7 +501,7 @@ return Flags & (1ULL << MCID::ExtraDefRegAllocReq); } - /// \brief Return a list of registers that are potentially read by any + /// Return a list of registers that are potentially read by any /// instance of this machine instruction. For example, on X86, the "adc" /// instruction adds two register operands and adds the carry bit in from the /// flags register. In this case, the instruction is marked as implicitly @@ -511,7 +511,7 @@ /// This method returns null if the instruction has no implicit uses. const MCPhysReg *getImplicitUses() const { return ImplicitUses; } - /// \brief Return the number of implicit uses this instruction has. + /// Return the number of implicit uses this instruction has. unsigned getNumImplicitUses() const { if (!ImplicitUses) return 0; @@ -521,7 +521,7 @@ return i; } - /// \brief Return a list of registers that are potentially written by any + /// Return a list of registers that are potentially written by any /// instance of this machine instruction. For example, on X86, many /// instructions implicitly set the flags register. In this case, they are /// marked as setting the FLAGS. Likewise, many instructions always deposit @@ -533,7 +533,7 @@ /// This method returns null if the instruction has no implicit defs. const MCPhysReg *getImplicitDefs() const { return ImplicitDefs; } - /// \brief Return the number of implicit defs this instruct has. + /// Return the number of implicit defs this instruct has. unsigned getNumImplicitDefs() const { if (!ImplicitDefs) return 0; @@ -543,7 +543,7 @@ return i; } - /// \brief Return true if this instruction implicitly + /// Return true if this instruction implicitly /// uses the specified physical register. bool hasImplicitUseOfPhysReg(unsigned Reg) const { if (const MCPhysReg *ImpUses = ImplicitUses) @@ -553,22 +553,22 @@ return false; } - /// \brief Return true if this instruction implicitly + /// Return true if this instruction implicitly /// defines the specified physical register. bool hasImplicitDefOfPhysReg(unsigned Reg, const MCRegisterInfo *MRI = nullptr) const; - /// \brief Return the scheduling class for this instruction. The + /// Return the scheduling class for this instruction. The /// scheduling class is an index into the InstrItineraryData table. This /// returns zero if there is no known scheduling information for the /// instruction. unsigned getSchedClass() const { return SchedClass; } - /// \brief Return the number of bytes in the encoding of this instruction, + /// Return the number of bytes in the encoding of this instruction, /// or zero if the encoding size cannot be known from the opcode. unsigned getSize() const { return Size; } - /// \brief Find the index of the first operand in the + /// Find the index of the first operand in the /// operand list that is used to represent the predicate. It returns -1 if /// none is found. int findFirstPredOperandIdx() const { @@ -580,7 +580,7 @@ return -1; } - /// \brief Return true if this instruction defines the specified physical + /// Return true if this instruction defines the specified physical /// register, either explicitly or implicitly. bool hasDefOfPhysReg(const MCInst &MI, unsigned Reg, const MCRegisterInfo &RI) const; Index: llvm/trunk/include/llvm/MC/MCInstrInfo.h =================================================================== --- llvm/trunk/include/llvm/MC/MCInstrInfo.h +++ llvm/trunk/include/llvm/MC/MCInstrInfo.h @@ -20,7 +20,7 @@ namespace llvm { //--------------------------------------------------------------------------- -/// \brief Interface to description of machine instruction set. +/// Interface to description of machine instruction set. class MCInstrInfo { const MCInstrDesc *Desc; // Raw array to allow static init'n const unsigned *InstrNameIndices; // Array for name indices in InstrNameData @@ -28,7 +28,7 @@ unsigned NumOpcodes; // Number of entries in the desc array public: - /// \brief Initialize MCInstrInfo, called by TableGen auto-generated routines. + /// Initialize MCInstrInfo, called by TableGen auto-generated routines. /// *DO NOT USE*. void InitMCInstrInfo(const MCInstrDesc *D, const unsigned *NI, const char *ND, unsigned NO) { @@ -40,14 +40,14 @@ unsigned getNumOpcodes() const { return NumOpcodes; } - /// \brief Return the machine instruction descriptor that corresponds to the + /// Return the machine instruction descriptor that corresponds to the /// specified instruction opcode. const MCInstrDesc &get(unsigned Opcode) const { assert(Opcode < NumOpcodes && "Invalid opcode!"); return Desc[Opcode]; } - /// \brief Returns the name for the instructions with the given opcode. + /// Returns the name for the instructions with the given opcode. StringRef getName(unsigned Opcode) const { assert(Opcode < NumOpcodes && "Invalid opcode!"); return StringRef(&InstrNameData[InstrNameIndices[Opcode]]); Index: llvm/trunk/include/llvm/MC/MCInstrItineraries.h =================================================================== --- llvm/trunk/include/llvm/MC/MCInstrItineraries.h +++ llvm/trunk/include/llvm/MC/MCInstrItineraries.h @@ -67,12 +67,12 @@ int NextCycles_; ///< Number of machine cycles to next stage ReservationKinds Kind_; ///< Kind of the FU reservation - /// \brief Returns the number of cycles the stage is occupied. + /// Returns the number of cycles the stage is occupied. unsigned getCycles() const { return Cycles_; } - /// \brief Returns the choice of FUs. + /// Returns the choice of FUs. unsigned getUnits() const { return Units_; } @@ -81,7 +81,7 @@ return Kind_; } - /// \brief Returns the number of cycles from the start of this stage to the + /// Returns the number of cycles from the start of this stage to the /// start of the next stage in the itinerary unsigned getNextCycles() const { return (NextCycles_ >= 0) ? (unsigned)NextCycles_ : Cycles_; @@ -120,28 +120,28 @@ : SchedModel(SM), Stages(S), OperandCycles(OS), Forwardings(F), Itineraries(SchedModel.InstrItineraries) {} - /// \brief Returns true if there are no itineraries. + /// Returns true if there are no itineraries. bool isEmpty() const { return Itineraries == nullptr; } - /// \brief Returns true if the index is for the end marker itinerary. + /// Returns true if the index is for the end marker itinerary. bool isEndMarker(unsigned ItinClassIndx) const { return ((Itineraries[ItinClassIndx].FirstStage == UINT16_MAX) && (Itineraries[ItinClassIndx].LastStage == UINT16_MAX)); } - /// \brief Return the first stage of the itinerary. + /// Return the first stage of the itinerary. const InstrStage *beginStage(unsigned ItinClassIndx) const { unsigned StageIdx = Itineraries[ItinClassIndx].FirstStage; return Stages + StageIdx; } - /// \brief Return the last+1 stage of the itinerary. + /// Return the last+1 stage of the itinerary. const InstrStage *endStage(unsigned ItinClassIndx) const { unsigned StageIdx = Itineraries[ItinClassIndx].LastStage; return Stages + StageIdx; } - /// \brief Return the total stage latency of the given class. The latency is + /// Return the total stage latency of the given class. The latency is /// the maximum completion time for any stage in the itinerary. If no stages /// exist, it defaults to one cycle. unsigned getStageLatency(unsigned ItinClassIndx) const { @@ -160,7 +160,7 @@ return Latency; } - /// \brief Return the cycle for the given class and operand. Return -1 if no + /// Return the cycle for the given class and operand. Return -1 if no /// cycle is specified for the operand. int getOperandCycle(unsigned ItinClassIndx, unsigned OperandIdx) const { if (isEmpty()) @@ -174,7 +174,7 @@ return (int)OperandCycles[FirstIdx + OperandIdx]; } - /// \brief Return true if there is a pipeline forwarding between instructions + /// Return true if there is a pipeline forwarding between instructions /// of itinerary classes DefClass and UseClasses so that value produced by an /// instruction of itinerary class DefClass, operand index DefIdx can be /// bypassed when it's read by an instruction of itinerary class UseClass, @@ -197,7 +197,7 @@ Forwardings[FirstUseIdx + UseIdx]; } - /// \brief Compute and return the use operand latency of a given itinerary + /// Compute and return the use operand latency of a given itinerary /// class and operand index if the value is produced by an instruction of the /// specified itinerary class and def operand index. int getOperandLatency(unsigned DefClass, unsigned DefIdx, @@ -221,7 +221,7 @@ return UseCycle; } - /// \brief Return the number of micro-ops that the given class decodes to. + /// Return the number of micro-ops that the given class decodes to. /// Return -1 for classes that require dynamic lookup via TargetInstrInfo. int getNumMicroOps(unsigned ItinClassIndx) const { if (isEmpty()) Index: llvm/trunk/include/llvm/MC/MCLabel.h =================================================================== --- llvm/trunk/include/llvm/MC/MCLabel.h +++ llvm/trunk/include/llvm/MC/MCLabel.h @@ -18,11 +18,11 @@ class raw_ostream; -/// \brief Instances of this class represent a label name in the MC file, +/// Instances of this class represent a label name in the MC file, /// and MCLabel are created and uniqued by the MCContext class. MCLabel /// should only be constructed for valid instances in the object file. class MCLabel { - // \brief The instance number of this Directional Local Label. + // The instance number of this Directional Local Label. unsigned Instance; private: // MCContext creates and uniques these. @@ -34,16 +34,16 @@ MCLabel(const MCLabel &) = delete; MCLabel &operator=(const MCLabel &) = delete; - /// \brief Get the current instance of this Directional Local Label. + /// Get the current instance of this Directional Local Label. unsigned getInstance() const { return Instance; } - /// \brief Increment the current instance of this Directional Local Label. + /// Increment the current instance of this Directional Local Label. unsigned incInstance() { return ++Instance; } - /// \brief Print the value to the stream \p OS. + /// Print the value to the stream \p OS. void print(raw_ostream &OS) const; - /// \brief Print the value to stderr. + /// Print the value to stderr. void dump() const; }; Index: llvm/trunk/include/llvm/MC/MCObjectStreamer.h =================================================================== --- llvm/trunk/include/llvm/MC/MCObjectStreamer.h +++ llvm/trunk/include/llvm/MC/MCObjectStreamer.h @@ -26,7 +26,7 @@ class raw_ostream; class raw_pwrite_stream; -/// \brief Streaming object file generation interface. +/// Streaming object file generation interface. /// /// This class provides an implementation of the MCStreamer interface which is /// suitable for use with the assembler backend. Specific object file formats @@ -105,7 +105,7 @@ void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI, bool = false) override; - /// \brief Emit an instruction to a special fragment, because this instruction + /// Emit an instruction to a special fragment, because this instruction /// can change its size during relaxation. virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &); Index: llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h =================================================================== --- llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h +++ llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h @@ -91,7 +91,7 @@ IdKind Kind; }; -/// \brief Generic Sema callback for assembly parser. +/// Generic Sema callback for assembly parser. class MCAsmParserSemaCallback { public: virtual ~MCAsmParserSemaCallback(); @@ -105,7 +105,7 @@ unsigned &Offset) = 0; }; -/// \brief Generic assembler parser interface, for use by target specific +/// Generic assembler parser interface, for use by target specific /// assembly parsers. class MCAsmParser { public: @@ -153,7 +153,7 @@ virtual MCContext &getContext() = 0; - /// \brief Return the output streamer for the assembler. + /// Return the output streamer for the assembler. virtual MCStreamer &getStreamer() = 0; MCTargetAsmParser &getTargetParser() const { return *TargetParser; } @@ -168,13 +168,13 @@ void setEnablePrintSchedInfo(bool Value) { EnablePrintSchedInfo = Value; } bool shouldPrintSchedInfo() { return EnablePrintSchedInfo; } - /// \brief Run the parser on the input source buffer. + /// Run the parser on the input source buffer. virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0; virtual void setParsingInlineAsm(bool V) = 0; virtual bool isParsingInlineAsm() = 0; - /// \brief Parse MS-style inline assembly. + /// Parse MS-style inline assembly. virtual bool parseMSInlineAsm( void *AsmLoc, std::string &AsmString, unsigned &NumOutputs, unsigned &NumInputs, SmallVectorImpl> &OpDecls, @@ -182,22 +182,22 @@ SmallVectorImpl &Clobbers, const MCInstrInfo *MII, const MCInstPrinter *IP, MCAsmParserSemaCallback &SI) = 0; - /// \brief Emit a note at the location \p L, with the message \p Msg. + /// Emit a note at the location \p L, with the message \p Msg. virtual void Note(SMLoc L, const Twine &Msg, SMRange Range = None) = 0; - /// \brief Emit a warning at the location \p L, with the message \p Msg. + /// Emit a warning at the location \p L, with the message \p Msg. /// /// \return The return value is true, if warnings are fatal. virtual bool Warning(SMLoc L, const Twine &Msg, SMRange Range = None) = 0; - /// \brief Return an error at the location \p L, with the message \p Msg. This + /// Return an error at the location \p L, with the message \p Msg. This /// may be modified before being emitted. /// /// \return The return value is always true, as an idiomatic convenience to /// clients. bool Error(SMLoc L, const Twine &Msg, SMRange Range = None); - /// \brief Emit an error at the location \p L, with the message \p Msg. + /// Emit an error at the location \p L, with the message \p Msg. /// /// \return The return value is always true, as an idiomatic convenience to /// clients. @@ -216,19 +216,19 @@ bool addErrorSuffix(const Twine &Suffix); - /// \brief Get the next AsmToken in the stream, possibly handling file + /// Get the next AsmToken in the stream, possibly handling file /// inclusion first. virtual const AsmToken &Lex() = 0; - /// \brief Get the current AsmToken from the stream. + /// Get the current AsmToken from the stream. const AsmToken &getTok() const; - /// \brief Report an error at the current lexer location. + /// Report an error at the current lexer location. bool TokError(const Twine &Msg, SMRange Range = None); bool parseTokenLoc(SMLoc &Loc); bool parseToken(AsmToken::TokenKind T, const Twine &Msg = "unexpected token"); - /// \brief Attempt to parse and consume token, returning true on + /// Attempt to parse and consume token, returning true on /// success. bool parseOptionalToken(AsmToken::TokenKind T); @@ -241,23 +241,23 @@ bool check(bool P, const Twine &Msg); bool check(bool P, SMLoc Loc, const Twine &Msg); - /// \brief Parse an identifier or string (as a quoted identifier) and set \p + /// Parse an identifier or string (as a quoted identifier) and set \p /// Res to the identifier contents. virtual bool parseIdentifier(StringRef &Res) = 0; - /// \brief Parse up to the end of statement and return the contents from the + /// Parse up to the end of statement and return the contents from the /// current token until the end of the statement; the current token on exit /// will be either the EndOfStatement or EOF. virtual StringRef parseStringToEndOfStatement() = 0; - /// \brief Parse the current token as a string which may include escaped + /// Parse the current token as a string which may include escaped /// characters and return the string contents. virtual bool parseEscapedString(std::string &Data) = 0; - /// \brief Skip to the end of the current statement, for error recovery. + /// Skip to the end of the current statement, for error recovery. virtual void eatToEndOfStatement() = 0; - /// \brief Parse an arbitrary expression. + /// Parse an arbitrary expression. /// /// \param Res - The value of the expression. The result is undefined /// on error. @@ -265,14 +265,14 @@ virtual bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0; bool parseExpression(const MCExpr *&Res); - /// \brief Parse a primary expression. + /// Parse a primary expression. /// /// \param Res - The value of the expression. The result is undefined /// on error. /// \return - False on success. virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) = 0; - /// \brief Parse an arbitrary expression, assuming that an initial '(' has + /// Parse an arbitrary expression, assuming that an initial '(' has /// already been consumed. /// /// \param Res - The value of the expression. The result is undefined @@ -280,19 +280,19 @@ /// \return - False on success. virtual bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0; - /// \brief Parse an expression which must evaluate to an absolute value. + /// Parse an expression which must evaluate to an absolute value. /// /// \param Res - The value of the absolute expression. The result is undefined /// on error. /// \return - False on success. virtual bool parseAbsoluteExpression(int64_t &Res) = 0; - /// \brief Ensure that we have a valid section set in the streamer. Otherwise, + /// Ensure that we have a valid section set in the streamer. Otherwise, /// report an error and switch to .text. /// \return - False on success. virtual bool checkForValidSection() = 0; - /// \brief Parse an arbitrary expression of a specified parenthesis depth, + /// Parse an arbitrary expression of a specified parenthesis depth, /// assuming that the initial '(' characters have already been consumed. /// /// \param ParenDepth - Specifies how many trailing expressions outside the @@ -304,7 +304,7 @@ SMLoc &EndLoc) = 0; }; -/// \brief Create an MCAsmParser instance. +/// Create an MCAsmParser instance. MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &, MCStreamer &, const MCAsmInfo &, unsigned CB = 0); Index: llvm/trunk/include/llvm/MC/MCParser/MCAsmParserExtension.h =================================================================== --- llvm/trunk/include/llvm/MC/MCParser/MCAsmParserExtension.h +++ llvm/trunk/include/llvm/MC/MCParser/MCAsmParserExtension.h @@ -20,7 +20,7 @@ class Twine; -/// \brief Generic interface for extending the MCAsmParser, +/// Generic interface for extending the MCAsmParser, /// which is implemented by target and object file assembly parser /// implementations. class MCAsmParserExtension { @@ -45,7 +45,7 @@ MCAsmParserExtension &operator=(const MCAsmParserExtension &) = delete; virtual ~MCAsmParserExtension(); - /// \brief Initialize the extension for parsing using the given \p Parser. + /// Initialize the extension for parsing using the given \p Parser. /// The extension should use the AsmParser interfaces to register its /// parsing routines. virtual void Initialize(MCAsmParser &Parser); Index: llvm/trunk/include/llvm/MC/MCRegisterInfo.h =================================================================== --- llvm/trunk/include/llvm/MC/MCRegisterInfo.h +++ llvm/trunk/include/llvm/MC/MCRegisterInfo.h @@ -240,7 +240,7 @@ friend class MCRegUnitMaskIterator; friend class MCRegUnitRootIterator; - /// \brief Initialize MCRegisterInfo, called by TableGen + /// Initialize MCRegisterInfo, called by TableGen /// auto-generated routines. *DO NOT USE*. void InitMCRegisterInfo(const MCRegisterDesc *D, unsigned NR, unsigned RA, unsigned PC, @@ -283,7 +283,7 @@ Dwarf2LRegsSize = 0; } - /// \brief Used to initialize LLVM register to Dwarf + /// Used to initialize LLVM register to Dwarf /// register number mapping. Called by TableGen auto-generated routines. /// *DO NOT USE*. void mapLLVMRegsToDwarfRegs(const DwarfLLVMRegPair *Map, unsigned Size, @@ -297,7 +297,7 @@ } } - /// \brief Used to initialize Dwarf register to LLVM + /// Used to initialize Dwarf register to LLVM /// register number mapping. Called by TableGen auto-generated routines. /// *DO NOT USE*. void mapDwarfRegsToLLVMRegs(const DwarfLLVMRegPair *Map, unsigned Size, @@ -324,7 +324,7 @@ L2CVRegs[LLVMReg] = CVReg; } - /// \brief This method should return the register where the return + /// This method should return the register where the return /// address can be found. unsigned getRARegister() const { return RAReg; @@ -341,86 +341,86 @@ return Desc[RegNo]; } - /// \brief Provide a get method, equivalent to [], but more useful with a + /// Provide a get method, equivalent to [], but more useful with a /// pointer to this object. const MCRegisterDesc &get(unsigned RegNo) const { return operator[](RegNo); } - /// \brief Returns the physical register number of sub-register "Index" + /// Returns the physical register number of sub-register "Index" /// for physical register RegNo. Return zero if the sub-register does not /// exist. unsigned getSubReg(unsigned Reg, unsigned Idx) const; - /// \brief Return a super-register of the specified register + /// Return a super-register of the specified register /// Reg so its sub-register of index SubIdx is Reg. unsigned getMatchingSuperReg(unsigned Reg, unsigned SubIdx, const MCRegisterClass *RC) const; - /// \brief For a given register pair, return the sub-register index + /// For a given register pair, return the sub-register index /// if the second register is a sub-register of the first. Return zero /// otherwise. unsigned getSubRegIndex(unsigned RegNo, unsigned SubRegNo) const; - /// \brief Get the size of the bit range covered by a sub-register index. + /// Get the size of the bit range covered by a sub-register index. /// If the index isn't continuous, return the sum of the sizes of its parts. /// If the index is used to access subregisters of different sizes, return -1. unsigned getSubRegIdxSize(unsigned Idx) const; - /// \brief Get the offset of the bit range covered by a sub-register index. + /// Get the offset of the bit range covered by a sub-register index. /// If an Offset doesn't make sense (the index isn't continuous, or is used to /// access sub-registers at different offsets), return -1. unsigned getSubRegIdxOffset(unsigned Idx) const; - /// \brief Return the human-readable symbolic target-specific name for the + /// Return the human-readable symbolic target-specific name for the /// specified physical register. const char *getName(unsigned RegNo) const { return RegStrings + get(RegNo).Name; } - /// \brief Return the number of registers this target has (useful for + /// Return the number of registers this target has (useful for /// sizing arrays holding per register information) unsigned getNumRegs() const { return NumRegs; } - /// \brief Return the number of sub-register indices + /// Return the number of sub-register indices /// understood by the target. Index 0 is reserved for the no-op sub-register, /// while 1 to getNumSubRegIndices() - 1 represent real sub-registers. unsigned getNumSubRegIndices() const { return NumSubRegIndices; } - /// \brief Return the number of (native) register units in the + /// Return the number of (native) register units in the /// target. Register units are numbered from 0 to getNumRegUnits() - 1. They /// can be accessed through MCRegUnitIterator defined below. unsigned getNumRegUnits() const { return NumRegUnits; } - /// \brief Map a target register to an equivalent dwarf register + /// Map a target register to an equivalent dwarf register /// number. Returns -1 if there is no equivalent value. The second /// parameter allows targets to use different numberings for EH info and /// debugging info. int getDwarfRegNum(unsigned RegNum, bool isEH) const; - /// \brief Map a dwarf register back to a target register. + /// Map a dwarf register back to a target register. int getLLVMRegNum(unsigned RegNum, bool isEH) const; - /// \brief Map a DWARF EH register back to a target register (same as + /// Map a DWARF EH register back to a target register (same as /// getLLVMRegNum(RegNum, true)) but return -1 if there is no mapping, /// rather than asserting that there must be one. int getLLVMRegNumFromEH(unsigned RegNum) const; - /// \brief Map a target EH register number to an equivalent DWARF register + /// Map a target EH register number to an equivalent DWARF register /// number. int getDwarfRegNumFromDwarfEHRegNum(unsigned RegNum) const; - /// \brief Map a target register to an equivalent SEH register + /// Map a target register to an equivalent SEH register /// number. Returns LLVM register number if there is no equivalent value. int getSEHRegNum(unsigned RegNum) const; - /// \brief Map a target register to an equivalent CodeView register + /// Map a target register to an equivalent CodeView register /// number. int getCodeViewRegNum(unsigned RegNum) const; @@ -434,7 +434,7 @@ return (unsigned)(regclass_end()-regclass_begin()); } - /// \brief Returns the register class associated with the enumeration + /// Returns the register class associated with the enumeration /// value. See class MCOperandInfo. const MCRegisterClass& getRegClass(unsigned i) const { assert(i < getNumRegClasses() && "Register Class ID out of range"); @@ -445,33 +445,33 @@ return RegClassStrings + Class->NameIdx; } - /// \brief Returns the encoding for RegNo + /// Returns the encoding for RegNo uint16_t getEncodingValue(unsigned RegNo) const { assert(RegNo < NumRegs && "Attempting to get encoding for invalid register number!"); return RegEncodingTable[RegNo]; } - /// \brief Returns true if RegB is a sub-register of RegA. + /// Returns true if RegB is a sub-register of RegA. bool isSubRegister(unsigned RegA, unsigned RegB) const { return isSuperRegister(RegB, RegA); } - /// \brief Returns true if RegB is a super-register of RegA. + /// Returns true if RegB is a super-register of RegA. bool isSuperRegister(unsigned RegA, unsigned RegB) const; - /// \brief Returns true if RegB is a sub-register of RegA or if RegB == RegA. + /// Returns true if RegB is a sub-register of RegA or if RegB == RegA. bool isSubRegisterEq(unsigned RegA, unsigned RegB) const { return isSuperRegisterEq(RegB, RegA); } - /// \brief Returns true if RegB is a super-register of RegA or if + /// Returns true if RegB is a super-register of RegA or if /// RegB == RegA. bool isSuperRegisterEq(unsigned RegA, unsigned RegB) const { return RegA == RegB || isSuperRegister(RegA, RegB); } - /// \brief Returns true if RegB is a super-register or sub-register of RegA + /// Returns true if RegB is a super-register or sub-register of RegA /// or if RegB == RegA. bool isSuperOrSubRegisterEq(unsigned RegA, unsigned RegB) const { return isSubRegisterEq(RegA, RegB) || isSuperRegister(RegA, RegB); @@ -651,17 +651,17 @@ Reg1 = MCRI->RegUnitRoots[RegUnit][1]; } - /// \brief Dereference to get the current root register. + /// Dereference to get the current root register. unsigned operator*() const { return Reg0; } - /// \brief Check if the iterator is at the end of the list. + /// Check if the iterator is at the end of the list. bool isValid() const { return Reg0; } - /// \brief Preincrement to move to the next root register. + /// Preincrement to move to the next root register. void operator++() { assert(isValid() && "Cannot move off the end of the list."); Reg0 = Reg1; Index: llvm/trunk/include/llvm/MC/MCSection.h =================================================================== --- llvm/trunk/include/llvm/MC/MCSection.h +++ llvm/trunk/include/llvm/MC/MCSection.h @@ -40,7 +40,7 @@ public: enum SectionVariant { SV_COFF = 0, SV_ELF, SV_MachO, SV_Wasm }; - /// \brief Express the state of bundle locked groups while emitting code. + /// Express the state of bundle locked groups while emitting code. enum BundleLockStateType { NotBundleLocked, BundleLocked, @@ -65,13 +65,13 @@ /// The index of this section in the layout order. unsigned LayoutOrder; - /// \brief Keeping track of bundle-locked state. + /// Keeping track of bundle-locked state. BundleLockStateType BundleLockState = NotBundleLocked; - /// \brief Current nesting depth of bundle_lock directives. + /// Current nesting depth of bundle_lock directives. unsigned BundleLockNestingDepth = 0; - /// \brief We've seen a bundle_lock directive but not its first instruction + /// We've seen a bundle_lock directive but not its first instruction /// yet. bool BundleGroupBeforeFirstInst : 1; Index: llvm/trunk/include/llvm/MC/MCStreamer.h =================================================================== --- llvm/trunk/include/llvm/MC/MCStreamer.h +++ llvm/trunk/include/llvm/MC/MCStreamer.h @@ -170,7 +170,7 @@ std::unique_ptr ConstantPools; }; -/// \brief Streaming machine code generation interface. +/// Streaming machine code generation interface. /// /// This interface is intended to provide a programatic interface that is very /// similar to the level that an assembler .s file provides. It has callbacks @@ -197,11 +197,11 @@ /// closed. Otherwise, issue an error and return null. WinEH::FrameInfo *EnsureValidWinFrameInfo(SMLoc Loc); - /// \brief Tracks an index to represent the order a symbol was emitted in. + /// Tracks an index to represent the order a symbol was emitted in. /// Zero means we did not emit that symbol. DenseMap SymbolOrdering; - /// \brief This is stack of current and previous section values saved by + /// This is stack of current and previous section values saved by /// PushSection. SmallVector, 4> SectionStack; @@ -275,19 +275,19 @@ /// \name Assembly File Formatting. /// @{ - /// \brief Return true if this streamer supports verbose assembly and if it is + /// Return true if this streamer supports verbose assembly and if it is /// enabled. virtual bool isVerboseAsm() const { return false; } - /// \brief Return true if this asm streamer supports emitting unformatted text + /// Return true if this asm streamer supports emitting unformatted text /// to the .s file with EmitRawText. virtual bool hasRawTextSupport() const { return false; } - /// \brief Is the integrated assembler required for this streamer to function + /// Is the integrated assembler required for this streamer to function /// correctly? virtual bool isIntegratedAssemblerRequired() const { return false; } - /// \brief Add a textual comment. + /// Add a textual comment. /// /// Typically for comments that can be emitted to the generated .s /// file if applicable as a QoI issue to make the output of the compiler @@ -302,22 +302,22 @@ /// with a false value. virtual void AddComment(const Twine &T, bool EOL = true) {} - /// \brief Return a raw_ostream that comments can be written to. Unlike + /// Return a raw_ostream that comments can be written to. Unlike /// AddComment, you are required to terminate comments with \n if you use this /// method. virtual raw_ostream &GetCommentOS(); - /// \brief Print T and prefix it with the comment string (normally #) and + /// Print T and prefix it with the comment string (normally #) and /// optionally a tab. This prints the comment immediately, not at the end of /// the current line. It is basically a safe version of EmitRawText: since it /// only prints comments, the object streamer ignores it instead of asserting. virtual void emitRawComment(const Twine &T, bool TabPrefix = true); - /// \brief Add explicit comment T. T is required to be a valid + /// Add explicit comment T. T is required to be a valid /// comment in the output and does not need to be escaped. virtual void addExplicitComment(const Twine &T); - /// \brief Emit added explicit comments. + /// Emit added explicit comments. virtual void emitExplicitComments(); /// AddBlankLine - Emit a blank line to a .s file to pretty it up. @@ -328,7 +328,7 @@ /// \name Symbol & Section Management /// @{ - /// \brief Return the current section that the streamer is emitting code to. + /// Return the current section that the streamer is emitting code to. MCSectionSubPair getCurrentSection() const { if (!SectionStack.empty()) return SectionStack.back().first; @@ -336,32 +336,32 @@ } MCSection *getCurrentSectionOnly() const { return getCurrentSection().first; } - /// \brief Return the previous section that the streamer is emitting code to. + /// Return the previous section that the streamer is emitting code to. MCSectionSubPair getPreviousSection() const { if (!SectionStack.empty()) return SectionStack.back().second; return MCSectionSubPair(); } - /// \brief Returns an index to represent the order a symbol was emitted in. + /// Returns an index to represent the order a symbol was emitted in. /// (zero if we did not emit that symbol) unsigned GetSymbolOrder(const MCSymbol *Sym) const { return SymbolOrdering.lookup(Sym); } - /// \brief Update streamer for a new active section. + /// Update streamer for a new active section. /// /// This is called by PopSection and SwitchSection, if the current /// section changes. virtual void ChangeSection(MCSection *, const MCExpr *); - /// \brief Save the current and previous section on the section stack. + /// Save the current and previous section on the section stack. void PushSection() { SectionStack.push_back( std::make_pair(getCurrentSection(), getPreviousSection())); } - /// \brief Restore the current and previous section from the section stack. + /// Restore the current and previous section from the section stack. /// Calls ChangeSection as needed. /// /// Returns false if the stack was empty. @@ -395,7 +395,7 @@ virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection = nullptr); - /// \brief Set the current section where code is being emitted to \p Section. + /// Set the current section where code is being emitted to \p Section. /// This is required to update CurSection. This version does not call /// ChangeSection. void SwitchSectionNoChange(MCSection *Section, @@ -407,18 +407,18 @@ SectionStack.back().first = MCSectionSubPair(Section, Subsection); } - /// \brief Create the default sections and set the initial one. + /// Create the default sections and set the initial one. virtual void InitSections(bool NoExecStack); MCSymbol *endSection(MCSection *Section); - /// \brief Sets the symbol's section. + /// Sets the symbol's section. /// /// Each emitted symbol will be tracked in the ordering table, /// so we can sort on them later. void AssignFragment(MCSymbol *Symbol, MCFragment *Fragment); - /// \brief Emit a label for \p Symbol into the current section. + /// Emit a label for \p Symbol into the current section. /// /// This corresponds to an assembler statement such as: /// foo: @@ -432,17 +432,17 @@ virtual void EmitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol); - /// \brief Note in the output the specified \p Flag. + /// Note in the output the specified \p Flag. virtual void EmitAssemblerFlag(MCAssemblerFlag Flag); - /// \brief Emit the given list \p Options of strings as linker + /// Emit the given list \p Options of strings as linker /// options into the output. virtual void EmitLinkerOptions(ArrayRef Kind) {} - /// \brief Note in the output the specified region \p Kind. + /// Note in the output the specified region \p Kind. virtual void EmitDataRegion(MCDataRegionType Kind) {} - /// \brief Specify the Mach-O minimum deployment target version. + /// Specify the Mach-O minimum deployment target version. virtual void EmitVersionMin(MCVersionMinType Type, unsigned Major, unsigned Minor, unsigned Update) {} @@ -453,11 +453,11 @@ void EmitVersionForTarget(const Triple &Target); - /// \brief Note in the output that the specified \p Func is a Thumb mode + /// Note in the output that the specified \p Func is a Thumb mode /// function (ARM target only). virtual void EmitThumbFunc(MCSymbol *Func); - /// \brief Emit an assignment of \p Value to \p Symbol. + /// Emit an assignment of \p Value to \p Symbol. /// /// This corresponds to an assembler statement such as: /// symbol = value @@ -470,7 +470,7 @@ /// \param Value - The value for the symbol. virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value); - /// \brief Emit an weak reference from \p Alias to \p Symbol. + /// Emit an weak reference from \p Alias to \p Symbol. /// /// This corresponds to an assembler statement such as: /// .weakref alias, symbol @@ -479,56 +479,56 @@ /// \param Symbol - The symbol being aliased. virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol); - /// \brief Add the given \p Attribute to \p Symbol. + /// Add the given \p Attribute to \p Symbol. virtual bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) = 0; - /// \brief Set the \p DescValue for the \p Symbol. + /// Set the \p DescValue for the \p Symbol. /// /// \param Symbol - The symbol to have its n_desc field set. /// \param DescValue - The value to set into the n_desc field. virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue); - /// \brief Start emitting COFF symbol definition + /// Start emitting COFF symbol definition /// /// \param Symbol - The symbol to have its External & Type fields set. virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol); - /// \brief Emit the storage class of the symbol. + /// Emit the storage class of the symbol. /// /// \param StorageClass - The storage class the symbol should have. virtual void EmitCOFFSymbolStorageClass(int StorageClass); - /// \brief Emit the type of the symbol. + /// Emit the type of the symbol. /// /// \param Type - A COFF type identifier (see COFF::SymbolType in X86COFF.h) virtual void EmitCOFFSymbolType(int Type); - /// \brief Marks the end of the symbol definition. + /// Marks the end of the symbol definition. virtual void EndCOFFSymbolDef(); virtual void EmitCOFFSafeSEH(MCSymbol const *Symbol); - /// \brief Emits the symbol table index of a Symbol into the current section. + /// Emits the symbol table index of a Symbol into the current section. virtual void EmitCOFFSymbolIndex(MCSymbol const *Symbol); - /// \brief Emits a COFF section index. + /// Emits a COFF section index. /// /// \param Symbol - Symbol the section number relocation should point to. virtual void EmitCOFFSectionIndex(MCSymbol const *Symbol); - /// \brief Emits a COFF section relative relocation. + /// Emits a COFF section relative relocation. /// /// \param Symbol - Symbol the section relative relocation should point to. virtual void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset); - /// \brief Emit an ELF .size directive. + /// Emit an ELF .size directive. /// /// This corresponds to an assembler statement such as: /// .size symbol, expression virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value); - /// \brief Emit an ELF .symver directive. + /// Emit an ELF .symver directive. /// /// This corresponds to an assembler statement such as: /// .symver _start, foo@@SOME_VERSION @@ -537,11 +537,11 @@ virtual void emitELFSymverDirective(StringRef AliasName, const MCSymbol *Aliasee); - /// \brief Emit a Linker Optimization Hint (LOH) directive. + /// Emit a Linker Optimization Hint (LOH) directive. /// \param Args - Arguments of the LOH. virtual void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {} - /// \brief Emit a common symbol. + /// Emit a common symbol. /// /// \param Symbol - The common symbol to emit. /// \param Size - The size of the common symbol. @@ -550,7 +550,7 @@ virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment) = 0; - /// \brief Emit a local common (.lcomm) symbol. + /// Emit a local common (.lcomm) symbol. /// /// \param Symbol - The common symbol to emit. /// \param Size - The size of the common symbol. @@ -558,7 +558,7 @@ virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment); - /// \brief Emit the zerofill section and an optional symbol. + /// Emit the zerofill section and an optional symbol. /// /// \param Section - The zerofill section to create and or to put the symbol /// \param Symbol - The zerofill symbol to emit, if non-NULL. @@ -568,7 +568,7 @@ virtual void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr, uint64_t Size = 0, unsigned ByteAlignment = 0) = 0; - /// \brief Emit a thread local bss (.tbss) symbol. + /// Emit a thread local bss (.tbss) symbol. /// /// \param Section - The thread local common section. /// \param Symbol - The thread local common symbol to emit. @@ -582,7 +582,7 @@ /// \name Generating Data /// @{ - /// \brief Emit the bytes in \p Data into the output. + /// Emit the bytes in \p Data into the output. /// /// This is used to implement assembler directives such as .byte, .ascii, /// etc. @@ -592,7 +592,7 @@ /// method uses .byte directives instead of .ascii or .asciz for readability. virtual void EmitBinaryData(StringRef Data); - /// \brief Emit the expression \p Value into the output as a native + /// Emit the expression \p Value into the output as a native /// integer of the given \p Size bytes. /// /// This is used to implement assembler directives such as .word, .quad, @@ -607,7 +607,7 @@ void EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()); - /// \brief Special case of EmitValue that avoids the client having + /// Special case of EmitValue that avoids the client having /// to pass in a MCExpr for constant integers. virtual void EmitIntValue(uint64_t Value, unsigned Size); @@ -615,66 +615,66 @@ virtual void EmitSLEB128Value(const MCExpr *Value); - /// \brief Special case of EmitULEB128Value that avoids the client having to + /// Special case of EmitULEB128Value that avoids the client having to /// pass in a MCExpr for constant integers. void EmitULEB128IntValue(uint64_t Value); - /// \brief Special case of EmitSLEB128Value that avoids the client having to + /// Special case of EmitSLEB128Value that avoids the client having to /// pass in a MCExpr for constant integers. void EmitSLEB128IntValue(int64_t Value); - /// \brief Special case of EmitValue that avoids the client having to pass in + /// Special case of EmitValue that avoids the client having to pass in /// a MCExpr for MCSymbols. void EmitSymbolValue(const MCSymbol *Sym, unsigned Size, bool IsSectionRelative = false); - /// \brief Emit the expression \p Value into the output as a dtprel + /// Emit the expression \p Value into the output as a dtprel /// (64-bit DTP relative) value. /// /// This is used to implement assembler directives such as .dtpreldword on /// targets that support them. virtual void EmitDTPRel64Value(const MCExpr *Value); - /// \brief Emit the expression \p Value into the output as a dtprel + /// Emit the expression \p Value into the output as a dtprel /// (32-bit DTP relative) value. /// /// This is used to implement assembler directives such as .dtprelword on /// targets that support them. virtual void EmitDTPRel32Value(const MCExpr *Value); - /// \brief Emit the expression \p Value into the output as a tprel + /// Emit the expression \p Value into the output as a tprel /// (64-bit TP relative) value. /// /// This is used to implement assembler directives such as .tpreldword on /// targets that support them. virtual void EmitTPRel64Value(const MCExpr *Value); - /// \brief Emit the expression \p Value into the output as a tprel + /// Emit the expression \p Value into the output as a tprel /// (32-bit TP relative) value. /// /// This is used to implement assembler directives such as .tprelword on /// targets that support them. virtual void EmitTPRel32Value(const MCExpr *Value); - /// \brief Emit the expression \p Value into the output as a gprel64 (64-bit + /// Emit the expression \p Value into the output as a gprel64 (64-bit /// GP relative) value. /// /// This is used to implement assembler directives such as .gpdword on /// targets that support them. virtual void EmitGPRel64Value(const MCExpr *Value); - /// \brief Emit the expression \p Value into the output as a gprel32 (32-bit + /// Emit the expression \p Value into the output as a gprel32 (32-bit /// GP relative) value. /// /// This is used to implement assembler directives such as .gprel32 on /// targets that support them. virtual void EmitGPRel32Value(const MCExpr *Value); - /// \brief Emit NumBytes bytes worth of the value specified by FillValue. + /// Emit NumBytes bytes worth of the value specified by FillValue. /// This implements directives such as '.space'. void emitFill(uint64_t NumBytes, uint8_t FillValue); - /// \brief Emit \p Size bytes worth of the value specified by \p FillValue. + /// Emit \p Size bytes worth of the value specified by \p FillValue. /// /// This is used to implement assembler directives such as .space or .skip. /// @@ -684,7 +684,7 @@ virtual void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc = SMLoc()); - /// \brief Emit \p NumValues copies of \p Size bytes. Each \p Size bytes is + /// Emit \p NumValues copies of \p Size bytes. Each \p Size bytes is /// taken from the lowest order 4 bytes of \p Expr expression. /// /// This is used to implement assembler directives such as .fill. @@ -695,11 +695,11 @@ virtual void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr, SMLoc Loc = SMLoc()); - /// \brief Emit NumBytes worth of zeros. + /// Emit NumBytes worth of zeros. /// This function properly handles data in virtual sections. void EmitZeros(uint64_t NumBytes); - /// \brief Emit some number of copies of \p Value until the byte alignment \p + /// Emit some number of copies of \p Value until the byte alignment \p /// ByteAlignment is reached. /// /// If the number of bytes need to emit for the alignment is not a multiple @@ -720,7 +720,7 @@ unsigned ValueSize = 1, unsigned MaxBytesToEmit = 0); - /// \brief Emit nops until the byte alignment \p ByteAlignment is reached. + /// Emit nops until the byte alignment \p ByteAlignment is reached. /// /// This used to align code where the alignment bytes may be executed. This /// can emit different bytes for different sizes to optimize execution. @@ -733,7 +733,7 @@ virtual void EmitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit = 0); - /// \brief Emit some number of copies of \p Value until the byte offset \p + /// Emit some number of copies of \p Value until the byte offset \p /// Offset is reached. /// /// This is used to implement assembler directives such as .org. @@ -752,15 +752,15 @@ /// @} - /// \brief Switch to a new logical file. This is used to implement the '.file + /// Switch to a new logical file. This is used to implement the '.file /// "foo.c"' assembler directive. virtual void EmitFileDirective(StringRef Filename); - /// \brief Emit the "identifiers" directive. This implements the + /// Emit the "identifiers" directive. This implements the /// '.ident "version foo"' assembler directive. virtual void EmitIdent(StringRef IdentString) {} - /// \brief Associate a filename with a specified logical file number. This + /// Associate a filename with a specified logical file number. This /// implements the DWARF2 '.file 4 "foo.c"' assembler directive. unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory, StringRef Filename, @@ -788,7 +788,7 @@ Optional Source, unsigned CUID = 0); - /// \brief This implements the DWARF2 '.loc fileno lineno ...' assembler + /// This implements the DWARF2 '.loc fileno lineno ...' assembler /// directive. virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, @@ -802,27 +802,27 @@ ArrayRef Checksum, unsigned ChecksumKind); - /// \brief Introduces a function id for use with .cv_loc. + /// Introduces a function id for use with .cv_loc. virtual bool EmitCVFuncIdDirective(unsigned FunctionId); - /// \brief Introduces an inline call site id for use with .cv_loc. Includes + /// Introduces an inline call site id for use with .cv_loc. Includes /// extra information for inline line table generation. virtual bool EmitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc, unsigned IAFile, unsigned IALine, unsigned IACol, SMLoc Loc); - /// \brief This implements the CodeView '.cv_loc' assembler directive. + /// This implements the CodeView '.cv_loc' assembler directive. virtual void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc); - /// \brief This implements the CodeView '.cv_linetable' assembler directive. + /// This implements the CodeView '.cv_linetable' assembler directive. virtual void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart, const MCSymbol *FnEnd); - /// \brief This implements the CodeView '.cv_inline_linetable' assembler + /// This implements the CodeView '.cv_inline_linetable' assembler /// directive. virtual void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, @@ -830,16 +830,16 @@ const MCSymbol *FnStartSym, const MCSymbol *FnEndSym); - /// \brief This implements the CodeView '.cv_def_range' assembler + /// This implements the CodeView '.cv_def_range' assembler /// directive. virtual void EmitCVDefRangeDirective( ArrayRef> Ranges, StringRef FixedSizePortion); - /// \brief This implements the CodeView '.cv_stringtable' assembler directive. + /// This implements the CodeView '.cv_stringtable' assembler directive. virtual void EmitCVStringTableDirective() {} - /// \brief This implements the CodeView '.cv_filechecksums' assembler directive. + /// This implements the CodeView '.cv_filechecksums' assembler directive. virtual void EmitCVFileChecksumsDirective() {} /// This implements the CodeView '.cv_filechecksumoffset' assembler @@ -911,7 +911,7 @@ virtual void EmitSyntaxDirective(); - /// \brief Emit a .reloc directive. + /// Emit a .reloc directive. /// Returns true if the relocation could not be emitted because Name is not /// known. virtual bool EmitRelocDirective(const MCExpr &Offset, StringRef Name, @@ -919,33 +919,33 @@ return true; } - /// \brief Emit the given \p Instruction into the current section. + /// Emit the given \p Instruction into the current section. /// PrintSchedInfo == true then schedul comment should be added to output virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI, bool PrintSchedInfo = false); - /// \brief Set the bundle alignment mode from now on in the section. + /// Set the bundle alignment mode from now on in the section. /// The argument is the power of 2 to which the alignment is set. The /// value 0 means turn the bundle alignment off. virtual void EmitBundleAlignMode(unsigned AlignPow2); - /// \brief The following instructions are a bundle-locked group. + /// The following instructions are a bundle-locked group. /// /// \param AlignToEnd - If true, the bundle-locked group will be aligned to /// the end of a bundle. virtual void EmitBundleLock(bool AlignToEnd); - /// \brief Ends a bundle-locked group. + /// Ends a bundle-locked group. virtual void EmitBundleUnlock(); - /// \brief If this file is backed by a assembly streamer, this dumps the + /// If this file is backed by a assembly streamer, this dumps the /// specified string in the output .s file. This capability is indicated by /// the hasRawTextSupport() predicate. By default this aborts. void EmitRawText(const Twine &String); - /// \brief Streamer specific finalization. + /// Streamer specific finalization. virtual void FinishImpl(); - /// \brief Finish emission of machine code. + /// Finish emission of machine code. void Finish(); virtual bool mayHaveInstructions(MCSection &Sec) const { return true; } Index: llvm/trunk/include/llvm/MC/MCSymbol.h =================================================================== --- llvm/trunk/include/llvm/MC/MCSymbol.h +++ llvm/trunk/include/llvm/MC/MCSymbol.h @@ -85,7 +85,7 @@ /// "Lfoo" or ".foo". unsigned IsTemporary : 1; - /// \brief True if this symbol can be redefined. + /// True if this symbol can be redefined. unsigned IsRedefinable : 1; /// IsUsed - True if this symbol has been used. @@ -141,7 +141,7 @@ friend class MCExpr; friend class MCContext; - /// \brief The name for a symbol. + /// The name for a symbol. /// MCSymbol contains a uint64_t so is probably aligned to 8. On a 32-bit /// system, the name is a pointer so isn't going to satisfy the 8 byte /// alignment of uint64_t. Account for that here. @@ -168,11 +168,11 @@ private: void operator delete(void *); - /// \brief Placement delete - required by std, but never called. + /// Placement delete - required by std, but never called. void operator delete(void*, unsigned) { llvm_unreachable("Constructor throws?"); } - /// \brief Placement delete - required by std, but never called. + /// Placement delete - required by std, but never called. void operator delete(void*, unsigned, bool) { llvm_unreachable("Constructor throws?"); } @@ -185,7 +185,7 @@ return nullptr; } - /// \brief Get a reference to the name field. Requires that we have a name + /// Get a reference to the name field. Requires that we have a name const StringMapEntry *&getNameEntryPtr() { assert(FragmentAndHasName.getInt() && "Name is required"); NameEntryStorageTy *Name = reinterpret_cast(this); @@ -222,11 +222,11 @@ /// isUsed - Check if this is used. bool isUsed() const { return IsUsed; } - /// \brief Check if this symbol is redefinable. + /// Check if this symbol is redefinable. bool isRedefinable() const { return IsRedefinable; } - /// \brief Mark this symbol as redefinable. + /// Mark this symbol as redefinable. void setRedefinable(bool Value) { IsRedefinable = Value; } - /// \brief Prepare this symbol to be redefined. + /// Prepare this symbol to be redefined. void redefineIfPossible() { if (IsRedefinable) { if (SymbolContents == SymContentsVariable) { Index: llvm/trunk/include/llvm/MC/MCSymbolMachO.h =================================================================== --- llvm/trunk/include/llvm/MC/MCSymbolMachO.h +++ llvm/trunk/include/llvm/MC/MCSymbolMachO.h @@ -14,7 +14,7 @@ namespace llvm { class MCSymbolMachO : public MCSymbol { - /// \brief We store the value for the 'desc' symbol field in the + /// We store the value for the 'desc' symbol field in the /// lowest 16 bits of the implementation defined flags. enum MachOSymbolFlags : uint16_t { // See . SF_DescFlagsMask = 0xFFFF, @@ -104,7 +104,7 @@ setFlags(Value & SF_DescFlagsMask); } - /// \brief Get the encoded value of the flags as they will be emitted in to + /// Get the encoded value of the flags as they will be emitted in to /// the MachO binary uint16_t getEncodedFlags(bool EncodeAsAltEntry) const { uint16_t Flags = getFlags(); Index: llvm/trunk/include/llvm/MC/MCValue.h =================================================================== --- llvm/trunk/include/llvm/MC/MCValue.h +++ llvm/trunk/include/llvm/MC/MCValue.h @@ -23,7 +23,7 @@ class MCAsmInfo; class raw_ostream; -/// \brief This represents an "assembler immediate". +/// This represents an "assembler immediate". /// /// In its most general form, this can hold ":Kind:(SymbolA - SymbolB + /// imm64)". Not all targets supports relocations of this general form, but we @@ -49,13 +49,13 @@ const MCSymbolRefExpr *getSymB() const { return SymB; } uint32_t getRefKind() const { return RefKind; } - /// \brief Is this an absolute (as opposed to relocatable) value. + /// Is this an absolute (as opposed to relocatable) value. bool isAbsolute() const { return !SymA && !SymB; } - /// \brief Print the value to the stream \p OS. + /// Print the value to the stream \p OS. void print(raw_ostream &OS) const; - /// \brief Print the value to stderr. + /// Print the value to stderr. void dump() const; MCSymbolRefExpr::VariantKind getAccessVariant() const; Index: llvm/trunk/include/llvm/MC/MCWasmObjectWriter.h =================================================================== --- llvm/trunk/include/llvm/MC/MCWasmObjectWriter.h +++ llvm/trunk/include/llvm/MC/MCWasmObjectWriter.h @@ -39,7 +39,7 @@ /// @} }; -/// \brief Construct a new Wasm writer instance. +/// Construct a new Wasm writer instance. /// /// \param MOTW - The target specific Wasm writer subclass. /// \param OS - The stream to write to. Index: llvm/trunk/include/llvm/MC/MCWasmStreamer.h =================================================================== --- llvm/trunk/include/llvm/MC/MCWasmStreamer.h +++ llvm/trunk/include/llvm/MC/MCWasmStreamer.h @@ -73,7 +73,7 @@ void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override; void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override; - /// \brief Merge the content of the fragment \p EF into the fragment \p DF. + /// Merge the content of the fragment \p EF into the fragment \p DF. void mergeFragment(MCDataFragment *, MCDataFragment *); bool SeenIdent; Index: llvm/trunk/include/llvm/MC/MCWinCOFFObjectWriter.h =================================================================== --- llvm/trunk/include/llvm/MC/MCWinCOFFObjectWriter.h +++ llvm/trunk/include/llvm/MC/MCWinCOFFObjectWriter.h @@ -39,7 +39,7 @@ virtual bool recordRelocation(const MCFixup &) const { return true; } }; - /// \brief Construct a new Win COFF writer instance. + /// Construct a new Win COFF writer instance. /// /// \param MOTW - The target specific WinCOFF writer subclass. /// \param OS - The stream to write to. Index: llvm/trunk/include/llvm/MC/StringTableBuilder.h =================================================================== --- llvm/trunk/include/llvm/MC/StringTableBuilder.h +++ llvm/trunk/include/llvm/MC/StringTableBuilder.h @@ -20,7 +20,7 @@ class raw_ostream; -/// \brief Utility for building string tables with deduplicated suffixes. +/// Utility for building string tables with deduplicated suffixes. class StringTableBuilder { public: enum Kind { ELF, WinCOFF, MachO, RAW, DWARF }; @@ -39,13 +39,13 @@ StringTableBuilder(Kind K, unsigned Alignment = 1); ~StringTableBuilder(); - /// \brief Add a string to the builder. Returns the position of S in the + /// Add a string to the builder. Returns the position of S in the /// table. The position will be changed if finalize is used. /// Can only be used before the table is finalized. size_t add(CachedHashStringRef S); size_t add(StringRef S) { return add(CachedHashStringRef(S)); } - /// \brief Analyze the strings and build the final table. No more strings can + /// Analyze the strings and build the final table. No more strings can /// be added after this point. void finalize(); @@ -53,7 +53,7 @@ /// returned by add will still be valid. void finalizeInOrder(); - /// \brief Get the offest of a string in the string table. Can only be used + /// Get the offest of a string in the string table. Can only be used /// after the table is finalized. size_t getOffset(CachedHashStringRef S) const; size_t getOffset(StringRef S) const { Index: llvm/trunk/include/llvm/Object/Archive.h =================================================================== --- llvm/trunk/include/llvm/Object/Archive.h +++ llvm/trunk/include/llvm/Object/Archive.h @@ -91,9 +91,9 @@ const Archive *Parent; ArchiveMemberHeader Header; - /// \brief Includes header but not padding byte. + /// Includes header but not padding byte. StringRef Data; - /// \brief Offset from Data to the start of the file. + /// Offset from Data to the start of the file. uint16_t StartOfFile; Expected isThinMember() const; Index: llvm/trunk/include/llvm/Object/ELF.h =================================================================== --- llvm/trunk/include/llvm/Object/ELF.h +++ llvm/trunk/include/llvm/Object/ELF.h @@ -111,7 +111,7 @@ void getRelocationTypeName(uint32_t Type, SmallVectorImpl &Result) const; - /// \brief Get the symbol for a given relocation. + /// Get the symbol for a given relocation. Expected getRelocationSymbol(const Elf_Rel *Rel, const Elf_Shdr *SymTab) const; @@ -145,7 +145,7 @@ Expected> android_relas(const Elf_Shdr *Sec) const; - /// \brief Iterate over program header table. + /// Iterate over program header table. Expected program_headers() const { if (getHeader()->e_phnum && getHeader()->e_phentsize != sizeof(Elf_Phdr)) return createError("invalid e_phentsize"); Index: llvm/trunk/include/llvm/Object/ELFObjectFile.h =================================================================== --- llvm/trunk/include/llvm/Object/ELFObjectFile.h +++ llvm/trunk/include/llvm/Object/ELFObjectFile.h @@ -270,7 +270,7 @@ uint64_t getSectionOffset(DataRefImpl Sec) const override; StringRef getRelocationTypeName(uint32_t Type) const; - /// \brief Get the relocation section that contains \a Rel. + /// Get the relocation section that contains \a Rel. const Elf_Shdr *getRelSection(DataRefImpl Rel) const { auto RelSecOrErr = EF.getSection(Rel.d.a); if (!RelSecOrErr) Index: llvm/trunk/include/llvm/Object/IRObjectFile.h =================================================================== --- llvm/trunk/include/llvm/Object/IRObjectFile.h +++ llvm/trunk/include/llvm/Object/IRObjectFile.h @@ -50,11 +50,11 @@ return v->isIR(); } - /// \brief Finds and returns bitcode embedded in the given object file, or an + /// Finds and returns bitcode embedded in the given object file, or an /// error code if not found. static Expected findBitcodeInObject(const ObjectFile &Obj); - /// \brief Finds and returns bitcode in the given memory buffer (which may + /// Finds and returns bitcode in the given memory buffer (which may /// be either a bitcode file or a native object file with embedded bitcode), /// or an error code if not found. static Expected Index: llvm/trunk/include/llvm/Object/MachOUniversal.h =================================================================== --- llvm/trunk/include/llvm/Object/MachOUniversal.h +++ llvm/trunk/include/llvm/Object/MachOUniversal.h @@ -34,9 +34,9 @@ public: class ObjectForArch { const MachOUniversalBinary *Parent; - /// \brief Index of object in the universal binary. + /// Index of object in the universal binary. uint32_t Index; - /// \brief Descriptor of the object. + /// Descriptor of the object. MachO::fat_arch Header; MachO::fat_arch_64 Header64; Index: llvm/trunk/include/llvm/ObjectYAML/DWARFEmitter.h =================================================================== --- llvm/trunk/include/llvm/ObjectYAML/DWARFEmitter.h +++ llvm/trunk/include/llvm/ObjectYAML/DWARFEmitter.h @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// /// \file -/// \brief Common declarations for yaml2obj +/// Common declarations for yaml2obj //===----------------------------------------------------------------------===// #ifndef LLVM_OBJECTYAML_DWARFEMITTER_H Index: llvm/trunk/include/llvm/ObjectYAML/DWARFYAML.h =================================================================== --- llvm/trunk/include/llvm/ObjectYAML/DWARFYAML.h +++ llvm/trunk/include/llvm/ObjectYAML/DWARFYAML.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief This file declares classes for handling the YAML representation +/// This file declares classes for handling the YAML representation /// of DWARF Debug Info. /// //===----------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/ObjectYAML/ELFYAML.h =================================================================== --- llvm/trunk/include/llvm/ObjectYAML/ELFYAML.h +++ llvm/trunk/include/llvm/ObjectYAML/ELFYAML.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief This file declares classes for handling the YAML representation +/// This file declares classes for handling the YAML representation /// of ELF. /// //===----------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/ObjectYAML/MachOYAML.h =================================================================== --- llvm/trunk/include/llvm/ObjectYAML/MachOYAML.h +++ llvm/trunk/include/llvm/ObjectYAML/MachOYAML.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief This file declares classes for handling the YAML representation +/// This file declares classes for handling the YAML representation /// of Mach-O. /// //===----------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/ObjectYAML/WasmYAML.h =================================================================== --- llvm/trunk/include/llvm/ObjectYAML/WasmYAML.h +++ llvm/trunk/include/llvm/ObjectYAML/WasmYAML.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief This file declares classes for handling the YAML representation +/// This file declares classes for handling the YAML representation /// of wasm binaries. /// //===----------------------------------------------------------------------===// Index: llvm/trunk/include/llvm/ObjectYAML/YAML.h =================================================================== --- llvm/trunk/include/llvm/ObjectYAML/YAML.h +++ llvm/trunk/include/llvm/ObjectYAML/YAML.h @@ -21,7 +21,7 @@ namespace yaml { -/// \brief Specialized YAMLIO scalar type for representing a binary blob. +/// Specialized YAMLIO scalar type for representing a binary blob. /// /// A typical use case would be to represent the content of a section in a /// binary file. @@ -64,11 +64,11 @@ class BinaryRef { friend bool operator==(const BinaryRef &LHS, const BinaryRef &RHS); - /// \brief Either raw binary data, or a string of hex bytes (must always + /// Either raw binary data, or a string of hex bytes (must always /// be an even number of characters). ArrayRef Data; - /// \brief Discriminator between the two states of the `Data` member. + /// Discriminator between the two states of the `Data` member. bool DataIsHexString = true; public: @@ -77,7 +77,7 @@ BinaryRef(StringRef Data) : Data(reinterpret_cast(Data.data()), Data.size()) {} - /// \brief The number of bytes that are represented by this BinaryRef. + /// The number of bytes that are represented by this BinaryRef. /// This is the number of bytes that writeAsBinary() will write. ArrayRef::size_type binary_size() const { if (DataIsHexString) @@ -85,11 +85,11 @@ return Data.size(); } - /// \brief Write the contents (regardless of whether it is binary or a + /// Write the contents (regardless of whether it is binary or a /// hex string) as binary to the given raw_ostream. void writeAsBinary(raw_ostream &OS) const; - /// \brief Write the contents (regardless of whether it is binary or a + /// Write the contents (regardless of whether it is binary or a /// hex string) as hex to the given raw_ostream. /// /// For example, a possible output could be `DEADBEEFCAFEBABE`. Index: llvm/trunk/include/llvm/Option/Arg.h =================================================================== --- llvm/trunk/include/llvm/Option/Arg.h +++ llvm/trunk/include/llvm/Option/Arg.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief Defines the llvm::Arg class for parsed arguments. +/// Defines the llvm::Arg class for parsed arguments. /// //===----------------------------------------------------------------------===// @@ -28,35 +28,35 @@ class ArgList; -/// \brief A concrete instance of a particular driver option. +/// A concrete instance of a particular driver option. /// /// The Arg class encodes just enough information to be able to /// derive the argument values efficiently. class Arg { private: - /// \brief The option this argument is an instance of. + /// The option this argument is an instance of. const Option Opt; - /// \brief The argument this argument was derived from (during tool chain + /// The argument this argument was derived from (during tool chain /// argument translation), if any. const Arg *BaseArg; - /// \brief How this instance of the option was spelled. + /// How this instance of the option was spelled. StringRef Spelling; - /// \brief The index at which this argument appears in the containing + /// The index at which this argument appears in the containing /// ArgList. unsigned Index; - /// \brief Was this argument used to effect compilation? + /// Was this argument used to effect compilation? /// /// This is used for generating "argument unused" diagnostics. mutable unsigned Claimed : 1; - /// \brief Does this argument own its values? + /// Does this argument own its values? mutable unsigned OwnsValues : 1; - /// \brief The argument values, as C strings. + /// The argument values, as C strings. SmallVector Values; public: @@ -74,7 +74,7 @@ StringRef getSpelling() const { return Spelling; } unsigned getIndex() const { return Index; } - /// \brief Return the base argument which generated this arg. + /// Return the base argument which generated this arg. /// /// This is either the argument itself or the argument it was /// derived from during tool chain specific argument translation. @@ -88,7 +88,7 @@ bool isClaimed() const { return getBaseArg().Claimed; } - /// \brief Set the Arg claimed bit. + /// Set the Arg claimed bit. void claim() const { getBaseArg().Claimed = true; } unsigned getNumValues() const { return Values.size(); } @@ -107,10 +107,10 @@ return false; } - /// \brief Append the argument onto the given array as strings. + /// Append the argument onto the given array as strings. void render(const ArgList &Args, ArgStringList &Output) const; - /// \brief Append the argument, render as an input, onto the given + /// Append the argument, render as an input, onto the given /// array as strings. /// /// The distinction is that some options only render their values @@ -120,7 +120,7 @@ void print(raw_ostream &O) const; void dump() const; - /// \brief Return a formatted version of the argument and + /// Return a formatted version of the argument and /// its values, for debugging and diagnostics. std::string getAsString(const ArgList &Args) const; }; Index: llvm/trunk/include/llvm/Option/ArgList.h =================================================================== --- llvm/trunk/include/llvm/Option/ArgList.h +++ llvm/trunk/include/llvm/Option/ArgList.h @@ -356,7 +356,7 @@ return MakeArgStringRef(Str.toStringRef(Buf)); } - /// \brief Create an arg string for (\p LHS + \p RHS), reusing the + /// Create an arg string for (\p LHS + \p RHS), reusing the /// string at \p Index if possible. const char *GetOrMakeJoinedArgString(unsigned Index, StringRef LHS, StringRef RHS) const; Index: llvm/trunk/include/llvm/Option/OptTable.h =================================================================== --- llvm/trunk/include/llvm/Option/OptTable.h +++ llvm/trunk/include/llvm/Option/OptTable.h @@ -29,7 +29,7 @@ class InputArgList; class Option; -/// \brief Provide access to the Option info table. +/// Provide access to the Option info table. /// /// The OptTable class provides a layer of indirection which allows Option /// instance to be created lazily. In the common case, only a few options will @@ -38,7 +38,7 @@ /// parts of the driver still use Option instances where convenient. class OptTable { public: - /// \brief Entry for a single option instance in the option data table. + /// Entry for a single option instance in the option data table. struct Info { /// A null terminated array of prefix strings to apply to name while /// matching. @@ -57,7 +57,7 @@ }; private: - /// \brief The option information table. + /// The option information table. std::vector OptionInfos; bool IgnoreCase; @@ -86,36 +86,36 @@ public: ~OptTable(); - /// \brief Return the total number of option classes. + /// Return the total number of option classes. unsigned getNumOptions() const { return OptionInfos.size(); } - /// \brief Get the given Opt's Option instance, lazily creating it + /// Get the given Opt's Option instance, lazily creating it /// if necessary. /// /// \return The option, or null for the INVALID option id. const Option getOption(OptSpecifier Opt) const; - /// \brief Lookup the name of the given option. + /// Lookup the name of the given option. const char *getOptionName(OptSpecifier id) const { return getInfo(id).Name; } - /// \brief Get the kind of the given option. + /// Get the kind of the given option. unsigned getOptionKind(OptSpecifier id) const { return getInfo(id).Kind; } - /// \brief Get the group id for the given option. + /// Get the group id for the given option. unsigned getOptionGroupID(OptSpecifier id) const { return getInfo(id).GroupID; } - /// \brief Get the help text to use to describe this option. + /// Get the help text to use to describe this option. const char *getOptionHelpText(OptSpecifier id) const { return getInfo(id).HelpText; } - /// \brief Get the meta-variable name to use when describing + /// Get the meta-variable name to use when describing /// this options values in the help text. const char *getOptionMetaVar(OptSpecifier id) const { return getInfo(id).MetaVar; @@ -174,7 +174,7 @@ /// \return true in success, and false in fail. bool addValues(const char *Option, const char *Values); - /// \brief Parse a single argument; returning the new argument and + /// Parse a single argument; returning the new argument and /// updating Index. /// /// \param [in,out] Index - The current parsing position in the argument @@ -192,7 +192,7 @@ unsigned FlagsToInclude = 0, unsigned FlagsToExclude = 0) const; - /// \brief Parse an list of arguments into an InputArgList. + /// Parse an list of arguments into an InputArgList. /// /// The resulting InputArgList will reference the strings in [\p ArgBegin, /// \p ArgEnd), and their lifetime should extend past that of the returned @@ -214,7 +214,7 @@ unsigned &MissingArgCount, unsigned FlagsToInclude = 0, unsigned FlagsToExclude = 0) const; - /// \brief Render the help text for an option table. + /// Render the help text for an option table. /// /// \param OS - The stream to write the help text to. /// \param Name - The name to use in the usage line. Index: llvm/trunk/include/llvm/Option/Option.h =================================================================== --- llvm/trunk/include/llvm/Option/Option.h +++ llvm/trunk/include/llvm/Option/Option.h @@ -95,7 +95,7 @@ return OptionClass(Info->Kind); } - /// \brief Get the name of this option without any prefix. + /// Get the name of this option without any prefix. StringRef getName() const { assert(Info && "Must have a valid info!"); return Info->Name; @@ -113,7 +113,7 @@ return Owner->getOption(Info->AliasID); } - /// \brief Get the alias arguments as a \0 separated list. + /// Get the alias arguments as a \0 separated list. /// E.g. ["foo", "bar"] would be returned as "foo\0bar\0". const char *getAliasArgs() const { assert(Info && "Must have a valid info!"); @@ -123,13 +123,13 @@ return Info->AliasArgs; } - /// \brief Get the default prefix for this option. + /// Get the default prefix for this option. StringRef getPrefix() const { const char *Prefix = *Info->Prefixes; return Prefix ? Prefix : StringRef(); } - /// \brief Get the name of this option with the default prefix. + /// Get the name of this option with the default prefix. std::string getPrefixedName() const { std::string Ret = getPrefix(); Ret += getName(); Index: llvm/trunk/include/llvm/Passes/PassBuilder.h =================================================================== --- llvm/trunk/include/llvm/Passes/PassBuilder.h +++ llvm/trunk/include/llvm/Passes/PassBuilder.h @@ -48,7 +48,7 @@ bool SamplePGOSupport; }; -/// \brief This class provides access to building LLVM's passes. +/// This class provides access to building LLVM's passes. /// /// It's members provide the baseline state available to passes during their /// construction. The \c PassRegistry.def file specifies how to construct all @@ -59,7 +59,7 @@ Optional PGOOpt; public: - /// \brief A struct to capture parsed pass pipeline names. + /// A struct to capture parsed pass pipeline names. /// /// A pipeline is defined as a series of names, each of which may in itself /// recursively contain a nested pipeline. A name is either the name of a pass @@ -72,7 +72,7 @@ std::vector InnerPipeline; }; - /// \brief ThinLTO phase. + /// ThinLTO phase. /// /// This enumerates the LLVM ThinLTO optimization phases. enum class ThinLTOPhase { @@ -84,7 +84,7 @@ PostLink }; - /// \brief LLVM-provided high-level optimization levels. + /// LLVM-provided high-level optimization levels. /// /// This enumerates the LLVM-provided high-level optimization levels. Each /// level has a specific goal and rationale. @@ -174,7 +174,7 @@ Optional PGOOpt = None) : TM(TM), PGOOpt(PGOOpt) {} - /// \brief Cross register the analysis managers through their proxies. + /// Cross register the analysis managers through their proxies. /// /// This is an interface that can be used to cross register each // AnalysisManager with all the others analysis managers. @@ -183,7 +183,7 @@ CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM); - /// \brief Registers all available module analysis passes. + /// Registers all available module analysis passes. /// /// This is an interface that can be used to populate a \c /// ModuleAnalysisManager with all registered module analyses. Callers can @@ -191,7 +191,7 @@ /// pre-register analyses and this will not override those. void registerModuleAnalyses(ModuleAnalysisManager &MAM); - /// \brief Registers all available CGSCC analysis passes. + /// Registers all available CGSCC analysis passes. /// /// This is an interface that can be used to populate a \c CGSCCAnalysisManager /// with all registered CGSCC analyses. Callers can still manually register any @@ -199,7 +199,7 @@ /// not override those. void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM); - /// \brief Registers all available function analysis passes. + /// Registers all available function analysis passes. /// /// This is an interface that can be used to populate a \c /// FunctionAnalysisManager with all registered function analyses. Callers can @@ -207,7 +207,7 @@ /// pre-register analyses and this will not override those. void registerFunctionAnalyses(FunctionAnalysisManager &FAM); - /// \brief Registers all available loop analysis passes. + /// Registers all available loop analysis passes. /// /// This is an interface that can be used to populate a \c LoopAnalysisManager /// with all registered loop analyses. Callers can still manually register any @@ -346,7 +346,7 @@ /// registered. AAManager buildDefaultAAPipeline(); - /// \brief Parse a textual pass pipeline description into a \c + /// Parse a textual pass pipeline description into a \c /// ModulePassManager. /// /// The format of the textual pass pipeline description looks something like: @@ -410,7 +410,7 @@ /// returns false. bool parseAAPipeline(AAManager &AA, StringRef PipelineText); - /// \brief Register a callback for a default optimizer pipeline extension + /// Register a callback for a default optimizer pipeline extension /// point /// /// This extension point allows adding passes that perform peephole @@ -421,7 +421,7 @@ PeepholeEPCallbacks.push_back(C); } - /// \brief Register a callback for a default optimizer pipeline extension + /// Register a callback for a default optimizer pipeline extension /// point /// /// This extension point allows adding late loop canonicalization and @@ -435,7 +435,7 @@ LateLoopOptimizationsEPCallbacks.push_back(C); } - /// \brief Register a callback for a default optimizer pipeline extension + /// Register a callback for a default optimizer pipeline extension /// point /// /// This extension point allows adding loop passes to the end of the loop @@ -445,7 +445,7 @@ LoopOptimizerEndEPCallbacks.push_back(C); } - /// \brief Register a callback for a default optimizer pipeline extension + /// Register a callback for a default optimizer pipeline extension /// point /// /// This extension point allows adding optimization passes after most of the @@ -455,7 +455,7 @@ ScalarOptimizerLateEPCallbacks.push_back(C); } - /// \brief Register a callback for a default optimizer pipeline extension + /// Register a callback for a default optimizer pipeline extension /// point /// /// This extension point allows adding CallGraphSCC passes at the end of the @@ -466,7 +466,7 @@ CGSCCOptimizerLateEPCallbacks.push_back(C); } - /// \brief Register a callback for a default optimizer pipeline extension + /// Register a callback for a default optimizer pipeline extension /// point /// /// This extension point allows adding optimization passes before the @@ -487,7 +487,7 @@ PipelineStartEPCallbacks.push_back(C); } - /// \brief Register a callback for parsing an AliasAnalysis Name to populate + /// Register a callback for parsing an AliasAnalysis Name to populate /// the given AAManager \p AA void registerParseAACallback( const std::function &C) { @@ -541,7 +541,7 @@ } /// @}} - /// \brief Register a callback for a top-level pipeline entry. + /// Register a callback for a top-level pipeline entry. /// /// If the PassManager type is not given at the top level of the pipeline /// text, this Callback should be used to determine the appropriate stack of Index: llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h +++ llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h @@ -32,7 +32,7 @@ class CoverageMappingReader; -/// \brief Coverage mapping information for a single function. +/// Coverage mapping information for a single function. struct CoverageMappingRecord { StringRef FunctionName; uint64_t FunctionHash; @@ -41,7 +41,7 @@ ArrayRef MappingRegions; }; -/// \brief A file format agnostic iterator over coverage mapping data. +/// A file format agnostic iterator over coverage mapping data. class CoverageMappingIterator : public std::iterator { CoverageMappingReader *Reader; @@ -101,7 +101,7 @@ CoverageMappingIterator end() { return CoverageMappingIterator(); } }; -/// \brief Base class for the raw coverage mapping and filenames data readers. +/// Base class for the raw coverage mapping and filenames data readers. class RawCoverageReader { protected: StringRef Data; @@ -114,7 +114,7 @@ Error readString(StringRef &Result); }; -/// \brief Reader for the raw coverage filenames. +/// Reader for the raw coverage filenames. class RawCoverageFilenamesReader : public RawCoverageReader { std::vector &Filenames; @@ -128,7 +128,7 @@ Error read(); }; -/// \brief Checks if the given coverage mapping data is exported for +/// Checks if the given coverage mapping data is exported for /// an unused function. class RawCoverageMappingDummyChecker : public RawCoverageReader { public: @@ -138,7 +138,7 @@ Expected isDummy(); }; -/// \brief Reader for the raw coverage mapping data. +/// Reader for the raw coverage mapping data. class RawCoverageMappingReader : public RawCoverageReader { ArrayRef TranslationUnitFilenames; std::vector &Filenames; @@ -169,7 +169,7 @@ unsigned InferredFileID, size_t NumFileIDs); }; -/// \brief Reader for the coverage mapping data that is emitted by the +/// Reader for the coverage mapping data that is emitted by the /// frontend and stored in an object file. class BinaryCoverageReader : public CoverageMappingReader { public: Index: llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h +++ llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h @@ -25,7 +25,7 @@ namespace coverage { -/// \brief Writer of the filenames section for the instrumentation +/// Writer of the filenames section for the instrumentation /// based code coverage. class CoverageFilenamesSectionWriter { ArrayRef Filenames; @@ -34,11 +34,11 @@ CoverageFilenamesSectionWriter(ArrayRef Filenames) : Filenames(Filenames) {} - /// \brief Write encoded filenames to the given output stream. + /// Write encoded filenames to the given output stream. void write(raw_ostream &OS); }; -/// \brief Writer for instrumentation based coverage mapping data. +/// Writer for instrumentation based coverage mapping data. class CoverageMappingWriter { ArrayRef VirtualFileMapping; ArrayRef Expressions; @@ -51,7 +51,7 @@ : VirtualFileMapping(VirtualFileMapping), Expressions(Expressions), MappingRegions(MappingRegions) {} - /// \brief Write encoded coverage mapping data to the given output stream. + /// Write encoded coverage mapping data to the given output stream. void write(raw_ostream &OS); }; Index: llvm/trunk/include/llvm/ProfileData/GCOV.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/GCOV.h +++ llvm/trunk/include/llvm/ProfileData/GCOV.h @@ -41,7 +41,7 @@ enum GCOVVersion { V402, V404, V704 }; -/// \brief A struct for passing gcov options between functions. +/// A struct for passing gcov options between functions. struct Options { Options(bool A, bool B, bool C, bool F, bool P, bool U, bool L, bool N) : AllBlocks(A), BranchInfo(B), BranchCount(C), FuncCoverage(F), Index: llvm/trunk/include/llvm/ProfileData/InstrProfData.inc =================================================================== --- llvm/trunk/include/llvm/ProfileData/InstrProfData.inc +++ llvm/trunk/include/llvm/ProfileData/InstrProfData.inc @@ -308,11 +308,11 @@ #ifdef __cplusplus /*! - * \brief Return the number of value sites. + * Return the number of value sites. */ uint32_t getNumValueSites() const { return NumValueSites; } /*! - * \brief Read data from this record and save it to Record. + * Read data from this record and save it to Record. */ void deserializeTo(InstrProfRecord &Record, InstrProfSymtab *SymTab); @@ -458,7 +458,7 @@ #endif /*! - * \brief Return the \c ValueProfRecord header size including the + * Return the \c ValueProfRecord header size including the * padding bytes. */ INSTR_PROF_VISIBILITY INSTR_PROF_INLINE @@ -471,7 +471,7 @@ } /*! - * \brief Return the total size of the value profile record including the + * Return the total size of the value profile record including the * header and the value data. */ INSTR_PROF_VISIBILITY INSTR_PROF_INLINE @@ -482,7 +482,7 @@ } /*! - * \brief Return the pointer to the start of value data array. + * Return the pointer to the start of value data array. */ INSTR_PROF_VISIBILITY INSTR_PROF_INLINE InstrProfValueData *getValueProfRecordValueData(ValueProfRecord *This) { @@ -491,7 +491,7 @@ } /*! - * \brief Return the total number of value data for \c This record. + * Return the total number of value data for \c This record. */ INSTR_PROF_VISIBILITY INSTR_PROF_INLINE uint32_t getValueProfRecordNumValueData(ValueProfRecord *This) { @@ -503,7 +503,7 @@ } /*! - * \brief Use this method to advance to the next \c This \c ValueProfRecord. + * Use this method to advance to the next \c This \c ValueProfRecord. */ INSTR_PROF_VISIBILITY INSTR_PROF_INLINE ValueProfRecord *getValueProfRecordNext(ValueProfRecord *This) { @@ -514,7 +514,7 @@ } /*! - * \brief Return the first \c ValueProfRecord instance. + * Return the first \c ValueProfRecord instance. */ INSTR_PROF_VISIBILITY INSTR_PROF_INLINE ValueProfRecord *getFirstValueProfRecord(ValueProfData *This) { Index: llvm/trunk/include/llvm/ProfileData/ProfileCommon.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/ProfileCommon.h +++ llvm/trunk/include/llvm/ProfileData/ProfileCommon.h @@ -61,7 +61,7 @@ void computeDetailedSummary(); public: - /// \brief A vector of useful cutoff values for detailed summary. + /// A vector of useful cutoff values for detailed summary. static const ArrayRef DefaultCutoffs; }; Index: llvm/trunk/include/llvm/ProfileData/SampleProf.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/SampleProf.h +++ llvm/trunk/include/llvm/ProfileData/SampleProf.h @@ -387,7 +387,7 @@ /// We assume that a single function will not exceed 65535 LOC. static unsigned getOffset(const DILocation *DIL); - /// \brief Get the FunctionSamples of the inline instance where DIL originates + /// Get the FunctionSamples of the inline instance where DIL originates /// from. /// /// The FunctionSamples of the instruction (Machine or IR) associated to Index: llvm/trunk/include/llvm/ProfileData/SampleProfReader.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/SampleProfReader.h +++ llvm/trunk/include/llvm/ProfileData/SampleProfReader.h @@ -235,7 +235,7 @@ namespace sampleprof { -/// \brief Sample-based profile reader. +/// Sample-based profile reader. /// /// Each profile contains sample counts for all the functions /// executed. Inside each function, statements are annotated with the @@ -269,19 +269,19 @@ virtual ~SampleProfileReader() = default; - /// \brief Read and validate the file header. + /// Read and validate the file header. virtual std::error_code readHeader() = 0; - /// \brief Read sample profiles from the associated file. + /// Read sample profiles from the associated file. virtual std::error_code read() = 0; - /// \brief Print the profile for \p FName on stream \p OS. + /// Print the profile for \p FName on stream \p OS. void dumpFunctionProfile(StringRef FName, raw_ostream &OS = dbgs()); - /// \brief Print all the profiles on stream \p OS. + /// Print all the profiles on stream \p OS. void dump(raw_ostream &OS = dbgs()); - /// \brief Return the samples collected for function \p F. + /// Return the samples collected for function \p F. FunctionSamples *getSamplesFor(const Function &F) { // The function name may have been updated by adding suffix. In sample // profile, the function names are all stripped, so we need to strip @@ -291,44 +291,44 @@ return nullptr; } - /// \brief Return all the profiles. + /// Return all the profiles. StringMap &getProfiles() { return Profiles; } - /// \brief Report a parse error message. + /// Report a parse error message. void reportError(int64_t LineNumber, Twine Msg) const { Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(), LineNumber, Msg)); } - /// \brief Create a sample profile reader appropriate to the file format. + /// Create a sample profile reader appropriate to the file format. static ErrorOr> create(const Twine &Filename, LLVMContext &C); - /// \brief Create a sample profile reader from the supplied memory buffer. + /// Create a sample profile reader from the supplied memory buffer. static ErrorOr> create(std::unique_ptr &B, LLVMContext &C); - /// \brief Return the profile summary. + /// Return the profile summary. ProfileSummary &getSummary() { return *(Summary.get()); } protected: - /// \brief Map every function to its associated profile. + /// Map every function to its associated profile. /// /// The profile of every function executed at runtime is collected /// in the structure FunctionSamples. This maps function objects /// to their corresponding profiles. StringMap Profiles; - /// \brief LLVM context used to emit diagnostics. + /// LLVM context used to emit diagnostics. LLVMContext &Ctx; - /// \brief Memory buffer holding the profile file. + /// Memory buffer holding the profile file. std::unique_ptr Buffer; - /// \brief Profile summary information. + /// Profile summary information. std::unique_ptr Summary; - /// \brief Compute summary for this profile. + /// Compute summary for this profile. void computeSummary(); }; @@ -337,13 +337,13 @@ SampleProfileReaderText(std::unique_ptr B, LLVMContext &C) : SampleProfileReader(std::move(B), C) {} - /// \brief Read and validate the file header. + /// Read and validate the file header. std::error_code readHeader() override { return sampleprof_error::success; } - /// \brief Read sample profiles from the associated file. + /// Read sample profiles from the associated file. std::error_code read() override; - /// \brief Return true if \p Buffer is in the format supported by this class. + /// Return true if \p Buffer is in the format supported by this class. static bool hasFormat(const MemoryBuffer &Buffer); }; @@ -352,17 +352,17 @@ SampleProfileReaderBinary(std::unique_ptr B, LLVMContext &C) : SampleProfileReader(std::move(B), C) {} - /// \brief Read and validate the file header. + /// Read and validate the file header. std::error_code readHeader() override; - /// \brief Read sample profiles from the associated file. + /// Read sample profiles from the associated file. std::error_code read() override; - /// \brief Return true if \p Buffer is in the format supported by this class. + /// Return true if \p Buffer is in the format supported by this class. static bool hasFormat(const MemoryBuffer &Buffer); protected: - /// \brief Read a numeric value of type T from the profile. + /// Read a numeric value of type T from the profile. /// /// If an error occurs during decoding, a diagnostic message is emitted and /// EC is set. @@ -370,7 +370,7 @@ /// \returns the read value. template ErrorOr readNumber(); - /// \brief Read a string from the profile. + /// Read a string from the profile. /// /// If an error occurs during decoding, a diagnostic message is emitted and /// EC is set. @@ -381,16 +381,16 @@ /// Read a string indirectly via the name table. ErrorOr readStringFromTable(); - /// \brief Return true if we've reached the end of file. + /// Return true if we've reached the end of file. bool at_eof() const { return Data >= End; } /// Read the contents of the given profile instance. std::error_code readProfile(FunctionSamples &FProfile); - /// \brief Points to the current location in the buffer. + /// Points to the current location in the buffer. const uint8_t *Data = nullptr; - /// \brief Points to the end of the buffer. + /// Points to the end of the buffer. const uint8_t *End = nullptr; /// Function name table. @@ -399,7 +399,7 @@ private: std::error_code readSummaryEntry(std::vector &Entries); - /// \brief Read profile summary. + /// Read profile summary. std::error_code readSummary(); }; @@ -423,13 +423,13 @@ SampleProfileReaderGCC(std::unique_ptr B, LLVMContext &C) : SampleProfileReader(std::move(B), C), GcovBuffer(Buffer.get()) {} - /// \brief Read and validate the file header. + /// Read and validate the file header. std::error_code readHeader() override; - /// \brief Read sample profiles from the associated file. + /// Read sample profiles from the associated file. std::error_code read() override; - /// \brief Return true if \p Buffer is in the format supported by this class. + /// Return true if \p Buffer is in the format supported by this class. static bool hasFormat(const MemoryBuffer &Buffer); protected: @@ -441,7 +441,7 @@ template ErrorOr readNumber(); ErrorOr readString(); - /// \brief Read the section tag and check that it's the same as \p Expected. + /// Read the section tag and check that it's the same as \p Expected. std::error_code readSectionTag(uint32_t Expected); /// GCOV buffer containing the profile. Index: llvm/trunk/include/llvm/ProfileData/SampleProfWriter.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/SampleProfWriter.h +++ llvm/trunk/include/llvm/ProfileData/SampleProfWriter.h @@ -30,7 +30,7 @@ enum SampleProfileFormat { SPF_None = 0, SPF_Text, SPF_Binary, SPF_GCC }; -/// \brief Sample-based profile writer. Base class. +/// Sample-based profile writer. Base class. class SampleProfileWriter { public: virtual ~SampleProfileWriter() = default; @@ -62,21 +62,21 @@ SampleProfileWriter(std::unique_ptr &OS) : OutputStream(std::move(OS)) {} - /// \brief Write a file header for the profile file. + /// Write a file header for the profile file. virtual std::error_code writeHeader(const StringMap &ProfileMap) = 0; - /// \brief Output stream where to emit the profile to. + /// Output stream where to emit the profile to. std::unique_ptr OutputStream; - /// \brief Profile summary. + /// Profile summary. std::unique_ptr Summary; - /// \brief Compute summary for this profile. + /// Compute summary for this profile. void computeSummary(const StringMap &ProfileMap); }; -/// \brief Sample-based profile writer (text format). +/// Sample-based profile writer (text format). class SampleProfileWriterText : public SampleProfileWriter { public: std::error_code write(const FunctionSamples &S) override; @@ -101,7 +101,7 @@ SampleProfileFormat Format); }; -/// \brief Sample-based profile writer (binary format). +/// Sample-based profile writer (binary format). class SampleProfileWriterBinary : public SampleProfileWriter { public: std::error_code write(const FunctionSamples &S) override; Index: llvm/trunk/include/llvm/Support/AMDGPUKernelDescriptor.h =================================================================== --- llvm/trunk/include/llvm/Support/AMDGPUKernelDescriptor.h +++ llvm/trunk/include/llvm/Support/AMDGPUKernelDescriptor.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// // /// \file -/// \brief AMDGPU kernel descriptor definitions. For more information, visit +/// AMDGPU kernel descriptor definitions. For more information, visit /// https://llvm.org/docs/AMDGPUUsage.html#kernel-descriptor-for-gfx6-gfx9 // //===----------------------------------------------------------------------===// @@ -38,7 +38,7 @@ namespace AMDGPU { namespace HSAKD { -/// \brief Floating point rounding modes. +/// Floating point rounding modes. enum : uint8_t { AMDGPU_FLOAT_ROUND_MODE_NEAR_EVEN = 0, AMDGPU_FLOAT_ROUND_MODE_PLUS_INFINITY = 1, @@ -46,7 +46,7 @@ AMDGPU_FLOAT_ROUND_MODE_ZERO = 3, }; -/// \brief Floating point denorm modes. +/// Floating point denorm modes. enum : uint8_t { AMDGPU_FLOAT_DENORM_MODE_FLUSH_SRC_DST = 0, AMDGPU_FLOAT_DENORM_MODE_FLUSH_DST = 1, @@ -54,7 +54,7 @@ AMDGPU_FLOAT_DENORM_MODE_FLUSH_NONE = 3, }; -/// \brief System VGPR workitem IDs. +/// System VGPR workitem IDs. enum : uint8_t { AMDGPU_SYSTEM_VGPR_WORKITEM_ID_X = 0, AMDGPU_SYSTEM_VGPR_WORKITEM_ID_X_Y = 1, @@ -62,7 +62,7 @@ AMDGPU_SYSTEM_VGPR_WORKITEM_ID_UNDEFINED = 3, }; -/// \brief Compute program resource register one layout. +/// Compute program resource register one layout. enum ComputePgmRsrc1 { AMDGPU_BITS_ENUM_ENTRY(GRANULATED_WORKITEM_VGPR_COUNT, 0, 6), AMDGPU_BITS_ENUM_ENTRY(GRANULATED_WAVEFRONT_SGPR_COUNT, 6, 4), @@ -81,7 +81,7 @@ AMDGPU_BITS_ENUM_ENTRY(RESERVED0, 27, 5), }; -/// \brief Compute program resource register two layout. +/// Compute program resource register two layout. enum ComputePgmRsrc2 { AMDGPU_BITS_ENUM_ENTRY(ENABLE_SGPR_PRIVATE_SEGMENT_WAVE_OFFSET, 0, 1), AMDGPU_BITS_ENUM_ENTRY(USER_SGPR_COUNT, 1, 5), @@ -104,7 +104,7 @@ AMDGPU_BITS_ENUM_ENTRY(RESERVED1, 31, 1), }; -/// \brief Kernel descriptor layout. This layout should be kept backwards +/// Kernel descriptor layout. This layout should be kept backwards /// compatible as it is consumed by the command processor. struct KernelDescriptor final { uint32_t GroupSegmentFixedSize; Index: llvm/trunk/include/llvm/Support/AMDGPUMetadata.h =================================================================== --- llvm/trunk/include/llvm/Support/AMDGPUMetadata.h +++ llvm/trunk/include/llvm/Support/AMDGPUMetadata.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// // /// \file -/// \brief AMDGPU metadata definitions and in-memory representations. +/// AMDGPU metadata definitions and in-memory representations. /// // //===----------------------------------------------------------------------===// @@ -29,17 +29,17 @@ //===----------------------------------------------------------------------===// namespace HSAMD { -/// \brief HSA metadata major version. +/// HSA metadata major version. constexpr uint32_t VersionMajor = 1; -/// \brief HSA metadata minor version. +/// HSA metadata minor version. constexpr uint32_t VersionMinor = 0; -/// \brief HSA metadata beginning assembler directive. +/// HSA metadata beginning assembler directive. constexpr char AssemblerDirectiveBegin[] = ".amd_amdgpu_hsa_metadata"; -/// \brief HSA metadata ending assembler directive. +/// HSA metadata ending assembler directive. constexpr char AssemblerDirectiveEnd[] = ".end_amd_amdgpu_hsa_metadata"; -/// \brief Access qualifiers. +/// Access qualifiers. enum class AccessQualifier : uint8_t { Default = 0, ReadOnly = 1, @@ -48,7 +48,7 @@ Unknown = 0xff }; -/// \brief Address space qualifiers. +/// Address space qualifiers. enum class AddressSpaceQualifier : uint8_t { Private = 0, Global = 1, @@ -59,7 +59,7 @@ Unknown = 0xff }; -/// \brief Value kinds. +/// Value kinds. enum class ValueKind : uint8_t { ByValue = 0, GlobalBuffer = 1, @@ -78,7 +78,7 @@ Unknown = 0xff }; -/// \brief Value types. +/// Value types. enum class ValueType : uint8_t { Struct = 0, I8 = 1, @@ -106,29 +106,29 @@ namespace Attrs { namespace Key { -/// \brief Key for Kernel::Attr::Metadata::mReqdWorkGroupSize. +/// Key for Kernel::Attr::Metadata::mReqdWorkGroupSize. constexpr char ReqdWorkGroupSize[] = "ReqdWorkGroupSize"; -/// \brief Key for Kernel::Attr::Metadata::mWorkGroupSizeHint. +/// Key for Kernel::Attr::Metadata::mWorkGroupSizeHint. constexpr char WorkGroupSizeHint[] = "WorkGroupSizeHint"; -/// \brief Key for Kernel::Attr::Metadata::mVecTypeHint. +/// Key for Kernel::Attr::Metadata::mVecTypeHint. constexpr char VecTypeHint[] = "VecTypeHint"; -/// \brief Key for Kernel::Attr::Metadata::mRuntimeHandle. +/// Key for Kernel::Attr::Metadata::mRuntimeHandle. constexpr char RuntimeHandle[] = "RuntimeHandle"; } // end namespace Key -/// \brief In-memory representation of kernel attributes metadata. +/// In-memory representation of kernel attributes metadata. struct Metadata final { - /// \brief 'reqd_work_group_size' attribute. Optional. + /// 'reqd_work_group_size' attribute. Optional. std::vector mReqdWorkGroupSize = std::vector(); - /// \brief 'work_group_size_hint' attribute. Optional. + /// 'work_group_size_hint' attribute. Optional. std::vector mWorkGroupSizeHint = std::vector(); - /// \brief 'vec_type_hint' attribute. Optional. + /// 'vec_type_hint' attribute. Optional. std::string mVecTypeHint = std::string(); - /// \brief External symbol created by runtime to store the kernel address + /// External symbol created by runtime to store the kernel address /// for enqueued blocks. std::string mRuntimeHandle = std::string(); - /// \brief Default constructor. + /// Default constructor. Metadata() = default; /// \returns True if kernel attributes metadata is empty, false otherwise. @@ -151,68 +151,68 @@ namespace Arg { namespace Key { -/// \brief Key for Kernel::Arg::Metadata::mName. +/// Key for Kernel::Arg::Metadata::mName. constexpr char Name[] = "Name"; -/// \brief Key for Kernel::Arg::Metadata::mTypeName. +/// Key for Kernel::Arg::Metadata::mTypeName. constexpr char TypeName[] = "TypeName"; -/// \brief Key for Kernel::Arg::Metadata::mSize. +/// Key for Kernel::Arg::Metadata::mSize. constexpr char Size[] = "Size"; -/// \brief Key for Kernel::Arg::Metadata::mAlign. +/// Key for Kernel::Arg::Metadata::mAlign. constexpr char Align[] = "Align"; -/// \brief Key for Kernel::Arg::Metadata::mValueKind. +/// Key for Kernel::Arg::Metadata::mValueKind. constexpr char ValueKind[] = "ValueKind"; -/// \brief Key for Kernel::Arg::Metadata::mValueType. +/// Key for Kernel::Arg::Metadata::mValueType. constexpr char ValueType[] = "ValueType"; -/// \brief Key for Kernel::Arg::Metadata::mPointeeAlign. +/// Key for Kernel::Arg::Metadata::mPointeeAlign. constexpr char PointeeAlign[] = "PointeeAlign"; -/// \brief Key for Kernel::Arg::Metadata::mAddrSpaceQual. +/// Key for Kernel::Arg::Metadata::mAddrSpaceQual. constexpr char AddrSpaceQual[] = "AddrSpaceQual"; -/// \brief Key for Kernel::Arg::Metadata::mAccQual. +/// Key for Kernel::Arg::Metadata::mAccQual. constexpr char AccQual[] = "AccQual"; -/// \brief Key for Kernel::Arg::Metadata::mActualAccQual. +/// Key for Kernel::Arg::Metadata::mActualAccQual. constexpr char ActualAccQual[] = "ActualAccQual"; -/// \brief Key for Kernel::Arg::Metadata::mIsConst. +/// Key for Kernel::Arg::Metadata::mIsConst. constexpr char IsConst[] = "IsConst"; -/// \brief Key for Kernel::Arg::Metadata::mIsRestrict. +/// Key for Kernel::Arg::Metadata::mIsRestrict. constexpr char IsRestrict[] = "IsRestrict"; -/// \brief Key for Kernel::Arg::Metadata::mIsVolatile. +/// Key for Kernel::Arg::Metadata::mIsVolatile. constexpr char IsVolatile[] = "IsVolatile"; -/// \brief Key for Kernel::Arg::Metadata::mIsPipe. +/// Key for Kernel::Arg::Metadata::mIsPipe. constexpr char IsPipe[] = "IsPipe"; } // end namespace Key -/// \brief In-memory representation of kernel argument metadata. +/// In-memory representation of kernel argument metadata. struct Metadata final { - /// \brief Name. Optional. + /// Name. Optional. std::string mName = std::string(); - /// \brief Type name. Optional. + /// Type name. Optional. std::string mTypeName = std::string(); - /// \brief Size in bytes. Required. + /// Size in bytes. Required. uint32_t mSize = 0; - /// \brief Alignment in bytes. Required. + /// Alignment in bytes. Required. uint32_t mAlign = 0; - /// \brief Value kind. Required. + /// Value kind. Required. ValueKind mValueKind = ValueKind::Unknown; - /// \brief Value type. Required. + /// Value type. Required. ValueType mValueType = ValueType::Unknown; - /// \brief Pointee alignment in bytes. Optional. + /// Pointee alignment in bytes. Optional. uint32_t mPointeeAlign = 0; - /// \brief Address space qualifier. Optional. + /// Address space qualifier. Optional. AddressSpaceQualifier mAddrSpaceQual = AddressSpaceQualifier::Unknown; - /// \brief Access qualifier. Optional. + /// Access qualifier. Optional. AccessQualifier mAccQual = AccessQualifier::Unknown; - /// \brief Actual access qualifier. Optional. + /// Actual access qualifier. Optional. AccessQualifier mActualAccQual = AccessQualifier::Unknown; - /// \brief True if 'const' qualifier is specified. Optional. + /// True if 'const' qualifier is specified. Optional. bool mIsConst = false; - /// \brief True if 'restrict' qualifier is specified. Optional. + /// True if 'restrict' qualifier is specified. Optional. bool mIsRestrict = false; - /// \brief True if 'volatile' qualifier is specified. Optional. + /// True if 'volatile' qualifier is specified. Optional. bool mIsVolatile = false; - /// \brief True if 'pipe' qualifier is specified. Optional. + /// True if 'pipe' qualifier is specified. Optional. bool mIsPipe = false; - /// \brief Default constructor. + /// Default constructor. Metadata() = default; }; @@ -224,67 +224,67 @@ namespace CodeProps { namespace Key { -/// \brief Key for Kernel::CodeProps::Metadata::mKernargSegmentSize. +/// Key for Kernel::CodeProps::Metadata::mKernargSegmentSize. constexpr char KernargSegmentSize[] = "KernargSegmentSize"; -/// \brief Key for Kernel::CodeProps::Metadata::mGroupSegmentFixedSize. +/// Key for Kernel::CodeProps::Metadata::mGroupSegmentFixedSize. constexpr char GroupSegmentFixedSize[] = "GroupSegmentFixedSize"; -/// \brief Key for Kernel::CodeProps::Metadata::mPrivateSegmentFixedSize. +/// Key for Kernel::CodeProps::Metadata::mPrivateSegmentFixedSize. constexpr char PrivateSegmentFixedSize[] = "PrivateSegmentFixedSize"; -/// \brief Key for Kernel::CodeProps::Metadata::mKernargSegmentAlign. +/// Key for Kernel::CodeProps::Metadata::mKernargSegmentAlign. constexpr char KernargSegmentAlign[] = "KernargSegmentAlign"; -/// \brief Key for Kernel::CodeProps::Metadata::mWavefrontSize. +/// Key for Kernel::CodeProps::Metadata::mWavefrontSize. constexpr char WavefrontSize[] = "WavefrontSize"; -/// \brief Key for Kernel::CodeProps::Metadata::mNumSGPRs. +/// Key for Kernel::CodeProps::Metadata::mNumSGPRs. constexpr char NumSGPRs[] = "NumSGPRs"; -/// \brief Key for Kernel::CodeProps::Metadata::mNumVGPRs. +/// Key for Kernel::CodeProps::Metadata::mNumVGPRs. constexpr char NumVGPRs[] = "NumVGPRs"; -/// \brief Key for Kernel::CodeProps::Metadata::mMaxFlatWorkGroupSize. +/// Key for Kernel::CodeProps::Metadata::mMaxFlatWorkGroupSize. constexpr char MaxFlatWorkGroupSize[] = "MaxFlatWorkGroupSize"; -/// \brief Key for Kernel::CodeProps::Metadata::mIsDynamicCallStack. +/// Key for Kernel::CodeProps::Metadata::mIsDynamicCallStack. constexpr char IsDynamicCallStack[] = "IsDynamicCallStack"; -/// \brief Key for Kernel::CodeProps::Metadata::mIsXNACKEnabled. +/// Key for Kernel::CodeProps::Metadata::mIsXNACKEnabled. constexpr char IsXNACKEnabled[] = "IsXNACKEnabled"; -/// \brief Key for Kernel::CodeProps::Metadata::mNumSpilledSGPRs. +/// Key for Kernel::CodeProps::Metadata::mNumSpilledSGPRs. constexpr char NumSpilledSGPRs[] = "NumSpilledSGPRs"; -/// \brief Key for Kernel::CodeProps::Metadata::mNumSpilledVGPRs. +/// Key for Kernel::CodeProps::Metadata::mNumSpilledVGPRs. constexpr char NumSpilledVGPRs[] = "NumSpilledVGPRs"; } // end namespace Key -/// \brief In-memory representation of kernel code properties metadata. +/// In-memory representation of kernel code properties metadata. struct Metadata final { - /// \brief Size in bytes of the kernarg segment memory. Kernarg segment memory + /// Size in bytes of the kernarg segment memory. Kernarg segment memory /// holds the values of the arguments to the kernel. Required. uint64_t mKernargSegmentSize = 0; - /// \brief Size in bytes of the group segment memory required by a workgroup. + /// Size in bytes of the group segment memory required by a workgroup. /// This value does not include any dynamically allocated group segment memory /// that may be added when the kernel is dispatched. Required. uint32_t mGroupSegmentFixedSize = 0; - /// \brief Size in bytes of the private segment memory required by a workitem. + /// Size in bytes of the private segment memory required by a workitem. /// Private segment memory includes arg, spill and private segments. Required. uint32_t mPrivateSegmentFixedSize = 0; - /// \brief Maximum byte alignment of variables used by the kernel in the + /// Maximum byte alignment of variables used by the kernel in the /// kernarg memory segment. Required. uint32_t mKernargSegmentAlign = 0; - /// \brief Wavefront size. Required. + /// Wavefront size. Required. uint32_t mWavefrontSize = 0; - /// \brief Total number of SGPRs used by a wavefront. Optional. + /// Total number of SGPRs used by a wavefront. Optional. uint16_t mNumSGPRs = 0; - /// \brief Total number of VGPRs used by a workitem. Optional. + /// Total number of VGPRs used by a workitem. Optional. uint16_t mNumVGPRs = 0; - /// \brief Maximum flat work-group size supported by the kernel. Optional. + /// Maximum flat work-group size supported by the kernel. Optional. uint32_t mMaxFlatWorkGroupSize = 0; - /// \brief True if the generated machine code is using a dynamically sized + /// True if the generated machine code is using a dynamically sized /// call stack. Optional. bool mIsDynamicCallStack = false; - /// \brief True if the generated machine code is capable of supporting XNACK. + /// True if the generated machine code is capable of supporting XNACK. /// Optional. bool mIsXNACKEnabled = false; - /// \brief Number of SGPRs spilled by a wavefront. Optional. + /// Number of SGPRs spilled by a wavefront. Optional. uint16_t mNumSpilledSGPRs = 0; - /// \brief Number of VGPRs spilled by a workitem. Optional. + /// Number of VGPRs spilled by a workitem. Optional. uint16_t mNumSpilledVGPRs = 0; - /// \brief Default constructor. + /// Default constructor. Metadata() = default; /// \returns True if kernel code properties metadata is empty, false @@ -308,40 +308,40 @@ namespace DebugProps { namespace Key { -/// \brief Key for Kernel::DebugProps::Metadata::mDebuggerABIVersion. +/// Key for Kernel::DebugProps::Metadata::mDebuggerABIVersion. constexpr char DebuggerABIVersion[] = "DebuggerABIVersion"; -/// \brief Key for Kernel::DebugProps::Metadata::mReservedNumVGPRs. +/// Key for Kernel::DebugProps::Metadata::mReservedNumVGPRs. constexpr char ReservedNumVGPRs[] = "ReservedNumVGPRs"; -/// \brief Key for Kernel::DebugProps::Metadata::mReservedFirstVGPR. +/// Key for Kernel::DebugProps::Metadata::mReservedFirstVGPR. constexpr char ReservedFirstVGPR[] = "ReservedFirstVGPR"; -/// \brief Key for Kernel::DebugProps::Metadata::mPrivateSegmentBufferSGPR. +/// Key for Kernel::DebugProps::Metadata::mPrivateSegmentBufferSGPR. constexpr char PrivateSegmentBufferSGPR[] = "PrivateSegmentBufferSGPR"; -/// \brief Key for +/// Key for /// Kernel::DebugProps::Metadata::mWavefrontPrivateSegmentOffsetSGPR. constexpr char WavefrontPrivateSegmentOffsetSGPR[] = "WavefrontPrivateSegmentOffsetSGPR"; } // end namespace Key -/// \brief In-memory representation of kernel debug properties metadata. +/// In-memory representation of kernel debug properties metadata. struct Metadata final { - /// \brief Debugger ABI version. Optional. + /// Debugger ABI version. Optional. std::vector mDebuggerABIVersion = std::vector(); - /// \brief Consecutive number of VGPRs reserved for debugger use. Must be 0 if + /// Consecutive number of VGPRs reserved for debugger use. Must be 0 if /// mDebuggerABIVersion is not set. Optional. uint16_t mReservedNumVGPRs = 0; - /// \brief First fixed VGPR reserved. Must be uint16_t(-1) if + /// First fixed VGPR reserved. Must be uint16_t(-1) if /// mDebuggerABIVersion is not set or mReservedFirstVGPR is 0. Optional. uint16_t mReservedFirstVGPR = uint16_t(-1); - /// \brief Fixed SGPR of the first of 4 SGPRs used to hold the scratch V# used + /// Fixed SGPR of the first of 4 SGPRs used to hold the scratch V# used /// for the entire kernel execution. Must be uint16_t(-1) if /// mDebuggerABIVersion is not set or SGPR not used or not known. Optional. uint16_t mPrivateSegmentBufferSGPR = uint16_t(-1); - /// \brief Fixed SGPR used to hold the wave scratch offset for the entire + /// Fixed SGPR used to hold the wave scratch offset for the entire /// kernel execution. Must be uint16_t(-1) if mDebuggerABIVersion is not set /// or SGPR is not used or not known. Optional. uint16_t mWavefrontPrivateSegmentOffsetSGPR = uint16_t(-1); - /// \brief Default constructor. + /// Default constructor. Metadata() = default; /// \returns True if kernel debug properties metadata is empty, false @@ -360,75 +360,75 @@ } // end namespace DebugProps namespace Key { -/// \brief Key for Kernel::Metadata::mName. +/// Key for Kernel::Metadata::mName. constexpr char Name[] = "Name"; -/// \brief Key for Kernel::Metadata::mSymbolName. +/// Key for Kernel::Metadata::mSymbolName. constexpr char SymbolName[] = "SymbolName"; -/// \brief Key for Kernel::Metadata::mLanguage. +/// Key for Kernel::Metadata::mLanguage. constexpr char Language[] = "Language"; -/// \brief Key for Kernel::Metadata::mLanguageVersion. +/// Key for Kernel::Metadata::mLanguageVersion. constexpr char LanguageVersion[] = "LanguageVersion"; -/// \brief Key for Kernel::Metadata::mAttrs. +/// Key for Kernel::Metadata::mAttrs. constexpr char Attrs[] = "Attrs"; -/// \brief Key for Kernel::Metadata::mArgs. +/// Key for Kernel::Metadata::mArgs. constexpr char Args[] = "Args"; -/// \brief Key for Kernel::Metadata::mCodeProps. +/// Key for Kernel::Metadata::mCodeProps. constexpr char CodeProps[] = "CodeProps"; -/// \brief Key for Kernel::Metadata::mDebugProps. +/// Key for Kernel::Metadata::mDebugProps. constexpr char DebugProps[] = "DebugProps"; } // end namespace Key -/// \brief In-memory representation of kernel metadata. +/// In-memory representation of kernel metadata. struct Metadata final { - /// \brief Kernel source name. Required. + /// Kernel source name. Required. std::string mName = std::string(); - /// \brief Kernel descriptor name. Required. + /// Kernel descriptor name. Required. std::string mSymbolName = std::string(); - /// \brief Language. Optional. + /// Language. Optional. std::string mLanguage = std::string(); - /// \brief Language version. Optional. + /// Language version. Optional. std::vector mLanguageVersion = std::vector(); - /// \brief Attributes metadata. Optional. + /// Attributes metadata. Optional. Attrs::Metadata mAttrs = Attrs::Metadata(); - /// \brief Arguments metadata. Optional. + /// Arguments metadata. Optional. std::vector mArgs = std::vector(); - /// \brief Code properties metadata. Optional. + /// Code properties metadata. Optional. CodeProps::Metadata mCodeProps = CodeProps::Metadata(); - /// \brief Debug properties metadata. Optional. + /// Debug properties metadata. Optional. DebugProps::Metadata mDebugProps = DebugProps::Metadata(); - /// \brief Default constructor. + /// Default constructor. Metadata() = default; }; } // end namespace Kernel namespace Key { -/// \brief Key for HSA::Metadata::mVersion. +/// Key for HSA::Metadata::mVersion. constexpr char Version[] = "Version"; -/// \brief Key for HSA::Metadata::mPrintf. +/// Key for HSA::Metadata::mPrintf. constexpr char Printf[] = "Printf"; -/// \brief Key for HSA::Metadata::mKernels. +/// Key for HSA::Metadata::mKernels. constexpr char Kernels[] = "Kernels"; } // end namespace Key -/// \brief In-memory representation of HSA metadata. +/// In-memory representation of HSA metadata. struct Metadata final { - /// \brief HSA metadata version. Required. + /// HSA metadata version. Required. std::vector mVersion = std::vector(); - /// \brief Printf metadata. Optional. + /// Printf metadata. Optional. std::vector mPrintf = std::vector(); - /// \brief Kernels metadata. Required. + /// Kernels metadata. Required. std::vector mKernels = std::vector(); - /// \brief Default constructor. + /// Default constructor. Metadata() = default; }; -/// \brief Converts \p String to \p HSAMetadata. +/// Converts \p String to \p HSAMetadata. std::error_code fromString(std::string String, Metadata &HSAMetadata); -/// \brief Converts \p HSAMetadata to \p String. +/// Converts \p HSAMetadata to \p String. std::error_code toString(Metadata HSAMetadata, std::string &String); } // end namespace HSAMD @@ -438,10 +438,10 @@ //===----------------------------------------------------------------------===// namespace PALMD { -/// \brief PAL metadata assembler directive. +/// PAL metadata assembler directive. constexpr char AssemblerDirective[] = ".amd_amdgpu_pal_metadata"; -/// \brief PAL metadata keys. +/// PAL metadata keys. enum Key : uint32_t { LS_NUM_USED_VGPRS = 0x10000021, HS_NUM_USED_VGPRS = 0x10000022, @@ -468,10 +468,10 @@ CS_SCRATCH_SIZE = 0x1000004a }; -/// \brief PAL metadata represented as a vector. +/// PAL metadata represented as a vector. typedef std::vector Metadata; -/// \brief Converts \p PALMetadata to \p String. +/// Converts \p PALMetadata to \p String. std::error_code toString(const Metadata &PALMetadata, std::string &String); } // end namespace PALMD Index: llvm/trunk/include/llvm/Support/AlignOf.h =================================================================== --- llvm/trunk/include/llvm/Support/AlignOf.h +++ llvm/trunk/include/llvm/Support/AlignOf.h @@ -20,7 +20,7 @@ namespace llvm { /// \struct AlignedCharArray -/// \brief Helper for building an aligned character array type. +/// Helper for building an aligned character array type. /// /// This template is used to explicitly build up a collection of aligned /// character array types. We have to build these up using a macro and explicit @@ -39,7 +39,7 @@ #else // _MSC_VER -/// \brief Create a type with an aligned char buffer. +/// Create a type with an aligned char buffer. template struct AlignedCharArray; @@ -124,7 +124,7 @@ }; } // end namespace detail -/// \brief This union template exposes a suitably aligned and sized character +/// This union template exposes a suitably aligned and sized character /// array member which can hold elements of any of up to ten types. /// /// These types may be arrays, structs, or any other types. The goal is to Index: llvm/trunk/include/llvm/Support/Allocator.h =================================================================== --- llvm/trunk/include/llvm/Support/Allocator.h +++ llvm/trunk/include/llvm/Support/Allocator.h @@ -36,7 +36,7 @@ namespace llvm { -/// \brief CRTP base class providing obvious overloads for the core \c +/// CRTP base class providing obvious overloads for the core \c /// Allocate() methods of LLVM-style allocators. /// /// This base class both documents the full public interface exposed by all @@ -44,7 +44,7 @@ /// set of methods which the derived class must define. template class AllocatorBase { public: - /// \brief Allocate \a Size bytes of \a Alignment aligned memory. This method + /// Allocate \a Size bytes of \a Alignment aligned memory. This method /// must be implemented by \c DerivedT. void *Allocate(size_t Size, size_t Alignment) { #ifdef __clang__ @@ -58,7 +58,7 @@ return static_cast(this)->Allocate(Size, Alignment); } - /// \brief Deallocate \a Ptr to \a Size bytes of memory allocated by this + /// Deallocate \a Ptr to \a Size bytes of memory allocated by this /// allocator. void Deallocate(const void *Ptr, size_t Size) { #ifdef __clang__ @@ -75,12 +75,12 @@ // The rest of these methods are helpers that redirect to one of the above // core methods. - /// \brief Allocate space for a sequence of objects without constructing them. + /// Allocate space for a sequence of objects without constructing them. template T *Allocate(size_t Num = 1) { return static_cast(Allocate(Num * sizeof(T), alignof(T))); } - /// \brief Deallocate space for a sequence of objects without constructing them. + /// Deallocate space for a sequence of objects without constructing them. template typename std::enable_if< !std::is_same::type, void>::value, void>::type @@ -124,7 +124,7 @@ } // end namespace detail -/// \brief Allocate memory in an ever growing pool, as if by bump-pointer. +/// Allocate memory in an ever growing pool, as if by bump-pointer. /// /// This isn't strictly a bump-pointer allocator as it uses backing slabs of /// memory rather than relying on a boundless contiguous heap. However, it has @@ -192,7 +192,7 @@ return *this; } - /// \brief Deallocate all but the current slab and reset the current pointer + /// Deallocate all but the current slab and reset the current pointer /// to the beginning of it, freeing all memory allocated so far. void Reset() { // Deallocate all but the first slab, and deallocate all custom-sized slabs. @@ -212,7 +212,7 @@ Slabs.erase(std::next(Slabs.begin()), Slabs.end()); } - /// \brief Allocate space at the specified alignment. + /// Allocate space at the specified alignment. LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, size_t Alignment) { assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead."); @@ -307,30 +307,30 @@ } private: - /// \brief The current pointer into the current slab. + /// The current pointer into the current slab. /// /// This points to the next free byte in the slab. char *CurPtr = nullptr; - /// \brief The end of the current slab. + /// The end of the current slab. char *End = nullptr; - /// \brief The slabs allocated so far. + /// The slabs allocated so far. SmallVector Slabs; - /// \brief Custom-sized slabs allocated for too-large allocation requests. + /// Custom-sized slabs allocated for too-large allocation requests. SmallVector, 0> CustomSizedSlabs; - /// \brief How many bytes we've allocated. + /// How many bytes we've allocated. /// /// Used so that we can compute how much space was wasted. size_t BytesAllocated = 0; - /// \brief The number of bytes to put between allocations when running under + /// The number of bytes to put between allocations when running under /// a sanitizer. size_t RedZoneSize = 1; - /// \brief The allocator instance we use to get slabs of memory. + /// The allocator instance we use to get slabs of memory. AllocatorT Allocator; static size_t computeSlabSize(unsigned SlabIdx) { @@ -341,7 +341,7 @@ return SlabSize * ((size_t)1 << std::min(30, SlabIdx / 128)); } - /// \brief Allocate a new slab and move the bump pointers over into the new + /// Allocate a new slab and move the bump pointers over into the new /// slab, modifying CurPtr and End. void StartNewSlab() { size_t AllocatedSlabSize = computeSlabSize(Slabs.size()); @@ -356,7 +356,7 @@ End = ((char *)NewSlab) + AllocatedSlabSize; } - /// \brief Deallocate a sequence of slabs. + /// Deallocate a sequence of slabs. void DeallocateSlabs(SmallVectorImpl::iterator I, SmallVectorImpl::iterator E) { for (; I != E; ++I) { @@ -366,7 +366,7 @@ } } - /// \brief Deallocate all memory for custom sized slabs. + /// Deallocate all memory for custom sized slabs. void DeallocateCustomSizedSlabs() { for (auto &PtrAndSize : CustomSizedSlabs) { void *Ptr = PtrAndSize.first; @@ -378,11 +378,11 @@ template friend class SpecificBumpPtrAllocator; }; -/// \brief The standard BumpPtrAllocator which just uses the default template +/// The standard BumpPtrAllocator which just uses the default template /// parameters. typedef BumpPtrAllocatorImpl<> BumpPtrAllocator; -/// \brief A BumpPtrAllocator that allows only elements of a specific type to be +/// A BumpPtrAllocator that allows only elements of a specific type to be /// allocated. /// /// This allows calling the destructor in DestroyAll() and when the allocator is @@ -435,7 +435,7 @@ Allocator.Reset(); } - /// \brief Allocate space for an array of objects without constructing them. + /// Allocate space for an array of objects without constructing them. T *Allocate(size_t num = 1) { return Allocator.Allocate(num); } }; Index: llvm/trunk/include/llvm/Support/AtomicOrdering.h =================================================================== --- llvm/trunk/include/llvm/Support/AtomicOrdering.h +++ llvm/trunk/include/llvm/Support/AtomicOrdering.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief Atomic ordering constants. +/// Atomic ordering constants. /// /// These values are used by LLVM to represent atomic ordering for C++11's /// memory model and more, as detailed in docs/Atomics.rst. Index: llvm/trunk/include/llvm/Support/BinaryByteStream.h =================================================================== --- llvm/trunk/include/llvm/Support/BinaryByteStream.h +++ llvm/trunk/include/llvm/Support/BinaryByteStream.h @@ -25,7 +25,7 @@ namespace llvm { -/// \brief An implementation of BinaryStream which holds its entire data set +/// An implementation of BinaryStream which holds its entire data set /// in a single contiguous buffer. BinaryByteStream guarantees that no read /// operation will ever incur a copy. Note that BinaryByteStream does not /// own the underlying buffer. @@ -69,7 +69,7 @@ ArrayRef Data; }; -/// \brief An implementation of BinaryStream whose data is backed by an llvm +/// An implementation of BinaryStream whose data is backed by an llvm /// MemoryBuffer object. MemoryBufferByteStream owns the MemoryBuffer in /// question. As with BinaryByteStream, reading from a MemoryBufferByteStream /// will never cause a copy. @@ -83,7 +83,7 @@ std::unique_ptr MemBuffer; }; -/// \brief An implementation of BinaryStream which holds its entire data set +/// An implementation of BinaryStream which holds its entire data set /// in a single contiguous buffer. As with BinaryByteStream, the mutable /// version also guarantees that no read operation will ever incur a copy, /// and similarly it does not own the underlying buffer. @@ -131,7 +131,7 @@ BinaryByteStream ImmutableStream; }; -/// \brief An implementation of WritableBinaryStream which can write at its end +/// An implementation of WritableBinaryStream which can write at its end /// causing the underlying data to grow. This class owns the underlying data. class AppendingBinaryByteStream : public WritableBinaryStream { std::vector Data; @@ -193,7 +193,7 @@ Error commit() override { return Error::success(); } - /// \brief Return the properties of this stream. + /// Return the properties of this stream. virtual BinaryStreamFlags getFlags() const override { return BSF_Write | BSF_Append; } @@ -201,7 +201,7 @@ MutableArrayRef data() { return Data; } }; -/// \brief An implementation of WritableBinaryStream backed by an llvm +/// An implementation of WritableBinaryStream backed by an llvm /// FileOutputBuffer. class FileBufferByteStream : public WritableBinaryStream { private: Index: llvm/trunk/include/llvm/Support/BinaryStream.h =================================================================== --- llvm/trunk/include/llvm/Support/BinaryStream.h +++ llvm/trunk/include/llvm/Support/BinaryStream.h @@ -26,7 +26,7 @@ LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ BSF_Append) }; -/// \brief An interface for accessing data in a stream-like format, but which +/// An interface for accessing data in a stream-like format, but which /// discourages copying. Instead of specifying a buffer in which to copy /// data on a read, the API returns an ArrayRef to data owned by the stream's /// implementation. Since implementations may not necessarily store data in a @@ -39,21 +39,21 @@ virtual llvm::support::endianness getEndian() const = 0; - /// \brief Given an offset into the stream and a number of bytes, attempt to + /// Given an offset into the stream and a number of bytes, attempt to /// read the bytes and set the output ArrayRef to point to data owned by the /// stream. virtual Error readBytes(uint32_t Offset, uint32_t Size, ArrayRef &Buffer) = 0; - /// \brief Given an offset into the stream, read as much as possible without + /// Given an offset into the stream, read as much as possible without /// copying any data. virtual Error readLongestContiguousChunk(uint32_t Offset, ArrayRef &Buffer) = 0; - /// \brief Return the number of bytes of data in this stream. + /// Return the number of bytes of data in this stream. virtual uint32_t getLength() = 0; - /// \brief Return the properties of this stream. + /// Return the properties of this stream. virtual BinaryStreamFlags getFlags() const { return BSF_None; } protected: @@ -66,7 +66,7 @@ } }; -/// \brief A BinaryStream which can be read from as well as written to. Note +/// A BinaryStream which can be read from as well as written to. Note /// that writing to a BinaryStream always necessitates copying from the input /// buffer to the stream's backing store. Streams are assumed to be buffered /// so that to be portable it is necessary to call commit() on the stream when @@ -75,15 +75,15 @@ public: ~WritableBinaryStream() override = default; - /// \brief Attempt to write the given bytes into the stream at the desired + /// Attempt to write the given bytes into the stream at the desired /// offset. This will always necessitate a copy. Cannot shrink or grow the /// stream, only writes into existing allocated space. virtual Error writeBytes(uint32_t Offset, ArrayRef Data) = 0; - /// \brief For buffered streams, commits changes to the backing store. + /// For buffered streams, commits changes to the backing store. virtual Error commit() = 0; - /// \brief Return the properties of this stream. + /// Return the properties of this stream. BinaryStreamFlags getFlags() const override { return BSF_Write; } protected: Index: llvm/trunk/include/llvm/Support/BinaryStreamArray.h =================================================================== --- llvm/trunk/include/llvm/Support/BinaryStreamArray.h +++ llvm/trunk/include/llvm/Support/BinaryStreamArray.h @@ -111,7 +111,7 @@ bool empty() const { return Stream.getLength() == 0; } - /// \brief given an offset into the array's underlying stream, return an + /// given an offset into the array's underlying stream, return an /// iterator to the record at that offset. This is considered unsafe /// since the behavior is undefined if \p Offset does not refer to the /// beginning of a valid record. Index: llvm/trunk/include/llvm/Support/BinaryStreamReader.h =================================================================== --- llvm/trunk/include/llvm/Support/BinaryStreamReader.h +++ llvm/trunk/include/llvm/Support/BinaryStreamReader.h @@ -24,7 +24,7 @@ namespace llvm { -/// \brief Provides read only access to a subclass of `BinaryStream`. Provides +/// Provides read only access to a subclass of `BinaryStream`. Provides /// bounds checking and helpers for writing certain common data types such as /// null-terminated strings, integers in various flavors of endianness, etc. /// Can be subclassed to provide reading of custom datatypes, although no Index: llvm/trunk/include/llvm/Support/BinaryStreamRef.h =================================================================== --- llvm/trunk/include/llvm/Support/BinaryStreamRef.h +++ llvm/trunk/include/llvm/Support/BinaryStreamRef.h @@ -147,7 +147,7 @@ Optional Length; }; -/// \brief BinaryStreamRef is to BinaryStream what ArrayRef is to an Array. It +/// BinaryStreamRef is to BinaryStream what ArrayRef is to an Array. It /// provides copy-semantics and read only access to a "window" of the underlying /// BinaryStream. Note that BinaryStreamRef is *not* a BinaryStream. That is to /// say, it does not inherit and override the methods of BinaryStream. In @@ -266,7 +266,7 @@ /// Conver this WritableBinaryStreamRef to a read-only BinaryStreamRef. operator BinaryStreamRef() const; - /// \brief For buffered streams, commits changes to the backing store. + /// For buffered streams, commits changes to the backing store. Error commit(); }; Index: llvm/trunk/include/llvm/Support/BinaryStreamWriter.h =================================================================== --- llvm/trunk/include/llvm/Support/BinaryStreamWriter.h +++ llvm/trunk/include/llvm/Support/BinaryStreamWriter.h @@ -24,7 +24,7 @@ namespace llvm { -/// \brief Provides write only access to a subclass of `WritableBinaryStream`. +/// Provides write only access to a subclass of `WritableBinaryStream`. /// Provides bounds checking and helpers for writing certain common data types /// such as null-terminated strings, integers in various flavors of endianness, /// etc. Can be subclassed to provide reading and writing of custom datatypes, Index: llvm/trunk/include/llvm/Support/BlockFrequency.h =================================================================== --- llvm/trunk/include/llvm/Support/BlockFrequency.h +++ llvm/trunk/include/llvm/Support/BlockFrequency.h @@ -28,32 +28,32 @@ public: BlockFrequency(uint64_t Freq = 0) : Frequency(Freq) { } - /// \brief Returns the maximum possible frequency, the saturation value. + /// Returns the maximum possible frequency, the saturation value. static uint64_t getMaxFrequency() { return -1ULL; } - /// \brief Returns the frequency as a fixpoint number scaled by the entry + /// Returns the frequency as a fixpoint number scaled by the entry /// frequency. uint64_t getFrequency() const { return Frequency; } - /// \brief Multiplies with a branch probability. The computation will never + /// Multiplies with a branch probability. The computation will never /// overflow. BlockFrequency &operator*=(BranchProbability Prob); BlockFrequency operator*(BranchProbability Prob) const; - /// \brief Divide by a non-zero branch probability using saturating + /// Divide by a non-zero branch probability using saturating /// arithmetic. BlockFrequency &operator/=(BranchProbability Prob); BlockFrequency operator/(BranchProbability Prob) const; - /// \brief Adds another block frequency using saturating arithmetic. + /// Adds another block frequency using saturating arithmetic. BlockFrequency &operator+=(BlockFrequency Freq); BlockFrequency operator+(BlockFrequency Freq) const; - /// \brief Subtracts another block frequency using saturating arithmetic. + /// Subtracts another block frequency using saturating arithmetic. BlockFrequency &operator-=(BlockFrequency Freq); BlockFrequency operator-(BlockFrequency Freq) const; - /// \brief Shift block frequency to the right by count digits saturating to 1. + /// Shift block frequency to the right by count digits saturating to 1. BlockFrequency &operator>>=(const unsigned count); bool operator<(BlockFrequency RHS) const { Index: llvm/trunk/include/llvm/Support/BranchProbability.h =================================================================== --- llvm/trunk/include/llvm/Support/BranchProbability.h +++ llvm/trunk/include/llvm/Support/BranchProbability.h @@ -73,7 +73,7 @@ void dump() const; - /// \brief Scale a large integer. + /// Scale a large integer. /// /// Scales \c Num. Guarantees full precision. Returns the floor of the /// result. @@ -81,7 +81,7 @@ /// \return \c Num times \c this. uint64_t scale(uint64_t Num) const; - /// \brief Scale a large integer by the inverse. + /// Scale a large integer by the inverse. /// /// Scales \c Num by the inverse of \c this. Guarantees full precision. /// Returns the floor of the result. Index: llvm/trunk/include/llvm/Support/Casting.h =================================================================== --- llvm/trunk/include/llvm/Support/Casting.h +++ llvm/trunk/include/llvm/Support/Casting.h @@ -60,7 +60,7 @@ } }; -/// \brief Always allow upcasts, and perform no dynamic check for them. +/// Always allow upcasts, and perform no dynamic check for them. template struct isa_impl< To, From, typename std::enable_if::value>::type> { Index: llvm/trunk/include/llvm/Support/CommandLine.h =================================================================== --- llvm/trunk/include/llvm/Support/CommandLine.h +++ llvm/trunk/include/llvm/Support/CommandLine.h @@ -94,7 +94,7 @@ // Forward declaration - AddLiteralOption needs to be up here to make gcc happy. class Option; -/// \brief Adds a new option for parsing and provides the option it refers to. +/// Adds a new option for parsing and provides the option it refers to. /// /// \param O pointer to the option /// \param Name the string name for the option to handle during parsing @@ -1770,7 +1770,7 @@ // Public interface for accessing registered options. // -/// \brief Use this to get a StringMap to all registered named options +/// Use this to get a StringMap to all registered named options /// (e.g. -help). Note \p Map Should be an empty StringMap. /// /// \return A reference to the StringMap used by the cl APIs to parse options. @@ -1799,7 +1799,7 @@ /// than just handing around a global list. StringMap