Revert "Make STLExtras's (all|any|none)_of() Utility Functions Constexpr-Friendly" (#173163)

Reverts #172536. This is causing weird assertion
failures in clang, per
#172536 (comment).
It might be a bug in GCC, but still makes sense to revert it in the
interest of bootstrapping.

---------

Signed-off-by: Michał Górny <[email protected]>

Author: mgorny

llvm/include/llvm/ADT/Bitset.h

@@ -16,10 +16,10 @@
 #ifndef LLVM_ADT_BITSET_H
 #define LLVM_ADT_BITSET_H
 
-#include "llvm/ADT/STLExtras.h"
 #include <array>
 #include <climits>
 #include <cstdint>
+#include <llvm/ADT/STLExtras.h>
 
 namespace llvm {
 
@@ -31,27 +31,16 @@ class Bitset {
   using BitWord = uintptr_t;
 
   static constexpr unsigned BitwordBits = sizeof(BitWord) * CHAR_BIT;
-  static constexpr unsigned RemainderNumBits = NumBits % BitwordBits;
-  static constexpr BitWord RemainderMask =
-      RemainderNumBits == 0 ? ~BitWord(0)
-                            : ((BitWord(1) << RemainderNumBits) - 1);
 
   static_assert(BitwordBits == 64 || BitwordBits == 32,
                 "Unsupported word size");
 
   static constexpr unsigned NumWords =
       (NumBits + BitwordBits - 1) / BitwordBits;
 
-  // Returns the index of the last word (0-based). The last word may be
-  // partially filled and requires masking to maintain the invariant that
-  // unused high bits are always zero.
-  static constexpr unsigned getLastWordIndex() { return NumWords - 1; }
-
   using StorageType = std::array<BitWord, NumWords>;
   StorageType Bits{};
 
-  constexpr void maskLastWord() { Bits[getLastWordIndex()] &= RemainderMask; }
-
 protected:
   constexpr Bitset(const std::array<uint64_t, (NumBits + 63) / 64> &B) {
     if constexpr (sizeof(BitWord) == sizeof(uint64_t)) {
@@ -63,13 +52,12 @@ class Bitset {
         uint64_t Elt = B[I];
         // On a 32-bit system the storage type will be 32-bit, so we may only
         // need half of a uint64_t.
-        for (size_t Offset = 0; Offset != 2 && BitsToAssign; ++Offset) {
-          Bits[2 * I + Offset] = static_cast<uint32_t>(Elt >> (32 * Offset));
+        for (size_t offset = 0; offset != 2 && BitsToAssign; ++offset) {
+          Bits[2 * I + offset] = static_cast<uint32_t>(Elt >> (32 * offset));
           BitsToAssign = BitsToAssign >= 32 ? BitsToAssign - 32 : 0;
         }
       }
     }
-    maskLastWord();
   }
 
 public:
@@ -79,11 +67,8 @@ class Bitset {
       set(I);
   }
 
-  constexpr Bitset &set() {
-    constexpr const BitWord AllOnes = ~BitWord(0);
-    for (BitWord &B : Bits)
-      B = AllOnes;
-    maskLastWord();
+  Bitset &set() {
+    llvm::fill(Bits, -BitWord(0));
     return *this;
   }
 
@@ -111,24 +96,14 @@ class Bitset {
 
   constexpr size_t size() const { return NumBits; }
 
-  constexpr bool any() const {
+  bool any() const {
     return llvm::any_of(Bits, [](BitWord I) { return I != 0; });
   }
-
-  constexpr bool none() const { return !any(); }
-
-  constexpr bool all() const {
-    constexpr const BitWord AllOnes = ~BitWord(0);
-    for (unsigned I = 0; I < getLastWordIndex(); ++I)
-      if (Bits[I] != AllOnes)
-        return false;
-    return Bits[getLastWordIndex()] == RemainderMask;
-  }
-
-  constexpr size_t count() const {
+  bool none() const { return !any(); }
+  size_t count() const {
     size_t Count = 0;
-    for (BitWord Word : Bits)
-      Count += popcount(Word);
+    for (auto B : Bits)
+      Count += llvm::popcount(B);
     return Count;
   }
 
@@ -169,22 +144,18 @@ class Bitset {
 
   constexpr Bitset operator~() const {
     Bitset Result = *this;
-    for (BitWord &B : Result.Bits)
+    for (auto &B : Result.Bits)
       B = ~B;
-    Result.maskLastWord();
     return Result;
   }
 
-  constexpr bool operator==(const Bitset &RHS) const {
-    for (unsigned I = 0; I < NumWords; ++I)
-      if (Bits[I] != RHS.Bits[I])
-        return false;
-    return true;
+  bool operator==(const Bitset &RHS) const {
+    return std::equal(std::begin(Bits), std::end(Bits), std::begin(RHS.Bits));
   }
 
-  constexpr bool operator!=(const Bitset &RHS) const { return !(*this == RHS); }
+  bool operator!=(const Bitset &RHS) const { return !(*this == RHS); }
 
-  constexpr bool operator<(const Bitset &Other) const {
+  bool operator<(const Bitset &Other) const {
     for (unsigned I = 0, E = size(); I != E; ++I) {
       bool LHS = test(I), RHS = Other.test(I);
       if (LHS != RHS)

llvm/include/llvm/ADT/STLExtras.h

@@ -638,10 +638,10 @@ make_early_inc_range(RangeT &&Range) {
 
 // Forward declarations required by zip_shortest/zip_equal/zip_first/zip_longest
 template <typename R, typename UnaryPredicate>
-constexpr bool all_of(R &&range, UnaryPredicate P);
+bool all_of(R &&range, UnaryPredicate P);
 
 template <typename R, typename UnaryPredicate>
-constexpr bool any_of(R &&range, UnaryPredicate P);
+bool any_of(R &&range, UnaryPredicate P);
 
 template <typename T> bool all_equal(std::initializer_list<T> Values);
 
@@ -1734,31 +1734,22 @@ UnaryFunction for_each(R &&Range, UnaryFunction F) {
 /// Provide wrappers to std::all_of which take ranges instead of having to pass
 /// begin/end explicitly.
 template <typename R, typename UnaryPredicate>
-constexpr bool all_of(R &&Range, UnaryPredicate P) {
-  // TODO: switch back to std::all_of() after it becomes constexpr in c++20.
-  for (auto I = adl_begin(Range), E = adl_end(Range); I != E; ++I)
-    if (!P(*I))
-      return false;
-  return true;
+bool all_of(R &&Range, UnaryPredicate P) {
+  return std::all_of(adl_begin(Range), adl_end(Range), P);
 }
 
 /// Provide wrappers to std::any_of which take ranges instead of having to pass
 /// begin/end explicitly.
 template <typename R, typename UnaryPredicate>
-constexpr bool any_of(R &&Range, UnaryPredicate P) {
-  // TODO: switch back to std::any_of() after it becomes constexpr in c++20.
-  for (auto I = adl_begin(Range), E = adl_end(Range); I != E; ++I)
-    if (P(*I))
-      return true;
-  return false;
+bool any_of(R &&Range, UnaryPredicate P) {
+  return std::any_of(adl_begin(Range), adl_end(Range), P);
 }
 
 /// Provide wrappers to std::none_of which take ranges instead of having to pass
 /// begin/end explicitly.
 template <typename R, typename UnaryPredicate>
-constexpr bool none_of(R &&Range, UnaryPredicate P) {
-  // TODO: switch back to std::none_of() after it becomes constexpr in c++20.
-  return !any_of(Range, P);
+bool none_of(R &&Range, UnaryPredicate P) {
+  return std::none_of(adl_begin(Range), adl_end(Range), P);
 }
 
 /// Provide wrappers to std::fill which take ranges instead of having to pass