OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 2
Code Issues Packages Projects Releases Wiki Activity

[llvm] LLVM_NODISCARD => [[nodiscard]]. NFC 

With C++17 there is no Clang pedantic warning.
This commit is contained in:
Fangrui Song 2022-08-07 00:26:33 +00:00
parent ec04e45c03
commit fa66789d06
33 changed files with 291 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
llvm/include/llvm/ADT/APInt.h
View File

@ -72,7 +72,7 @@ inline APInt operator-(APInt);
/// shifts are defined, but sign extension and ashr is not. Zero bit values
/// compare and hash equal to themselves, and countLeadingZeros returns 0.
///
class LLVM_NODISCARD APInt {
class [[nodiscard]] APInt {
public:
typedef uint64_t WordType;

2
llvm/include/llvm/ADT/APSInt.h
View File

@ -20,7 +20,7 @@
namespace llvm {
/// An arbitrary precision integer that knows its signedness.
class LLVM_NODISCARD APSInt : public APInt {
class [[nodiscard]] APSInt : public APInt {
bool IsUnsigned = false;
public:

6
llvm/include/llvm/ADT/ArrayRef.h
View File

@ -25,7 +25,7 @@
#include <vector>
namespace llvm {
template<typename T> class LLVM_NODISCARD MutableArrayRef;
template<typename T> class [[nodiscard]] MutableArrayRef;
/// ArrayRef - Represent a constant reference to an array (0 or more elements
/// consecutively in memory), i.e. a start pointer and a length. It allows
@ -39,7 +39,7 @@ namespace llvm {
/// This is intended to be trivially copyable, so it should be passed by
/// value.
template<typename T>
class LLVM_GSL_POINTER LLVM_NODISCARD ArrayRef {
class LLVM_GSL_POINTER [[nodiscard]] ArrayRef {
public:
using value_type = T;
using pointer = value_type *;
@ -303,7 +303,7 @@ namespace llvm {
/// This is intended to be trivially copyable, so it should be passed by
/// value.
template<typename T>
class LLVM_NODISCARD MutableArrayRef : public ArrayRef<T> {
class [[nodiscard]] MutableArrayRef : public ArrayRef<T> {
public:
using value_type = T;
using pointer = value_type *;

4
llvm/include/llvm/ADT/DenseMap.h
View File

@ -95,9 +95,7 @@ public:
return makeConstIterator(getBucketsEnd(), getBucketsEnd(), *this, true);
}
LLVM_NODISCARD bool empty() const {
return getNumEntries() == 0;
}
[[nodiscard]] bool empty() const { return getNumEntries() == 0; }
unsigned size() const { return getNumEntries(); }
/// Grow the densemap so that it can contain at least \p NumEntries items

10
llvm/include/llvm/ADT/ImmutableList.h
View File

@ -174,7 +174,7 @@ public:
}
template <typename ElemT>
LLVM_NODISCARD ImmutableList<T> concat(ElemT &&Head, ImmutableList<T> Tail) {
[[nodiscard]] ImmutableList<T> concat(ElemT &&Head, ImmutableList<T> Tail) {
// Profile the new list to see if it already exists in our cache.
FoldingSetNodeID ID;
void* InsertPos;
@ -197,13 +197,13 @@ public:
}
template <typename ElemT>
LLVM_NODISCARD ImmutableList<T> add(ElemT &&Data, ImmutableList<T> L) {
[[nodiscard]] ImmutableList<T> add(ElemT &&Data, ImmutableList<T> L) {
return concat(std::forward<ElemT>(Data), L);
}
template <typename ...CtorArgs>
LLVM_NODISCARD ImmutableList<T> emplace(ImmutableList<T> Tail,
CtorArgs &&...Args) {
template <typename... CtorArgs>
[[nodiscard]] ImmutableList<T> emplace(ImmutableList<T> Tail,
CtorArgs &&...Args) {
return concat(T(std::forward<CtorArgs>(Args)...), Tail);
}

6
llvm/include/llvm/ADT/ImmutableMap.h
View File

@ -95,13 +95,13 @@ public:
ImmutableMap getEmptyMap() { return ImmutableMap(F.getEmptyTree()); }
LLVM_NODISCARD ImmutableMap add(ImmutableMap Old, key_type_ref K,
data_type_ref D) {
[[nodiscard]] ImmutableMap add(ImmutableMap Old, key_type_ref K,
data_type_ref D) {
TreeTy *T = F.add(Old.Root.get(), std::pair<key_type, data_type>(K, D));
return ImmutableMap(Canonicalize ? F.getCanonicalTree(T): T);
}
LLVM_NODISCARD ImmutableMap remove(ImmutableMap Old, key_type_ref K) {
[[nodiscard]] ImmutableMap remove(ImmutableMap Old, key_type_ref K) {
TreeTy *T = F.remove(Old.Root.get(), K);
return ImmutableMap(Canonicalize ? F.getCanonicalTree(T): T);
}

4
llvm/include/llvm/ADT/ImmutableSet.h
View File

@ -996,7 +996,7 @@ public:
/// of this operation is logarithmic in the size of the original set.
/// The memory allocated to represent the set is released when the
/// factory object that created the set is destroyed.
LLVM_NODISCARD ImmutableSet add(ImmutableSet Old, value_type_ref V) {
[[nodiscard]] ImmutableSet add(ImmutableSet Old, value_type_ref V) {
TreeTy *NewT = F.add(Old.Root.get(), V);
return ImmutableSet(Canonicalize ? F.getCanonicalTree(NewT) : NewT);
}
@ -1008,7 +1008,7 @@ public:
/// of this operation is logarithmic in the size of the original set.
/// The memory allocated to represent the set is released when the
/// factory object that created the set is destroyed.
LLVM_NODISCARD ImmutableSet remove(ImmutableSet Old, value_type_ref V) {
[[nodiscard]] ImmutableSet remove(ImmutableSet Old, value_type_ref V) {
TreeTy *NewT = F.remove(Old.Root.get(), V);
return ImmutableSet(Canonicalize ? F.getCanonicalTree(NewT) : NewT);
}

2
llvm/include/llvm/ADT/PriorityWorklist.h
View File

@ -150,7 +150,7 @@ public:
} while (!V.empty() && V.back() == T());
}
LLVM_NODISCARD T pop_back_val() {
[[nodiscard]] T pop_back_val() {
T Ret = back();
pop_back();
return Ret;

2
llvm/include/llvm/ADT/ScopeExit.h
View File

@ -55,7 +55,7 @@ public:
//
// Interface is specified by p0052r2.
template <typename Callable>
LLVM_NODISCARD detail::scope_exit<typename std::decay<Callable>::type>
[[nodiscard]] detail::scope_exit<typename std::decay<Callable>::type>
make_scope_exit(Callable &&F) {
return detail::scope_exit<typename std::decay<Callable>::type>(
std::forward<Callable>(F));

2
llvm/include/llvm/ADT/SetVector.h
View File

@ -229,7 +229,7 @@ public:
vector_.pop_back();
}
LLVM_NODISCARD T pop_back_val() {
[[nodiscard]] T pop_back_val() {
T Ret = back();
pop_back();
return Ret;

2
llvm/include/llvm/ADT/SmallPtrSet.h
View File

@ -89,7 +89,7 @@ public:
SmallPtrSetImplBase &operator=(const SmallPtrSetImplBase &) = delete;
LLVM_NODISCARD bool empty() const { return size() == 0; }
[[nodiscard]] bool empty() const { return size() == 0; }
size_type size() const { return NumNonEmpty - NumTombstones; }
void clear() {

4
llvm/include/llvm/ADT/SmallSet.h
View File

@ -154,9 +154,7 @@ public:
SmallSet() = default;
LLVM_NODISCARD bool empty() const {
return Vector.empty() && Set.empty();
}
[[nodiscard]] bool empty() const { return Vector.empty() && Set.empty(); }
size_type size() const {
return isSmall() ? Vector.size() : Set.size();

4
llvm/include/llvm/ADT/SmallVector.h
View File

@ -77,7 +77,7 @@ public:
size_t size() const { return Size; }
size_t capacity() const { return Capacity; }
LLVM_NODISCARD bool empty() const { return !Size; }
[[nodiscard]] bool empty() const { return !Size; }
protected:
/// Set the array size to \p N, which the current array must have enough
@ -658,7 +658,7 @@ public:
truncate(this->size() - NumItems);
}
LLVM_NODISCARD T pop_back_val() {
[[nodiscard]] T pop_back_val() {
T Result = ::std::move(this->back());
this->pop_back();
return Result;

210
llvm/include/llvm/ADT/StringRef.h
View File

@ -145,34 +145,29 @@ namespace llvm {
/// data - Get a pointer to the start of the string (which may not be null
/// terminated).
LLVM_NODISCARD
const char *data() const { return Data; }
[[nodiscard]] const char *data() const { return Data; }
/// empty - Check if the string is empty.
LLVM_NODISCARD
constexpr bool empty() const { return Length == 0; }
[[nodiscard]] constexpr bool empty() const { return Length == 0; }
/// size - Get the string size.
LLVM_NODISCARD
constexpr size_t size() const { return Length; }
[[nodiscard]] constexpr size_t size() const { return Length; }
/// front - Get the first character in the string.
LLVM_NODISCARD
char front() const {
[[nodiscard]] char front() const {
assert(!empty());
return Data[0];
}
/// back - Get the last character in the string.
LLVM_NODISCARD
char back() const {
[[nodiscard]] char back() const {
assert(!empty());
return Data[Length-1];
}
// copy - Allocate copy in Allocator and return StringRef to it.
template <typename Allocator>
LLVM_NODISCARD StringRef copy(Allocator &A) const {
[[nodiscard]] StringRef copy(Allocator &A) const {
// Don't request a length 0 copy from the allocator.
if (empty())
return StringRef();
@ -183,22 +178,19 @@ namespace llvm {
/// equals - Check for string equality, this is more efficient than
/// compare() when the relative ordering of inequal strings isn't needed.
LLVM_NODISCARD
bool equals(StringRef RHS) const {
[[nodiscard]] bool equals(StringRef RHS) const {
return (Length == RHS.Length &&
compareMemory(Data, RHS.Data, RHS.Length) == 0);
}
/// Check for string equality, ignoring case.
LLVM_NODISCARD
bool equals_insensitive(StringRef RHS) const {
[[nodiscard]] bool equals_insensitive(StringRef RHS) const {
return Length == RHS.Length && compare_insensitive(RHS) == 0;
}
/// compare - Compare two strings; the result is -1, 0, or 1 if this string
/// is lexicographically less than, equal to, or greater than the \p RHS.
LLVM_NODISCARD
int compare(StringRef RHS) const {
[[nodiscard]] int compare(StringRef RHS) const {
// Check the prefix for a mismatch.
if (int Res = compareMemory(Data, RHS.Data, std::min(Length, RHS.Length)))
return Res < 0 ? -1 : 1;
@ -210,13 +202,11 @@ namespace llvm {
}
/// Compare two strings, ignoring case.
LLVM_NODISCARD
int compare_insensitive(StringRef RHS) const;
[[nodiscard]] int compare_insensitive(StringRef RHS) const;
/// compare_numeric - Compare two strings, treating sequences of digits as
/// numbers.
LLVM_NODISCARD
int compare_numeric(StringRef RHS) const;
[[nodiscard]] int compare_numeric(StringRef RHS) const;
/// Determine the edit distance between this string and another
/// string.
@ -236,17 +226,16 @@ namespace llvm {
/// or (if \p AllowReplacements is \c true) replacements needed to
/// transform one of the given strings into the other. If zero,
/// the strings are identical.
LLVM_NODISCARD
unsigned edit_distance(StringRef Other, bool AllowReplacements = true,
unsigned MaxEditDistance = 0) const;
[[nodiscard]] unsigned edit_distance(StringRef Other,
bool AllowReplacements = true,
unsigned MaxEditDistance = 0) const;
LLVM_NODISCARD unsigned
[[nodiscard]] unsigned
edit_distance_insensitive(StringRef Other, bool AllowReplacements = true,
unsigned MaxEditDistance = 0) const;
/// str - Get the contents as an std::string.
LLVM_NODISCARD
std::string str() const {
[[nodiscard]] std::string str() const {
if (!Data) return std::string();
return std::string(Data, Length);
}
@ -255,8 +244,7 @@ namespace llvm {
/// @name Operator Overloads
/// @{
LLVM_NODISCARD
char operator[](size_t Index) const {
[[nodiscard]] char operator[](size_t Index) const {
assert(Index < Length && "Invalid index!");
return Data[Index];
}
@ -286,26 +274,22 @@ namespace llvm {
/// @{
/// Check if this string starts with the given \p Prefix.
LLVM_NODISCARD
bool startswith(StringRef Prefix) const {
[[nodiscard]] bool startswith(StringRef Prefix) const {
return Length >= Prefix.Length &&
compareMemory(Data, Prefix.Data, Prefix.Length) == 0;
}
/// Check if this string starts with the given \p Prefix, ignoring case.
LLVM_NODISCARD
bool startswith_insensitive(StringRef Prefix) const;
[[nodiscard]] bool startswith_insensitive(StringRef Prefix) const;
/// Check if this string ends with the given \p Suffix.
LLVM_NODISCARD
bool endswith(StringRef Suffix) const {
[[nodiscard]] bool endswith(StringRef Suffix) const {
return Length >= Suffix.Length &&
compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
}
/// Check if this string ends with the given \p Suffix, ignoring case.
LLVM_NODISCARD
bool endswith_insensitive(StringRef Suffix) const;
[[nodiscard]] bool endswith_insensitive(StringRef Suffix) const;
/// @}
/// @name String Searching
@ -315,8 +299,7 @@ namespace llvm {
///
/// \returns The index of the first occurrence of \p C, or npos if not
/// found.
LLVM_NODISCARD
size_t find(char C, size_t From = 0) const {
[[nodiscard]] size_t find(char C, size_t From = 0) const {
size_t FindBegin = std::min(From, Length);
if (FindBegin < Length) { // Avoid calling memchr with nullptr.
// Just forward to memchr, which is faster than a hand-rolled loop.
@ -330,15 +313,14 @@ namespace llvm {
///
/// \returns The index of the first occurrence of \p C, or npos if not
/// found.
LLVM_NODISCARD
size_t find_insensitive(char C, size_t From = 0) const;
[[nodiscard]] size_t find_insensitive(char C, size_t From = 0) const;
/// Search for the first character satisfying the predicate \p F
///
/// \returns The index of the first character satisfying \p F starting from
/// \p From, or npos if not found.
LLVM_NODISCARD
size_t find_if(function_ref<bool(char)> F, size_t From = 0) const {
[[nodiscard]] size_t find_if(function_ref<bool(char)> F,
size_t From = 0) const {
StringRef S = drop_front(From);
while (!S.empty()) {
if (F(S.front()))
@ -352,8 +334,8 @@ namespace llvm {
///
/// \returns The index of the first character not satisfying \p F starting
/// from \p From, or npos if not found.
LLVM_NODISCARD
size_t find_if_not(function_ref<bool(char)> F, size_t From = 0) const {
[[nodiscard]] size_t find_if_not(function_ref<bool(char)> F,
size_t From = 0) const {
return find_if([F](char c) { return !F(c); }, From);
}
@ -361,22 +343,19 @@ namespace llvm {
///
/// \returns The index of the first occurrence of \p Str, or npos if not
/// found.
LLVM_NODISCARD
size_t find(StringRef Str, size_t From = 0) const;
[[nodiscard]] size_t find(StringRef Str, size_t From = 0) const;
/// Search for the first string \p Str in the string, ignoring case.
///
/// \returns The index of the first occurrence of \p Str, or npos if not
/// found.
LLVM_NODISCARD
size_t find_insensitive(StringRef Str, size_t From = 0) const;
[[nodiscard]] size_t find_insensitive(StringRef Str, size_t From = 0) const;
/// Search for the last character \p C in the string.
///
/// \returns The index of the last occurrence of \p C, or npos if not
/// found.
LLVM_NODISCARD
size_t rfind(char C, size_t From = npos) const {
[[nodiscard]] size_t rfind(char C, size_t From = npos) const {
From = std::min(From, Length);
size_t i = From;
while (i != 0) {
@ -391,27 +370,23 @@ namespace llvm {
///
/// \returns The index of the last occurrence of \p C, or npos if not
/// found.
LLVM_NODISCARD
size_t rfind_insensitive(char C, size_t From = npos) const;
[[nodiscard]] size_t rfind_insensitive(char C, size_t From = npos) const;
/// Search for the last string \p Str in the string.
///
/// \returns The index of the last occurrence of \p Str, or npos if not
/// found.
LLVM_NODISCARD
size_t rfind(StringRef Str) const;
[[nodiscard]] size_t rfind(StringRef Str) const;
/// Search for the last string \p Str in the string, ignoring case.
///
/// \returns The index of the last occurrence of \p Str, or npos if not
/// found.
LLVM_NODISCARD
size_t rfind_insensitive(StringRef Str) const;
[[nodiscard]] size_t rfind_insensitive(StringRef Str) const;
/// Find the first character in the string that is \p C, or npos if not
/// found. Same as find.
LLVM_NODISCARD
size_t find_first_of(char C, size_t From = 0) const {
[[nodiscard]] size_t find_first_of(char C, size_t From = 0) const {
return find(C, From);
}
@ -419,25 +394,22 @@ namespace llvm {
/// not found.
///
/// Complexity: O(size() + Chars.size())
LLVM_NODISCARD
size_t find_first_of(StringRef Chars, size_t From = 0) const;
[[nodiscard]] size_t find_first_of(StringRef Chars, size_t From = 0) const;
/// Find the first character in the string that is not \p C or npos if not
/// found.
LLVM_NODISCARD
size_t find_first_not_of(char C, size_t From = 0) const;
[[nodiscard]] size_t find_first_not_of(char C, size_t From = 0) const;
/// Find the first character in the string that is not in the string
/// \p Chars, or npos if not found.
///
/// Complexity: O(size() + Chars.size())
LLVM_NODISCARD
size_t find_first_not_of(StringRef Chars, size_t From = 0) const;
[[nodiscard]] size_t find_first_not_of(StringRef Chars,
size_t From = 0) const;
/// Find the last character in the string that is \p C, or npos if not
/// found.
LLVM_NODISCARD
size_t find_last_of(char C, size_t From = npos) const {
[[nodiscard]] size_t find_last_of(char C, size_t From = npos) const {
return rfind(C, From);
}
@ -445,42 +417,41 @@ namespace llvm {
/// found.
///
/// Complexity: O(size() + Chars.size())
LLVM_NODISCARD
size_t find_last_of(StringRef Chars, size_t From = npos) const;
[[nodiscard]] size_t find_last_of(StringRef Chars,
size_t From = npos) const;
/// Find the last character in the string that is not \p C, or npos if not
/// found.
LLVM_NODISCARD
size_t find_last_not_of(char C, size_t From = npos) const;
[[nodiscard]] size_t find_last_not_of(char C, size_t From = npos) const;
/// Find the last character in the string that is not in \p Chars, or
/// npos if not found.
///
/// Complexity: O(size() + Chars.size())
LLVM_NODISCARD
size_t find_last_not_of(StringRef Chars, size_t From = npos) const;
[[nodiscard]] size_t find_last_not_of(StringRef Chars,
size_t From = npos) const;
/// Return true if the given string is a substring of *this, and false
/// otherwise.
LLVM_NODISCARD
bool contains(StringRef Other) const { return find(Other) != npos; }
[[nodiscard]] bool contains(StringRef Other) const {
return find(Other) != npos;
}
/// Return true if the given character is contained in *this, and false
/// otherwise.
LLVM_NODISCARD
bool contains(char C) const { return find_first_of(C) != npos; }
[[nodiscard]] bool contains(char C) const {
return find_first_of(C) != npos;
}
/// Return true if the given string is a substring of *this, and false
/// otherwise.
LLVM_NODISCARD
bool contains_insensitive(StringRef Other) const {
[[nodiscard]] bool contains_insensitive(StringRef Other) const {
return find_insensitive(Other) != npos;
}
/// Return true if the given character is contained in *this, and false
/// otherwise.
LLVM_NODISCARD
bool contains_insensitive(char C) const {
[[nodiscard]] bool contains_insensitive(char C) const {
return find_insensitive(C) != npos;
}
@ -489,8 +460,7 @@ namespace llvm {
/// @{
/// Return the number of occurrences of \p C in the string.
LLVM_NODISCARD
size_t count(char C) const {
[[nodiscard]] size_t count(char C) const {
size_t Count = 0;
for (size_t i = 0, e = Length; i != e; ++i)
if (Data[i] == C)
@ -591,12 +561,10 @@ namespace llvm {
/// @{
// Convert the given ASCII string to lowercase.
LLVM_NODISCARD
std::string lower() const;
[[nodiscard]] std::string lower() const;
/// Convert the given ASCII string to uppercase.
LLVM_NODISCARD
std::string upper() const;
[[nodiscard]] std::string upper() const;
/// @}
/// @name Substring Operations
@ -611,8 +579,7 @@ namespace llvm {
/// \param N The number of characters to included in the substring. If N
/// exceeds the number of characters remaining in the string, the string
/// suffix (starting with \p Start) will be returned.
LLVM_NODISCARD
StringRef substr(size_t Start, size_t N = npos) const {
[[nodiscard]] StringRef substr(size_t Start, size_t N = npos) const {
Start = std::min(Start, Length);
return StringRef(Data + Start, std::min(N, Length - Start));
}
@ -620,8 +587,7 @@ namespace llvm {
/// Return a StringRef equal to 'this' but with only the first \p N
/// elements remaining. If \p N is greater than the length of the
/// string, the entire string is returned.
LLVM_NODISCARD
StringRef take_front(size_t N = 1) const {
[[nodiscard]] StringRef take_front(size_t N = 1) const {
if (N >= size())
return *this;
return drop_back(size() - N);
@ -630,8 +596,7 @@ namespace llvm {
/// Return a StringRef equal to 'this' but with only the last \p N
/// elements remaining. If \p N is greater than the length of the
/// string, the entire string is returned.
LLVM_NODISCARD
StringRef take_back(size_t N = 1) const {
[[nodiscard]] StringRef take_back(size_t N = 1) const {
if (N >= size())
return *this;
return drop_front(size() - N);
@ -639,45 +604,39 @@ namespace llvm {
/// Return the longest prefix of 'this' such that every character
/// in the prefix satisfies the given predicate.
LLVM_NODISCARD
StringRef take_while(function_ref<bool(char)> F) const {
[[nodiscard]] StringRef take_while(function_ref<bool(char)> F) const {
return substr(0, find_if_not(F));
}
/// Return the longest prefix of 'this' such that no character in
/// the prefix satisfies the given predicate.
LLVM_NODISCARD
StringRef take_until(function_ref<bool(char)> F) const {
[[nodiscard]] StringRef take_until(function_ref<bool(char)> F) const {
return substr(0, find_if(F));
}
/// Return a StringRef equal to 'this' but with the first \p N elements
/// dropped.
LLVM_NODISCARD
StringRef drop_front(size_t N = 1) const {
[[nodiscard]] StringRef drop_front(size_t N = 1) const {
assert(size() >= N && "Dropping more elements than exist");
return substr(N);
}
/// Return a StringRef equal to 'this' but with the last \p N elements
/// dropped.
LLVM_NODISCARD
StringRef drop_back(size_t N = 1) const {
[[nodiscard]] StringRef drop_back(size_t N = 1) const {
assert(size() >= N && "Dropping more elements than exist");
return substr(0, size()-N);
}
/// Return a StringRef equal to 'this', but with all characters satisfying
/// the given predicate dropped from the beginning of the string.
LLVM_NODISCARD
StringRef drop_while(function_ref<bool(char)> F) const {
[[nodiscard]] StringRef drop_while(function_ref<bool(char)> F) const {
return substr(find_if_not(F));
}
/// Return a StringRef equal to 'this', but with all characters not
/// satisfying the given predicate dropped from the beginning of the string.
LLVM_NODISCARD
StringRef drop_until(function_ref<bool(char)> F) const {
[[nodiscard]] StringRef drop_until(function_ref<bool(char)> F) const {
return substr(find_if(F));
}
@ -732,8 +691,7 @@ namespace llvm {
/// remaining in the string, the string suffix (starting with \p Start)
/// will be returned. If this is less than \p Start, an empty string will
/// be returned.
LLVM_NODISCARD
StringRef slice(size_t Start, size_t End) const {
[[nodiscard]] StringRef slice(size_t Start, size_t End) const {
Start = std::min(Start, Length);
End = std::min(std::max(Start, End), Length);
return StringRef(Data + Start, End - Start);
@ -749,8 +707,7 @@ namespace llvm {
///
/// \param Separator The character to split on.
/// \returns The split substrings.
LLVM_NODISCARD
std::pair<StringRef, StringRef> split(char Separator) const {
[[nodiscard]] std::pair<StringRef, StringRef> split(char Separator) const {
return split(StringRef(&Separator, 1));
}
@ -764,8 +721,8 @@ namespace llvm {
///
/// \param Separator - The string to split on.
/// \return - The split substrings.
LLVM_NODISCARD
std::pair<StringRef, StringRef> split(StringRef Separator) const {
[[nodiscard]] std::pair<StringRef, StringRef>
split(StringRef Separator) const {
size_t Idx = find(Separator);
if (Idx == npos)
return std::make_pair(*this, StringRef());
@ -782,8 +739,8 @@ namespace llvm {
///
/// \param Separator - The string to split on.
/// \return - The split substrings.
LLVM_NODISCARD
std::pair<StringRef, StringRef> rsplit(StringRef Separator) const {
[[nodiscard]] std::pair<StringRef, StringRef>
rsplit(StringRef Separator) const {
size_t Idx = rfind(Separator);
if (Idx == npos)
return std::make_pair(*this, StringRef());
@ -835,50 +792,43 @@ namespace llvm {
///
/// \param Separator - The character to split on.
/// \return - The split substrings.
LLVM_NODISCARD
std::pair<StringRef, StringRef> rsplit(char Separator) const {
[[nodiscard]] std::pair<StringRef, StringRef> rsplit(char Separator) const {
return rsplit(StringRef(&Separator, 1));
}
/// Return string with consecutive \p Char characters starting from the
/// the left removed.
LLVM_NODISCARD
StringRef ltrim(char Char) const {
[[nodiscard]] StringRef ltrim(char Char) const {
return drop_front(std::min(Length, find_first_not_of(Char)));
}
/// Return string with consecutive characters in \p Chars starting from
/// the left removed.
LLVM_NODISCARD
StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const {
[[nodiscard]] StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const {
return drop_front(std::min(Length, find_first_not_of(Chars)));
}
/// Return string with consecutive \p Char characters starting from the
/// right removed.
LLVM_NODISCARD
StringRef rtrim(char Char) const {
[[nodiscard]] StringRef rtrim(char Char) const {
return drop_back(Length - std::min(Length, find_last_not_of(Char) + 1));
}
/// Return string with consecutive characters in \p Chars starting from
/// the right removed.
LLVM_NODISCARD
StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const {
[[nodiscard]] StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const {
return drop_back(Length - std::min(Length, find_last_not_of(Chars) + 1));
}
/// Return string with consecutive \p Char characters starting from the
/// left and right removed.
LLVM_NODISCARD
StringRef trim(char Char) const {
[[nodiscard]] StringRef trim(char Char) const {
return ltrim(Char).rtrim(Char);
}
/// Return string with consecutive characters in \p Chars starting from
/// the left and right removed.
LLVM_NODISCARD
StringRef trim(StringRef Chars = " \t\n\v\f\r") const {
[[nodiscard]] StringRef trim(StringRef Chars = " \t\n\v\f\r") const {
return ltrim(Chars).rtrim(Chars);
}
@ -888,8 +838,7 @@ namespace llvm {
/// sequence that is detected. Otherwise return '\n' for unix line endings.
///
/// \return - The line ending character sequence.
LLVM_NODISCARD
StringRef detectEOL() const {
[[nodiscard]] StringRef detectEOL() const {
size_t Pos = find('\r');
if (Pos == npos) {
// If there is no carriage return, assume unix
@ -968,8 +917,7 @@ namespace llvm {
/// @}
/// Compute a hash_code for a StringRef.
LLVM_NODISCARD
hash_code hash_value(StringRef S);
[[nodiscard]] hash_code hash_value(StringRef S);
// Provide DenseMapInfo for StringRefs.
template <> struct DenseMapInfo<StringRef, void> {

6
llvm/include/llvm/ADT/StringSwitch.h
View File

@ -179,15 +179,13 @@ public:
return CaseLower(S0, Value).CasesLower(S1, S2, S3, S4, Value);
}
LLVM_NODISCARD
R Default(T Value) {
[[nodiscard]] R Default(T Value) {
if (Result)
return std::move(*Result);
return Value;
}
LLVM_NODISCARD
operator R() {
[[nodiscard]] operator R() {
assert(Result && "Fell off the end of a string-switch");
return std::move(*Result);
}

7
llvm/include/llvm/ADT/TypeSwitch.h
View File

@ -125,20 +125,19 @@ public:
/// As a default, invoke the given callable within the root value.
template <typename CallableT>
LLVM_NODISCARD ResultT Default(CallableT &&defaultFn) {
[[nodiscard]] ResultT Default(CallableT &&defaultFn) {
if (result)
return std::move(*result);
return defaultFn(this->value);
}
/// As a default, return the given value.
LLVM_NODISCARD ResultT Default(ResultT defaultResult) {
[[nodiscard]] ResultT Default(ResultT defaultResult) {
if (result)
return std::move(*result);
return defaultResult;
}
LLVM_NODISCARD
operator ResultT() {
[[nodiscard]] operator ResultT() {
assert(result && "Fell off the end of a type-switch");
return std::move(*result);
}

6
llvm/include/llvm/ADT/simple_ilist.h
View File

@ -128,12 +128,10 @@ public:
}
/// Check if the list is empty in constant time.
LLVM_NODISCARD bool empty() const { return Sentinel.empty(); }
[[nodiscard]] bool empty() const { return Sentinel.empty(); }
/// Calculate the size of the list in linear time.
LLVM_NODISCARD size_type size() const {
return std::distance(begin(), end());
}
[[nodiscard]] size_type size() const { return std::distance(begin(), end()); }
reference front() { return *begin(); }
const_reference front() const { return *begin(); }

38
llvm/include/llvm/Analysis/AliasAnalysis.h
View File

@ -155,46 +155,44 @@ enum class ModRefInfo : uint8_t {
LLVM_MARK_AS_BITMASK_ENUM(ModRef),
};
LLVM_NODISCARD inline bool isNoModRef(const ModRefInfo MRI) {
[[nodiscard]] inline bool isNoModRef(const ModRefInfo MRI) {
return MRI == ModRefInfo::NoModRef;
}
LLVM_NODISCARD inline bool isModOrRefSet(const ModRefInfo MRI) {
[[nodiscard]] inline bool isModOrRefSet(const ModRefInfo MRI) {
return MRI != ModRefInfo::NoModRef;
}
LLVM_NODISCARD inline bool isModAndRefSet(const ModRefInfo MRI) {
[[nodiscard]] inline bool isModAndRefSet(const ModRefInfo MRI) {
return MRI == ModRefInfo::ModRef;
}
LLVM_NODISCARD inline bool isModSet(const ModRefInfo MRI) {
[[nodiscard]] inline bool isModSet(const ModRefInfo MRI) {
return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod);
}
LLVM_NODISCARD inline bool isRefSet(const ModRefInfo MRI) {
[[nodiscard]] inline bool isRefSet(const ModRefInfo MRI) {
return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref);
}
[[deprecated("Use operator | instead")]]
LLVM_NODISCARD inline ModRefInfo setMod(const ModRefInfo MRI) {
[[deprecated("Use operator | instead")]] [[nodiscard]] inline ModRefInfo
setMod(const ModRefInfo MRI) {
return MRI | ModRefInfo::Mod;
}
[[deprecated("Use operator | instead")]]
LLVM_NODISCARD inline ModRefInfo setRef(const ModRefInfo MRI) {
[[deprecated("Use operator | instead")]] [[nodiscard]] inline ModRefInfo
setRef(const ModRefInfo MRI) {
return MRI | ModRefInfo::Ref;
}
[[deprecated("Use operator & instead")]]
LLVM_NODISCARD inline ModRefInfo clearMod(const ModRefInfo MRI) {
[[deprecated("Use operator & instead")]] [[nodiscard]] inline ModRefInfo
clearMod(const ModRefInfo MRI) {
return MRI & ModRefInfo::Ref;
}
[[deprecated("Use operator & instead")]]
LLVM_NODISCARD inline ModRefInfo clearRef(const ModRefInfo MRI) {
[[deprecated("Use operator & instead")]] [[nodiscard]] inline ModRefInfo
clearRef(const ModRefInfo MRI) {
return MRI & ModRefInfo::Mod;
}
[[deprecated("Use operator | instead")]]
LLVM_NODISCARD inline ModRefInfo unionModRef(const ModRefInfo MRI1,
const ModRefInfo MRI2) {
[[deprecated("Use operator | instead")]] [[nodiscard]] inline ModRefInfo
unionModRef(const ModRefInfo MRI1, const ModRefInfo MRI2) {
return MRI1 | MRI2;
}
[[deprecated("Use operator & instead")]]
LLVM_NODISCARD inline ModRefInfo intersectModRef(const ModRefInfo MRI1,
const ModRefInfo MRI2) {
[[deprecated("Use operator & instead")]] [[nodiscard]] inline ModRefInfo
intersectModRef(const ModRefInfo MRI1, const ModRefInfo MRI2) {
return MRI1 & MRI2;
}
@ -333,7 +331,7 @@ enum FunctionModRefBehavior {
// to obtain a valid ModRefInfo. The benefit of using the wrapper is that if
// ModRefInfo enum changes, the wrapper can be updated to & with the new enum
// entry with all bits set to 1.
LLVM_NODISCARD inline ModRefInfo
[[nodiscard]] inline ModRefInfo
createModRefInfo(const FunctionModRefBehavior FMRB) {
return ModRefInfo(FMRB & static_cast<int>(ModRefInfo::ModRef));
}

22
llvm/include/llvm/Analysis/ScalarEvolution.h
View File

@ -348,7 +348,7 @@ public:
};
/// Convenient IncrementWrapFlags manipulation methods.
LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
[[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
clearFlags(SCEVWrapPredicate::IncrementWrapFlags Flags,
SCEVWrapPredicate::IncrementWrapFlags OffFlags) {
assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
@ -357,7 +357,7 @@ public:
return (SCEVWrapPredicate::IncrementWrapFlags)(Flags & ~OffFlags);
}
LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
[[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
maskFlags(SCEVWrapPredicate::IncrementWrapFlags Flags, int Mask) {
assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
assert((Mask & IncrementNoWrapMask) == Mask && "Invalid mask value!");
@ -365,7 +365,7 @@ public:
return (SCEVWrapPredicate::IncrementWrapFlags)(Flags & Mask);
}
LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
[[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
setFlags(SCEVWrapPredicate::IncrementWrapFlags Flags,
SCEVWrapPredicate::IncrementWrapFlags OnFlags) {
assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
@ -377,7 +377,7 @@ public:
/// Returns the set of SCEVWrapPredicate no wrap flags implied by a
/// SCEVAddRecExpr.
LLVM_NODISCARD static SCEVWrapPredicate::IncrementWrapFlags
[[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
getImpliedFlags(const SCEVAddRecExpr *AR, ScalarEvolution &SE);
private:
@ -466,20 +466,20 @@ public:
/// Convenient NoWrapFlags manipulation that hides enum casts and is
/// visible in the ScalarEvolution name space.
LLVM_NODISCARD static SCEV::NoWrapFlags maskFlags(SCEV::NoWrapFlags Flags,
int Mask) {
[[nodiscard]] static SCEV::NoWrapFlags maskFlags(SCEV::NoWrapFlags Flags,
int Mask) {
return (SCEV::NoWrapFlags)(Flags & Mask);
}
LLVM_NODISCARD static SCEV::NoWrapFlags setFlags(SCEV::NoWrapFlags Flags,
SCEV::NoWrapFlags OnFlags) {
[[nodiscard]] static SCEV::NoWrapFlags setFlags(SCEV::NoWrapFlags Flags,
SCEV::NoWrapFlags OnFlags) {
return (SCEV::NoWrapFlags)(Flags | OnFlags);
}
LLVM_NODISCARD static SCEV::NoWrapFlags
[[nodiscard]] static SCEV::NoWrapFlags
clearFlags(SCEV::NoWrapFlags Flags, SCEV::NoWrapFlags OffFlags) {
return (SCEV::NoWrapFlags)(Flags & ~OffFlags);
}
LLVM_NODISCARD static bool hasFlags(SCEV::NoWrapFlags Flags,
SCEV::NoWrapFlags TestFlags) {
[[nodiscard]] static bool hasFlags(SCEV::NoWrapFlags Flags,
SCEV::NoWrapFlags TestFlags) {
return TestFlags == maskFlags(Flags, TestFlags);
};

2
llvm/include/llvm/CodeGen/MachineFunction.h
View File

@ -1055,7 +1055,7 @@ public:
return FrameInstructions;
}
LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst);
[[nodiscard]] unsigned addFrameInst(const MCCFIInstruction &Inst);
/// Returns a reference to a list of symbols immediately following calls to
/// _setjmp in the function. Used to construct the longjmp target table used

2
llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h
View File

@ -37,7 +37,7 @@ private:
public:
// RAII based lock for ThreadSafeContext.
class LLVM_NODISCARD Lock {
class [[nodiscard]] Lock {
public:
Lock(std::shared_ptr<State> S) : S(std::move(S)), L(this->S->Mutex) {}

170
llvm/include/llvm/IR/Attributes.h
View File

@ -315,32 +315,32 @@ public:
/// Add an argument attribute. Returns a new set because attribute sets are
/// immutable.
LLVM_NODISCARD AttributeSet addAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const;
[[nodiscard]] AttributeSet addAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const;
/// Add a target-dependent attribute. Returns a new set because attribute sets
/// are immutable.
LLVM_NODISCARD AttributeSet addAttribute(LLVMContext &C, StringRef Kind,
StringRef Value = StringRef()) const;
[[nodiscard]] AttributeSet addAttribute(LLVMContext &C, StringRef Kind,
StringRef Value = StringRef()) const;
/// Add attributes to the attribute set. Returns a new set because attribute
/// sets are immutable.
LLVM_NODISCARD AttributeSet addAttributes(LLVMContext &C,
AttributeSet AS) const;
[[nodiscard]] AttributeSet addAttributes(LLVMContext &C,
AttributeSet AS) const;
/// Remove the specified attribute from this set. Returns a new set because
/// attribute sets are immutable.
LLVM_NODISCARD AttributeSet removeAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const;
[[nodiscard]] AttributeSet removeAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const;
/// Remove the specified attribute from this set. Returns a new set because
/// attribute sets are immutable.
LLVM_NODISCARD AttributeSet removeAttribute(LLVMContext &C,
StringRef Kind) const;
[[nodiscard]] AttributeSet removeAttribute(LLVMContext &C,
StringRef Kind) const;
/// Remove the specified attributes from this set. Returns a new set because
/// attribute sets are immutable.
LLVM_NODISCARD AttributeSet
[[nodiscard]] AttributeSet
removeAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const;
/// Return the number of attributes in this set.
@ -486,86 +486,88 @@ public:
// TODO: remove non-AtIndex versions of these methods.
/// Add an attribute to the attribute set at the given index.
/// Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList addAttributeAtIndex(
LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const;
[[nodiscard]] AttributeList
addAttributeAtIndex(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const;
/// Add an attribute to the attribute set at the given index.
/// Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList
[[nodiscard]] AttributeList
addAttributeAtIndex(LLVMContext &C, unsigned Index, StringRef Kind,
StringRef Value = StringRef()) const;
/// Add an attribute to the attribute set at the given index.
/// Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList addAttributeAtIndex(LLVMContext &C,
unsigned Index,
Attribute A) const;
[[nodiscard]] AttributeList
addAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute A) const;
/// Add attributes to the attribute set at the given index.
/// Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList addAttributesAtIndex(LLVMContext &C,
unsigned Index,
const AttrBuilder &B) const;
[[nodiscard]] AttributeList addAttributesAtIndex(LLVMContext &C,
unsigned Index,
const AttrBuilder &B) const;
/// Add a function attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addFnAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const {
[[nodiscard]] AttributeList addFnAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const {
return addAttributeAtIndex(C, FunctionIndex, Kind);
}
/// Add a function attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addFnAttribute(LLVMContext &C,
Attribute Attr) const {
[[nodiscard]] AttributeList addFnAttribute(LLVMContext &C,
Attribute Attr) const {
return addAttributeAtIndex(C, FunctionIndex, Attr);
}
/// Add a function attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addFnAttribute(
LLVMContext &C, StringRef Kind, StringRef Value = StringRef()) const {
[[nodiscard]] AttributeList
addFnAttribute(LLVMContext &C, StringRef Kind,
StringRef Value = StringRef()) const {
return addAttributeAtIndex(C, FunctionIndex, Kind, Value);
}
/// Add function attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addFnAttributes(LLVMContext &C,
const AttrBuilder &B) const {
[[nodiscard]] AttributeList addFnAttributes(LLVMContext &C,
const AttrBuilder &B) const {
return addAttributesAtIndex(C, FunctionIndex, B);
}
/// Add a return value attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addRetAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const {
[[nodiscard]] AttributeList addRetAttribute(LLVMContext &C,
Attribute::AttrKind Kind) const {
return addAttributeAtIndex(C, ReturnIndex, Kind);
}
/// Add a return value attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addRetAttribute(LLVMContext &C,
Attribute Attr) const {
[[nodiscard]] AttributeList addRetAttribute(LLVMContext &C,
Attribute Attr) const {
return addAttributeAtIndex(C, ReturnIndex, Attr);
}
/// Add a return value attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addRetAttributes(LLVMContext &C,
const AttrBuilder &B) const {
[[nodiscard]] AttributeList addRetAttributes(LLVMContext &C,
const AttrBuilder &B) const {
return addAttributesAtIndex(C, ReturnIndex, B);
}
/// Add an argument attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addParamAttribute(
LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const {
[[nodiscard]] AttributeList
addParamAttribute(LLVMContext &C, unsigned ArgNo,
Attribute::AttrKind Kind) const {
return addAttributeAtIndex(C, ArgNo + FirstArgIndex, Kind);
}
/// Add an argument attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList
[[nodiscard]] AttributeList
addParamAttribute(LLVMContext &C, unsigned ArgNo, StringRef Kind,
StringRef Value = StringRef()) const {
return addAttributeAtIndex(C, ArgNo + FirstArgIndex, Kind, Value);
@ -573,109 +575,110 @@ public:
/// Add an attribute to the attribute list at the given arg indices. Returns a
/// new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C,
ArrayRef<unsigned> ArgNos,
Attribute A) const;
[[nodiscard]] AttributeList addParamAttribute(LLVMContext &C,
ArrayRef<unsigned> ArgNos,
Attribute A) const;
/// Add an argument attribute to the list. Returns a new list because
/// attribute lists are immutable.
LLVM_NODISCARD AttributeList addParamAttributes(LLVMContext &C,
unsigned ArgNo,
const AttrBuilder &B) const {
[[nodiscard]] AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo,
const AttrBuilder &B) const {
return addAttributesAtIndex(C, ArgNo + FirstArgIndex, B);
}
/// Remove the specified attribute at the specified index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeAttributeAtIndex(
LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const;
[[nodiscard]] AttributeList
removeAttributeAtIndex(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const;
/// Remove the specified attribute at the specified index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeAttributeAtIndex(LLVMContext &C,
unsigned Index,
StringRef Kind) const;
LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, unsigned Index,
StringRef Kind) const {
[[nodiscard]] AttributeList
removeAttributeAtIndex(LLVMContext &C, unsigned Index, StringRef Kind) const;
[[nodiscard]] AttributeList removeAttribute(LLVMContext &C, unsigned Index,
StringRef Kind) const {
return removeAttributeAtIndex(C, Index, Kind);
}
/// Remove the specified attributes at the specified index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeAttributesAtIndex(
LLVMContext &C, unsigned Index, const AttributeMask &AttrsToRemove) const;
[[nodiscard]] AttributeList
removeAttributesAtIndex(LLVMContext &C, unsigned Index,
const AttributeMask &AttrsToRemove) const;
/// Remove all attributes at the specified index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeAttributesAtIndex(LLVMContext &C,
unsigned Index) const;
[[nodiscard]] AttributeList removeAttributesAtIndex(LLVMContext &C,
unsigned Index) const;
/// Remove the specified attribute at the function index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList
[[nodiscard]] AttributeList
removeFnAttribute(LLVMContext &C, Attribute::AttrKind Kind) const {
return removeAttributeAtIndex(C, FunctionIndex, Kind);
}
/// Remove the specified attribute at the function index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeFnAttribute(LLVMContext &C,
StringRef Kind) const {
[[nodiscard]] AttributeList removeFnAttribute(LLVMContext &C,
StringRef Kind) const {
return removeAttributeAtIndex(C, FunctionIndex, Kind);
}
/// Remove the specified attribute at the function index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList
[[nodiscard]] AttributeList
removeFnAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const {
return removeAttributesAtIndex(C, FunctionIndex, AttrsToRemove);
}
/// Remove the attributes at the function index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeFnAttributes(LLVMContext &C) const {
[[nodiscard]] AttributeList removeFnAttributes(LLVMContext &C) const {
return removeAttributesAtIndex(C, FunctionIndex);
}
/// Remove the specified attribute at the return value index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList
[[nodiscard]] AttributeList
removeRetAttribute(LLVMContext &C, Attribute::AttrKind Kind) const {
return removeAttributeAtIndex(C, ReturnIndex, Kind);
}
/// Remove the specified attribute at the return value index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeRetAttribute(LLVMContext &C,
StringRef Kind) const {
[[nodiscard]] AttributeList removeRetAttribute(LLVMContext &C,
StringRef Kind) const {
return removeAttributeAtIndex(C, ReturnIndex, Kind);
}
/// Remove the specified attribute at the return value index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeRetAttributes(
LLVMContext &C, const AttributeMask &AttrsToRemove) const {
[[nodiscard]] AttributeList
removeRetAttributes(LLVMContext &C,
const AttributeMask &AttrsToRemove) const {
return removeAttributesAtIndex(C, ReturnIndex, AttrsToRemove);
}
/// Remove the specified attribute at the specified arg index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeParamAttribute(
LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const {
[[nodiscard]] AttributeList
removeParamAttribute(LLVMContext &C, unsigned ArgNo,
Attribute::AttrKind Kind) const {
return removeAttributeAtIndex(C, ArgNo + FirstArgIndex, Kind);
}
/// Remove the specified attribute at the specified arg index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeParamAttribute(LLVMContext &C,
unsigned ArgNo,
StringRef Kind) const {
[[nodiscard]] AttributeList
removeParamAttribute(LLVMContext &C, unsigned ArgNo, StringRef Kind) const {
return removeAttributeAtIndex(C, ArgNo + FirstArgIndex, Kind);
}
/// Remove the specified attribute at the specified arg index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList
[[nodiscard]] AttributeList
removeParamAttributes(LLVMContext &C, unsigned ArgNo,
const AttributeMask &AttrsToRemove) const {
return removeAttributesAtIndex(C, ArgNo + FirstArgIndex, AttrsToRemove);
@ -683,16 +686,17 @@ public:
/// Remove all attributes at the specified arg index from this
/// attribute list. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList removeParamAttributes(LLVMContext &C,
unsigned ArgNo) const {
[[nodiscard]] AttributeList removeParamAttributes(LLVMContext &C,
unsigned ArgNo) const {
return removeAttributesAtIndex(C, ArgNo + FirstArgIndex);
}
/// Replace the type contained by attribute \p AttrKind at index \p ArgNo wih
/// \p ReplacementTy, preserving all other attributes.
LLVM_NODISCARD AttributeList replaceAttributeTypeAtIndex(
LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind,
Type *ReplacementTy) const {
[[nodiscard]] AttributeList
replaceAttributeTypeAtIndex(LLVMContext &C, unsigned ArgNo,
Attribute::AttrKind Kind,
Type *ReplacementTy) const {
Attribute Attr = getAttributeAtIndex(ArgNo, Kind);
auto Attrs = removeAttributeAtIndex(C, ArgNo, Kind);
return Attrs.addAttributeAtIndex(C, ArgNo,
@ -701,23 +705,25 @@ public:
/// \brief Add the dereferenceable attribute to the attribute set at the given
/// index. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList addDereferenceableRetAttr(LLVMContext &C,
uint64_t Bytes) const;
[[nodiscard]] AttributeList addDereferenceableRetAttr(LLVMContext &C,
uint64_t Bytes) const;
/// \brief Add the dereferenceable attribute to the attribute set at the given
/// arg index. Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList addDereferenceableParamAttr(
LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const;
[[nodiscard]] AttributeList addDereferenceableParamAttr(LLVMContext &C,
unsigned ArgNo,
uint64_t Bytes) const;
/// Add the dereferenceable_or_null attribute to the attribute set at
/// the given arg index. Returns a new list because attribute lists are
/// immutable.
LLVM_NODISCARD AttributeList addDereferenceableOrNullParamAttr(
LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const;
[[nodiscard]] AttributeList
addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned ArgNo,
uint64_t Bytes) const;
/// Add the allocsize attribute to the attribute set at the given arg index.
/// Returns a new list because attribute lists are immutable.
LLVM_NODISCARD AttributeList
[[nodiscard]] AttributeList
addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo, unsigned ElemSizeArg,
const Optional<unsigned> &NumElemsArg);

2
llvm/include/llvm/IR/ConstantRange.h
View File

@ -44,7 +44,7 @@ class raw_ostream;
struct KnownBits;
/// This class represents a range of values.
class LLVM_NODISCARD ConstantRange {
class [[nodiscard]] ConstantRange {
APInt Lower, Upper;
/// Create empty constant range with same bitwidth.

40
llvm/include/llvm/Support/Casting.h
View File

@ -545,12 +545,12 @@ struct CastInfo<To, Optional<From>> : public OptionalValueCast<To, From> {};
/// if (isa<Type>(myVal)) { ... }
/// if (isa<Type0, Type1, Type2>(myVal)) { ... }
template <typename To, typename From>
LLVM_NODISCARD inline bool isa(const From &Val) {
[[nodiscard]] inline bool isa(const From &Val) {
return CastInfo<To, const From>::isPossible(Val);
}
template <typename First, typename Second, typename... Rest, typename From>
LLVM_NODISCARD inline bool isa(const From &Val) {
[[nodiscard]] inline bool isa(const From &Val) {
return isa<First>(Val) || isa<Second, Rest...>(Val);
}
@ -562,25 +562,25 @@ LLVM_NODISCARD inline bool isa(const From &Val) {
/// cast<Instruction>(myVal)->getParent()
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) cast(const From &Val) {
[[nodiscard]] inline decltype(auto) cast(const From &Val) {
assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
return CastInfo<To, const From>::doCast(Val);
}
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) cast(From &Val) {
[[nodiscard]] inline decltype(auto) cast(From &Val) {
assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
return CastInfo<To, From>::doCast(Val);
}
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) cast(From *Val) {
[[nodiscard]] inline decltype(auto) cast(From *Val) {
assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
return CastInfo<To, From *>::doCast(Val);
}
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) cast(std::unique_ptr<From> &&Val) {
[[nodiscard]] inline decltype(auto) cast(std::unique_ptr<From> &&Val) {
assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
return CastInfo<To, std::unique_ptr<From>>::doCast(std::move(Val));
}
@ -594,22 +594,22 @@ LLVM_NODISCARD inline decltype(auto) cast(std::unique_ptr<From> &&Val) {
/// if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) dyn_cast(const From &Val) {
[[nodiscard]] inline decltype(auto) dyn_cast(const From &Val) {
return CastInfo<To, const From>::doCastIfPossible(Val);
}
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) dyn_cast(From &Val) {
[[nodiscard]] inline decltype(auto) dyn_cast(From &Val) {
return CastInfo<To, From>::doCastIfPossible(Val);
}
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) dyn_cast(From *Val) {
[[nodiscard]] inline decltype(auto) dyn_cast(From *Val) {
return CastInfo<To, From *>::doCastIfPossible(Val);
}
template <typename To, typename From>
LLVM_NODISCARD inline decltype(auto) dyn_cast(std::unique_ptr<From> &&Val) {
[[nodiscard]] inline decltype(auto) dyn_cast(std::unique_ptr<From> &&Val) {
return CastInfo<To, std::unique_ptr<From>>::doCastIfPossible(std::move(Val));
}
@ -667,35 +667,35 @@ template <typename T> inline decltype(auto) unwrapValue(T &t) {
/// isa_and_present<X> - Functionally identical to isa, except that a null value
/// is accepted.
template <typename... X, class Y>
LLVM_NODISCARD inline bool isa_and_present(const Y &Val) {
[[nodiscard]] inline bool isa_and_present(const Y &Val) {
if (!detail::isPresent(Val))
return false;
return isa<X...>(Val);
}
template <typename... X, class Y>
LLVM_NODISCARD inline bool isa_and_nonnull(const Y &Val) {
[[nodiscard]] inline bool isa_and_nonnull(const Y &Val) {
return isa_and_present<X...>(Val);
}
/// cast_if_present<X> - Functionally identical to cast, except that a null
/// value is accepted.
template <class X, class Y>
LLVM_NODISCARD inline auto cast_if_present(const Y &Val) {
[[nodiscard]] inline auto cast_if_present(const Y &Val) {
if (!detail::isPresent(Val))
return CastInfo<X, const Y>::castFailed();
assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
return cast<X>(detail::unwrapValue(Val));
}
template <class X, class Y> LLVM_NODISCARD inline auto cast_if_present(Y &Val) {
template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y &Val) {
if (!detail::isPresent(Val))
return CastInfo<X, Y>::castFailed();
assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
return cast<X>(detail::unwrapValue(Val));
}
template <class X, class Y> LLVM_NODISCARD inline auto cast_if_present(Y *Val) {
template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y *Val) {
if (!detail::isPresent(Val))
return CastInfo<X, Y *>::castFailed();
assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
@ -703,7 +703,7 @@ template <class X, class Y> LLVM_NODISCARD inline auto cast_if_present(Y *Val) {
}
template <class X, class Y>
LLVM_NODISCARD inline auto cast_if_present(std::unique_ptr<Y> &&Val) {
[[nodiscard]] inline auto cast_if_present(std::unique_ptr<Y> &&Val) {
if (!detail::isPresent(Val))
return UniquePtrCast<X, Y>::castFailed();
return UniquePtrCast<X, Y>::doCast(std::move(Val));
@ -769,7 +769,7 @@ template <class X, class Y> auto dyn_cast_or_null(Y *Val) {
/// is returned. If the cast is unsuccessful, the function returns nullptr
/// and From is unchanged.
template <class X, class Y>
LLVM_NODISCARD inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
[[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
unique_dyn_cast(std::unique_ptr<Y> &Val) {
if (!isa<X>(Val))
return nullptr;
@ -777,14 +777,14 @@ unique_dyn_cast(std::unique_ptr<Y> &Val) {
}
template <class X, class Y>
LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val) {
[[nodiscard]] inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val) {
return unique_dyn_cast<X, Y>(Val);
}
// unique_dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast,
// except that a null value is accepted.
template <class X, class Y>
LLVM_NODISCARD inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
[[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
unique_dyn_cast_or_null(std::unique_ptr<Y> &Val) {
if (!Val)
return nullptr;
@ -792,7 +792,7 @@ unique_dyn_cast_or_null(std::unique_ptr<Y> &Val) {
}
template <class X, class Y>
LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val) {
[[nodiscard]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val) {
return unique_dyn_cast_or_null<X, Y>(Val);
}

4
llvm/include/llvm/Support/Error.h
View File

@ -152,7 +152,7 @@ private:
/// *All* Error instances must be checked before destruction, even if
/// they're moved-assigned or constructed from Success values that have already
/// been checked. This enforces checking through all levels of the call stack.
class LLVM_NODISCARD Error {
class [[nodiscard]] Error {
// ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
// to add to the error list. It can't rely on handleErrors for this, since
// handleErrors does not support ErrorList handlers.
@ -466,7 +466,7 @@ inline Error joinErrors(Error E1, Error E2) {
/// For unit-testing a function returning an 'Expceted<T>', see the
/// 'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
template <class T> class LLVM_NODISCARD Expected {
template <class T> class [[nodiscard]] Expected {
template <class T1> friend class ExpectedAsOutParameter;
template <class OtherT> friend class Expected;

8
llvm/include/llvm/Support/raw_ostream.h
View File

@ -36,7 +36,7 @@ class format_object_base;
class FormattedString;
class FormattedNumber;
class FormattedBytes;
template <class T> class LLVM_NODISCARD Expected;
template <class T> class [[nodiscard]] Expected;
namespace sys {
namespace fs {
@ -565,7 +565,7 @@ public:
/// });
/// }
/// @endcode
LLVM_NODISCARD Expected<sys::fs::FileLocker> lock();
[[nodiscard]] Expected<sys::fs::FileLocker> lock();
/// Tries to lock the underlying file within the specified period.
///
@ -574,8 +574,8 @@ public:
/// error code.
///
/// It is used as @ref lock.
LLVM_NODISCARD
Expected<sys::fs::FileLocker> tryLockFor(Duration const& Timeout);
[[nodiscard]] Expected<sys::fs::FileLocker>
tryLockFor(Duration const &Timeout);
};
/// This returns a reference to a raw_fd_ostream for standard output. Use it

2
llvm/lib/CodeGen/MachineFunction.cpp
View File

@ -306,7 +306,7 @@ bool MachineFunction::shouldSplitStack() const {
return getFunction().hasFnAttribute("split-stack");
}
LLVM_NODISCARD unsigned
[[nodiscard]] unsigned
MachineFunction::addFrameInst(const MCCFIInstruction &Inst) {
FrameInstructions.push_back(Inst);
return FrameInstructions.size() - 1;

36
llvm/lib/CodeGen/RegisterCoalescer.cpp
View File

@ -418,24 +418,24 @@ INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
INITIALIZE_PASS_END(RegisterCoalescer, "simple-register-coalescing",
"Simple Register Coalescing", false, false)
LLVM_NODISCARD static bool isMoveInstr(const TargetRegisterInfo &tri,
const MachineInstr *MI, Register &Src,
Register &Dst, unsigned &SrcSub,
unsigned &DstSub) {
if (MI->isCopy()) {
Dst = MI->getOperand(0).getReg();
DstSub = MI->getOperand(0).getSubReg();
Src = MI->getOperand(1).getReg();
SrcSub = MI->getOperand(1).getSubReg();
} else if (MI->isSubregToReg()) {
Dst = MI->getOperand(0).getReg();
DstSub = tri.composeSubRegIndices(MI->getOperand(0).getSubReg(),
MI->getOperand(3).getImm());
Src = MI->getOperand(2).getReg();
SrcSub = MI->getOperand(2).getSubReg();
} else
return false;
return true;
[[nodiscard]] static bool isMoveInstr(const TargetRegisterInfo &tri,
const MachineInstr *MI, Register &Src,
Register &Dst, unsigned &SrcSub,
unsigned &DstSub) {
if (MI->isCopy()) {
Dst = MI->getOperand(0).getReg();
DstSub = MI->getOperand(0).getSubReg();
Src = MI->getOperand(1).getReg();
SrcSub = MI->getOperand(1).getSubReg();
} else if (MI->isSubregToReg()) {
Dst = MI->getOperand(0).getReg();
DstSub = tri.composeSubRegIndices(MI->getOperand(0).getSubReg(),
MI->getOperand(3).getImm());
Src = MI->getOperand(2).getReg();
SrcSub = MI->getOperand(2).getSubReg();
} else
return false;
return true;
}
/// Return true if this block should be vacated by the coalescer to eliminate

10
llvm/lib/Transforms/Coroutines/CoroFrame.cpp
View File

@ -449,8 +449,8 @@ public:
/// Add a field to this structure for the storage of an `alloca`
/// instruction.
LLVM_NODISCARD FieldIDType addFieldForAlloca(AllocaInst *AI,
bool IsHeader = false) {
[[nodiscard]] FieldIDType addFieldForAlloca(AllocaInst *AI,
bool IsHeader = false) {
Type *Ty = AI->getAllocatedType();
// Make an array type if this is a static array allocation.
@ -495,9 +495,9 @@ public:
coro::Shape &Shape);
/// Add a field to this structure.
LLVM_NODISCARD FieldIDType addField(Type *Ty, MaybeAlign MaybeFieldAlignment,
bool IsHeader = false,
bool IsSpillOfValue = false) {
[[nodiscard]] FieldIDType addField(Type *Ty, MaybeAlign MaybeFieldAlignment,
bool IsHeader = false,
bool IsSpillOfValue = false) {
assert(!IsFinished && "adding fields to a finished builder");
assert(Ty && "must provide a type for a field");

10
llvm/lib/Transforms/InstCombine/InstCombineInternal.h
View File

@ -792,13 +792,13 @@ class Negator final {
std::array<Value *, 2> getSortedOperandsOfBinOp(Instruction *I);
LLVM_NODISCARD Value *visitImpl(Value *V, unsigned Depth);
[[nodiscard]] Value *visitImpl(Value *V, unsigned Depth);
LLVM_NODISCARD Value *negate(Value *V, unsigned Depth);
[[nodiscard]] Value *negate(Value *V, unsigned Depth);
/// Recurse depth-first and attempt to sink the negation.
/// FIXME: use worklist?
LLVM_NODISCARD Optional<Result> run(Value *Root);
[[nodiscard]] Optional<Result> run(Value *Root);
Negator(const Negator &) = delete;
Negator(Negator &&) = delete;
@ -808,8 +808,8 @@ class Negator final {
public:
/// Attempt to negate \p Root. Retuns nullptr if negation can't be performed,
/// otherwise returns negated value.
LLVM_NODISCARD static Value *Negate(bool LHSIsZero, Value *Root,
InstCombinerImpl &IC);
[[nodiscard]] static Value *Negate(bool LHSIsZero, Value *Root,
InstCombinerImpl &IC);
};
} // end namespace llvm

10
llvm/lib/Transforms/InstCombine/InstCombineNegator.cpp
View File

@ -130,7 +130,7 @@ std::array<Value *, 2> Negator::getSortedOperandsOfBinOp(Instruction *I) {
// FIXME: can this be reworked into a worklist-based algorithm while preserving
// the depth-first, early bailout traversal?
LLVM_NODISCARD Value *Negator::visitImpl(Value *V, unsigned Depth) {
[[nodiscard]] Value *Negator::visitImpl(Value *V, unsigned Depth) {
// -(undef) -> undef.
if (match(V, m_Undef()))
return V;
@ -465,7 +465,7 @@ LLVM_NODISCARD Value *Negator::visitImpl(Value *V, unsigned Depth) {
llvm_unreachable("Can't get here. We always return from switch.");
}
LLVM_NODISCARD Value *Negator::negate(Value *V, unsigned Depth) {
[[nodiscard]] Value *Negator::negate(Value *V, unsigned Depth) {
NegatorMaxDepthVisited.updateMax(Depth);
++NegatorNumValuesVisited;
@ -502,7 +502,7 @@ LLVM_NODISCARD Value *Negator::negate(Value *V, unsigned Depth) {
return NegatedV;
}
LLVM_NODISCARD Optional<Negator::Result> Negator::run(Value *Root) {
[[nodiscard]] Optional<Negator::Result> Negator::run(Value *Root) {
Value *Negated = negate(Root, /*Depth=*/0);
if (!Negated) {
// We must cleanup newly-inserted instructions, to avoid any potential
@ -514,8 +514,8 @@ LLVM_NODISCARD Optional<Negator::Result> Negator::run(Value *Root) {
return std::make_pair(ArrayRef<Instruction *>(NewInstructions), Negated);
}
LLVM_NODISCARD Value *Negator::Negate(bool LHSIsZero, Value *Root,
InstCombinerImpl &IC) {
[[nodiscard]] Value *Negator::Negate(bool LHSIsZero, Value *Root,
InstCombinerImpl &IC) {
++NegatorTotalNegationsAttempted;
LLVM_DEBUG(dbgs() << "Negator: attempting to sink negation into " << *Root
<< "\n");

2
llvm/unittests/ProfileData/CoverageMappingTest.cpp
View File

@ -22,7 +22,7 @@
using namespace llvm;
using namespace coverage;
LLVM_NODISCARD static ::testing::AssertionResult
[[nodiscard]] static ::testing::AssertionResult
ErrorEquals(coveragemap_error Expected, Error E) {
coveragemap_error Found;
std::string FoundMsg;

2
llvm/unittests/ProfileData/InstrProfTest.cpp
View File

@ -23,7 +23,7 @@
using namespace llvm;
LLVM_NODISCARD static ::testing::AssertionResult
[[nodiscard]] static ::testing::AssertionResult
ErrorEquals(instrprof_error Expected, Error E) {
instrprof_error Found;
std::string FoundMsg;