From fa66789d06be2937b15e02a286b67c5f5274df31 Mon Sep 17 00:00:00 2001 From: Fangrui Song Date: Sun, 7 Aug 2022 00:26:33 +0000 Subject: [llvm] LLVM_NODISCARD => [[nodiscard]]. NFC With C++17 there is no Clang pedantic warning. --- llvm/include/llvm/ADT/APInt.h | 2 +- llvm/include/llvm/ADT/APSInt.h | 2 +- llvm/include/llvm/ADT/ArrayRef.h | 6 +- llvm/include/llvm/ADT/DenseMap.h | 4 +- llvm/include/llvm/ADT/ImmutableList.h | 10 +- llvm/include/llvm/ADT/ImmutableMap.h | 6 +- llvm/include/llvm/ADT/ImmutableSet.h | 4 +- llvm/include/llvm/ADT/PriorityWorklist.h | 2 +- llvm/include/llvm/ADT/ScopeExit.h | 2 +- llvm/include/llvm/ADT/SetVector.h | 2 +- llvm/include/llvm/ADT/SmallPtrSet.h | 2 +- llvm/include/llvm/ADT/SmallSet.h | 4 +- llvm/include/llvm/ADT/SmallVector.h | 4 +- llvm/include/llvm/ADT/StringRef.h | 210 ++++++++------------- llvm/include/llvm/ADT/StringSwitch.h | 6 +- llvm/include/llvm/ADT/TypeSwitch.h | 7 +- llvm/include/llvm/ADT/simple_ilist.h | 6 +- llvm/include/llvm/Analysis/AliasAnalysis.h | 38 ++-- llvm/include/llvm/Analysis/ScalarEvolution.h | 22 +-- llvm/include/llvm/CodeGen/MachineFunction.h | 2 +- .../llvm/ExecutionEngine/Orc/ThreadSafeModule.h | 2 +- llvm/include/llvm/IR/Attributes.h | 170 +++++++++-------- llvm/include/llvm/IR/ConstantRange.h | 2 +- llvm/include/llvm/Support/Casting.h | 40 ++-- llvm/include/llvm/Support/Error.h | 4 +- llvm/include/llvm/Support/raw_ostream.h | 8 +- llvm/lib/CodeGen/MachineFunction.cpp | 2 +- llvm/lib/CodeGen/RegisterCoalescer.cpp | 36 ++-- llvm/lib/Transforms/Coroutines/CoroFrame.cpp | 10 +- .../Transforms/InstCombine/InstCombineInternal.h | 10 +- .../Transforms/InstCombine/InstCombineNegator.cpp | 10 +- llvm/unittests/ProfileData/CoverageMappingTest.cpp | 2 +- llvm/unittests/ProfileData/InstrProfTest.cpp | 2 +- 33 files changed, 291 insertions(+), 348 deletions(-) diff --git a/llvm/include/llvm/ADT/APInt.h b/llvm/include/llvm/ADT/APInt.h index 5bdc1541f630..9d371928e636 100644 --- a/llvm/include/llvm/ADT/APInt.h +++ b/llvm/include/llvm/ADT/APInt.h @@ -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; diff --git a/llvm/include/llvm/ADT/APSInt.h b/llvm/include/llvm/ADT/APSInt.h index 727d95ed8c1c..bf7454c41843 100644 --- a/llvm/include/llvm/ADT/APSInt.h +++ b/llvm/include/llvm/ADT/APSInt.h @@ -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: diff --git a/llvm/include/llvm/ADT/ArrayRef.h b/llvm/include/llvm/ADT/ArrayRef.h index ee35a5686fc4..acfa324e6b10 100644 --- a/llvm/include/llvm/ADT/ArrayRef.h +++ b/llvm/include/llvm/ADT/ArrayRef.h @@ -25,7 +25,7 @@ #include namespace llvm { - template class LLVM_NODISCARD MutableArrayRef; + template 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 - 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 - class LLVM_NODISCARD MutableArrayRef : public ArrayRef { + class [[nodiscard]] MutableArrayRef : public ArrayRef { public: using value_type = T; using pointer = value_type *; diff --git a/llvm/include/llvm/ADT/DenseMap.h b/llvm/include/llvm/ADT/DenseMap.h index a6d19d342822..c22a1f8a76e0 100644 --- a/llvm/include/llvm/ADT/DenseMap.h +++ b/llvm/include/llvm/ADT/DenseMap.h @@ -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 diff --git a/llvm/include/llvm/ADT/ImmutableList.h b/llvm/include/llvm/ADT/ImmutableList.h index 23f82691825c..185634cc8885 100644 --- a/llvm/include/llvm/ADT/ImmutableList.h +++ b/llvm/include/llvm/ADT/ImmutableList.h @@ -174,7 +174,7 @@ public: } template - LLVM_NODISCARD ImmutableList concat(ElemT &&Head, ImmutableList Tail) { + [[nodiscard]] ImmutableList concat(ElemT &&Head, ImmutableList Tail) { // Profile the new list to see if it already exists in our cache. FoldingSetNodeID ID; void* InsertPos; @@ -197,13 +197,13 @@ public: } template - LLVM_NODISCARD ImmutableList add(ElemT &&Data, ImmutableList L) { + [[nodiscard]] ImmutableList add(ElemT &&Data, ImmutableList L) { return concat(std::forward(Data), L); } - template - LLVM_NODISCARD ImmutableList emplace(ImmutableList Tail, - CtorArgs &&...Args) { + template + [[nodiscard]] ImmutableList emplace(ImmutableList Tail, + CtorArgs &&...Args) { return concat(T(std::forward(Args)...), Tail); } diff --git a/llvm/include/llvm/ADT/ImmutableMap.h b/llvm/include/llvm/ADT/ImmutableMap.h index c9351b3213dc..3d19ca41a5be 100644 --- a/llvm/include/llvm/ADT/ImmutableMap.h +++ b/llvm/include/llvm/ADT/ImmutableMap.h @@ -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(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); } diff --git a/llvm/include/llvm/ADT/ImmutableSet.h b/llvm/include/llvm/ADT/ImmutableSet.h index b513fe9ec011..5bee746688ce 100644 --- a/llvm/include/llvm/ADT/ImmutableSet.h +++ b/llvm/include/llvm/ADT/ImmutableSet.h @@ -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); } diff --git a/llvm/include/llvm/ADT/PriorityWorklist.h b/llvm/include/llvm/ADT/PriorityWorklist.h index e9fbf296973d..2b6510f42d56 100644 --- a/llvm/include/llvm/ADT/PriorityWorklist.h +++ b/llvm/include/llvm/ADT/PriorityWorklist.h @@ -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; diff --git a/llvm/include/llvm/ADT/ScopeExit.h b/llvm/include/llvm/ADT/ScopeExit.h index 7f013f3f7979..e2a19db1686d 100644 --- a/llvm/include/llvm/ADT/ScopeExit.h +++ b/llvm/include/llvm/ADT/ScopeExit.h @@ -55,7 +55,7 @@ public: // // Interface is specified by p0052r2. template -LLVM_NODISCARD detail::scope_exit::type> +[[nodiscard]] detail::scope_exit::type> make_scope_exit(Callable &&F) { return detail::scope_exit::type>( std::forward(F)); diff --git a/llvm/include/llvm/ADT/SetVector.h b/llvm/include/llvm/ADT/SetVector.h index 08cf42f0b210..556aacd2033e 100644 --- a/llvm/include/llvm/ADT/SetVector.h +++ b/llvm/include/llvm/ADT/SetVector.h @@ -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; diff --git a/llvm/include/llvm/ADT/SmallPtrSet.h b/llvm/include/llvm/ADT/SmallPtrSet.h index ef6dae68b4a6..3d8191b3d162 100644 --- a/llvm/include/llvm/ADT/SmallPtrSet.h +++ b/llvm/include/llvm/ADT/SmallPtrSet.h @@ -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() { diff --git a/llvm/include/llvm/ADT/SmallSet.h b/llvm/include/llvm/ADT/SmallSet.h index 0eed85449c9d..99f7c55ab8fd 100644 --- a/llvm/include/llvm/ADT/SmallSet.h +++ b/llvm/include/llvm/ADT/SmallSet.h @@ -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(); diff --git a/llvm/include/llvm/ADT/SmallVector.h b/llvm/include/llvm/ADT/SmallVector.h index 9a127552c549..e2c07fefc637 100644 --- a/llvm/include/llvm/ADT/SmallVector.h +++ b/llvm/include/llvm/ADT/SmallVector.h @@ -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; diff --git a/llvm/include/llvm/ADT/StringRef.h b/llvm/include/llvm/ADT/StringRef.h index 80ba47dd619c..1ba92038dd75 100644 --- a/llvm/include/llvm/ADT/StringRef.h +++ b/llvm/include/llvm/ADT/StringRef.h @@ -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 - 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 F, size_t From = 0) const { + [[nodiscard]] size_t find_if(function_ref 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 F, size_t From = 0) const { + [[nodiscard]] size_t find_if_not(function_ref 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 F) const { + [[nodiscard]] StringRef take_while(function_ref 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 F) const { + [[nodiscard]] StringRef take_until(function_ref 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 F) const { + [[nodiscard]] StringRef drop_while(function_ref 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 F) const { + [[nodiscard]] StringRef drop_until(function_ref 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 split(char Separator) const { + [[nodiscard]] std::pair 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 split(StringRef Separator) const { + [[nodiscard]] std::pair + 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 rsplit(StringRef Separator) const { + [[nodiscard]] std::pair + 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 rsplit(char Separator) const { + [[nodiscard]] std::pair 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 { diff --git a/llvm/include/llvm/ADT/StringSwitch.h b/llvm/include/llvm/ADT/StringSwitch.h index 95ab1df8d297..6ba75eba9b2e 100644 --- a/llvm/include/llvm/ADT/StringSwitch.h +++ b/llvm/include/llvm/ADT/StringSwitch.h @@ -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); } diff --git a/llvm/include/llvm/ADT/TypeSwitch.h b/llvm/include/llvm/ADT/TypeSwitch.h index 892a7d43b317..cc69f76594a2 100644 --- a/llvm/include/llvm/ADT/TypeSwitch.h +++ b/llvm/include/llvm/ADT/TypeSwitch.h @@ -125,20 +125,19 @@ public: /// As a default, invoke the given callable within the root value. template - 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); } diff --git a/llvm/include/llvm/ADT/simple_ilist.h b/llvm/include/llvm/ADT/simple_ilist.h index d4b6be347219..3a96e1ba5657 100644 --- a/llvm/include/llvm/ADT/simple_ilist.h +++ b/llvm/include/llvm/ADT/simple_ilist.h @@ -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(); } diff --git a/llvm/include/llvm/Analysis/AliasAnalysis.h b/llvm/include/llvm/Analysis/AliasAnalysis.h index 65d7d5bd3f22..47c5d6b9834c 100644 --- a/llvm/include/llvm/Analysis/AliasAnalysis.h +++ b/llvm/include/llvm/Analysis/AliasAnalysis.h @@ -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(MRI) & static_cast(ModRefInfo::Mod); } -LLVM_NODISCARD inline bool isRefSet(const ModRefInfo MRI) { +[[nodiscard]] inline bool isRefSet(const ModRefInfo MRI) { return static_cast(MRI) & static_cast(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(ModRefInfo::ModRef)); } diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h index 987b146cda62..0de9ba7a4b8f 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolution.h +++ b/llvm/include/llvm/Analysis/ScalarEvolution.h @@ -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); }; diff --git a/llvm/include/llvm/CodeGen/MachineFunction.h b/llvm/include/llvm/CodeGen/MachineFunction.h index fc1188186ac4..d0ca7733633b 100644 --- a/llvm/include/llvm/CodeGen/MachineFunction.h +++ b/llvm/include/llvm/CodeGen/MachineFunction.h @@ -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 diff --git a/llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h b/llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h index d4960ab8b0bb..c0df69ffcd88 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h @@ -37,7 +37,7 @@ private: public: // RAII based lock for ThreadSafeContext. - class LLVM_NODISCARD Lock { + class [[nodiscard]] Lock { public: Lock(std::shared_ptr S) : S(std::move(S)), L(this->S->Mutex) {} diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h index 6a4e6d63a973..0657cfdb2e88 100644 --- a/llvm/include/llvm/IR/Attributes.h +++ b/llvm/include/llvm/IR/Attributes.h @@ -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 ArgNos, - Attribute A) const; + [[nodiscard]] AttributeList addParamAttribute(LLVMContext &C, + ArrayRef 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 &NumElemsArg); diff --git a/llvm/include/llvm/IR/ConstantRange.h b/llvm/include/llvm/IR/ConstantRange.h index 68abf4ef555d..d2ff971485b3 100644 --- a/llvm/include/llvm/IR/ConstantRange.h +++ b/llvm/include/llvm/IR/ConstantRange.h @@ -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. diff --git a/llvm/include/llvm/Support/Casting.h b/llvm/include/llvm/Support/Casting.h index b6bbff8ada10..cf9c7c0efbf1 100644 --- a/llvm/include/llvm/Support/Casting.h +++ b/llvm/include/llvm/Support/Casting.h @@ -545,12 +545,12 @@ struct CastInfo> : public OptionalValueCast {}; /// if (isa(myVal)) { ... } /// if (isa(myVal)) { ... } template -LLVM_NODISCARD inline bool isa(const From &Val) { +[[nodiscard]] inline bool isa(const From &Val) { return CastInfo::isPossible(Val); } template -LLVM_NODISCARD inline bool isa(const From &Val) { +[[nodiscard]] inline bool isa(const From &Val) { return isa(Val) || isa(Val); } @@ -562,25 +562,25 @@ LLVM_NODISCARD inline bool isa(const From &Val) { /// cast(myVal)->getParent() template -LLVM_NODISCARD inline decltype(auto) cast(const From &Val) { +[[nodiscard]] inline decltype(auto) cast(const From &Val) { assert(isa(Val) && "cast() argument of incompatible type!"); return CastInfo::doCast(Val); } template -LLVM_NODISCARD inline decltype(auto) cast(From &Val) { +[[nodiscard]] inline decltype(auto) cast(From &Val) { assert(isa(Val) && "cast() argument of incompatible type!"); return CastInfo::doCast(Val); } template -LLVM_NODISCARD inline decltype(auto) cast(From *Val) { +[[nodiscard]] inline decltype(auto) cast(From *Val) { assert(isa(Val) && "cast() argument of incompatible type!"); return CastInfo::doCast(Val); } template -LLVM_NODISCARD inline decltype(auto) cast(std::unique_ptr &&Val) { +[[nodiscard]] inline decltype(auto) cast(std::unique_ptr &&Val) { assert(isa(Val) && "cast() argument of incompatible type!"); return CastInfo>::doCast(std::move(Val)); } @@ -594,22 +594,22 @@ LLVM_NODISCARD inline decltype(auto) cast(std::unique_ptr &&Val) { /// if (const Instruction *I = dyn_cast(myVal)) { ... } template -LLVM_NODISCARD inline decltype(auto) dyn_cast(const From &Val) { +[[nodiscard]] inline decltype(auto) dyn_cast(const From &Val) { return CastInfo::doCastIfPossible(Val); } template -LLVM_NODISCARD inline decltype(auto) dyn_cast(From &Val) { +[[nodiscard]] inline decltype(auto) dyn_cast(From &Val) { return CastInfo::doCastIfPossible(Val); } template -LLVM_NODISCARD inline decltype(auto) dyn_cast(From *Val) { +[[nodiscard]] inline decltype(auto) dyn_cast(From *Val) { return CastInfo::doCastIfPossible(Val); } template -LLVM_NODISCARD inline decltype(auto) dyn_cast(std::unique_ptr &&Val) { +[[nodiscard]] inline decltype(auto) dyn_cast(std::unique_ptr &&Val) { return CastInfo>::doCastIfPossible(std::move(Val)); } @@ -667,35 +667,35 @@ template inline decltype(auto) unwrapValue(T &t) { /// isa_and_present - Functionally identical to isa, except that a null value /// is accepted. template -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(Val); } template -LLVM_NODISCARD inline bool isa_and_nonnull(const Y &Val) { +[[nodiscard]] inline bool isa_and_nonnull(const Y &Val) { return isa_and_present(Val); } /// cast_if_present - Functionally identical to cast, except that a null /// value is accepted. template -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::castFailed(); assert(isa(Val) && "cast_if_present() argument of incompatible type!"); return cast(detail::unwrapValue(Val)); } -template LLVM_NODISCARD inline auto cast_if_present(Y &Val) { +template [[nodiscard]] inline auto cast_if_present(Y &Val) { if (!detail::isPresent(Val)) return CastInfo::castFailed(); assert(isa(Val) && "cast_if_present() argument of incompatible type!"); return cast(detail::unwrapValue(Val)); } -template LLVM_NODISCARD inline auto cast_if_present(Y *Val) { +template [[nodiscard]] inline auto cast_if_present(Y *Val) { if (!detail::isPresent(Val)) return CastInfo::castFailed(); assert(isa(Val) && "cast_if_present() argument of incompatible type!"); @@ -703,7 +703,7 @@ template LLVM_NODISCARD inline auto cast_if_present(Y *Val) { } template -LLVM_NODISCARD inline auto cast_if_present(std::unique_ptr &&Val) { +[[nodiscard]] inline auto cast_if_present(std::unique_ptr &&Val) { if (!detail::isPresent(Val)) return UniquePtrCast::castFailed(); return UniquePtrCast::doCast(std::move(Val)); @@ -769,7 +769,7 @@ template auto dyn_cast_or_null(Y *Val) { /// is returned. If the cast is unsuccessful, the function returns nullptr /// and From is unchanged. template -LLVM_NODISCARD inline typename CastInfo>::CastResultType +[[nodiscard]] inline typename CastInfo>::CastResultType unique_dyn_cast(std::unique_ptr &Val) { if (!isa(Val)) return nullptr; @@ -777,14 +777,14 @@ unique_dyn_cast(std::unique_ptr &Val) { } template -LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr &&Val) { +[[nodiscard]] inline auto unique_dyn_cast(std::unique_ptr &&Val) { return unique_dyn_cast(Val); } // unique_dyn_cast_or_null - Functionally identical to unique_dyn_cast, // except that a null value is accepted. template -LLVM_NODISCARD inline typename CastInfo>::CastResultType +[[nodiscard]] inline typename CastInfo>::CastResultType unique_dyn_cast_or_null(std::unique_ptr &Val) { if (!Val) return nullptr; @@ -792,7 +792,7 @@ unique_dyn_cast_or_null(std::unique_ptr &Val) { } template -LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr &&Val) { +[[nodiscard]] inline auto unique_dyn_cast_or_null(std::unique_ptr &&Val) { return unique_dyn_cast_or_null(Val); } diff --git a/llvm/include/llvm/Support/Error.h b/llvm/include/llvm/Support/Error.h index f2d3388a328f..fe56341b3083 100644 --- a/llvm/include/llvm/Support/Error.h +++ b/llvm/include/llvm/Support/Error.h @@ -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', see the /// 'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h -template class LLVM_NODISCARD Expected { +template class [[nodiscard]] Expected { template friend class ExpectedAsOutParameter; template friend class Expected; diff --git a/llvm/include/llvm/Support/raw_ostream.h b/llvm/include/llvm/Support/raw_ostream.h index f025cde4a16b..b0f06ba4e223 100644 --- a/llvm/include/llvm/Support/raw_ostream.h +++ b/llvm/include/llvm/Support/raw_ostream.h @@ -36,7 +36,7 @@ class format_object_base; class FormattedString; class FormattedNumber; class FormattedBytes; -template class LLVM_NODISCARD Expected; +template class [[nodiscard]] Expected; namespace sys { namespace fs { @@ -565,7 +565,7 @@ public: /// }); /// } /// @endcode - LLVM_NODISCARD Expected lock(); + [[nodiscard]] Expected 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 tryLockFor(Duration const& Timeout); + [[nodiscard]] Expected + tryLockFor(Duration const &Timeout); }; /// This returns a reference to a raw_fd_ostream for standard output. Use it diff --git a/llvm/lib/CodeGen/MachineFunction.cpp b/llvm/lib/CodeGen/MachineFunction.cpp index 6b481a374382..d2c224898fe2 100644 --- a/llvm/lib/CodeGen/MachineFunction.cpp +++ b/llvm/lib/CodeGen/MachineFunction.cpp @@ -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; diff --git a/llvm/lib/CodeGen/RegisterCoalescer.cpp b/llvm/lib/CodeGen/RegisterCoalescer.cpp index 4f8b6b241a76..aac98cf924e1 100644 --- a/llvm/lib/CodeGen/RegisterCoalescer.cpp +++ b/llvm/lib/CodeGen/RegisterCoalescer.cpp @@ -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 diff --git a/llvm/lib/Transforms/Coroutines/CoroFrame.cpp b/llvm/lib/Transforms/Coroutines/CoroFrame.cpp index 627886316730..5b0e0cba13a7 100644 --- a/llvm/lib/Transforms/Coroutines/CoroFrame.cpp +++ b/llvm/lib/Transforms/Coroutines/CoroFrame.cpp @@ -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"); diff --git a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h index cb533908e3fe..544838de2622 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h +++ b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h @@ -792,13 +792,13 @@ class Negator final { std::array 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 run(Value *Root); + [[nodiscard]] Optional 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 diff --git a/llvm/lib/Transforms/InstCombine/InstCombineNegator.cpp b/llvm/lib/Transforms/InstCombine/InstCombineNegator.cpp index c573b03f31a6..a3e0c45269ed 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineNegator.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineNegator.cpp @@ -130,7 +130,7 @@ std::array 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::run(Value *Root) { +[[nodiscard]] Optional 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::run(Value *Root) { return std::make_pair(ArrayRef(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"); diff --git a/llvm/unittests/ProfileData/CoverageMappingTest.cpp b/llvm/unittests/ProfileData/CoverageMappingTest.cpp index 758398daeeeb..e04265eb0813 100644 --- a/llvm/unittests/ProfileData/CoverageMappingTest.cpp +++ b/llvm/unittests/ProfileData/CoverageMappingTest.cpp @@ -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; diff --git a/llvm/unittests/ProfileData/InstrProfTest.cpp b/llvm/unittests/ProfileData/InstrProfTest.cpp index 6f11a2e62622..86a049223eeb 100644 --- a/llvm/unittests/ProfileData/InstrProfTest.cpp +++ b/llvm/unittests/ProfileData/InstrProfTest.cpp @@ -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; -- cgit v1.2.3