[libc++] Remove test-suite annotations for unsupported Clang versions

[ldionne]

Fix incorrectly removed UNSUPPORTED annotations on GCC for trivial_abi

libcxx/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.verify.cpp

 //     void
 //     random_shuffle(RandomAccessIterator first, RandomAccessIterator last);
 //
 // template <class RandomAccessIterator, class RandomNumberGenerator>
 //     void
 //     random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
 //                    RandomNumberGenerator& rand);
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03, c++11
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 
 #include <algorithm>
 #include <cstddef>
 
 #include "test_macros.h"

libcxx/test/libcxx/atomics/ext-int.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <atomic>
 
 // Make sure that `std::atomic` doesn't work with `_ExtInt`. The intent is to
 // disable them for now until their behavior can be designed better later.
 // See https://reviews.llvm.org/D84049 for details.
 
-// UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
-// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11, apple-clang-12
+// UNSUPPORTED: apple-clang-12
 
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++03
 
 #include <atomic>
 
 int main(int, char**)
 {
   // expected-error@atomic:*1 {{_Atomic cannot be applied to integer type '_ExtInt(32)'}}
   std::atomic<_ExtInt(32)> x(42);
 
   return 0;
 }

libcxx/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: diagnose-if-support
 // UNSUPPORTED: c++03
 
 // Libc++ only provides a defined primary template for std::hash in C++14 and
 // newer.
 // UNSUPPORTED: c++11
 
-// Clang doesn't support filename wildcards in verify tests until 05eedf1f5b44.
-// UNSUPPORTED: clang-10
-
 // <unordered_set>
 
 // Test that we generate a reasonable diagnostic when the specified hash is
 // not enabled.
 
 #include <unordered_set>
 #include <utility>
 

libcxx/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.verify.cpp

 //
 // class auto_ptr<void>;
 //
 // template <class X>
 // class auto_ptr_ref;
 //
 // Deprecated in C++11
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
 
 #include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::auto_ptr<int> AP; // expected-warning {{'auto_ptr<int>' is deprecated}}
     typedef std::auto_ptr<void> APV; // expected-warning {{'auto_ptr<void>' is deprecated}}
     typedef std::auto_ptr_ref<int> APR; // expected-warning {{'auto_ptr_ref<int>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 #include <cassert>
 #include "test_macros.h"
 

libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Test that entities declared [[nodiscard]] as at extension by libc++, are
 // only actually declared such when _LIBCPP_ENABLE_NODISCARD is specified.
 
 // This test intentionally leaks memory, so it is unsupported under ASAN.
 // UNSUPPORTED: asan
 
-// AppleClang9 and GCC 5 don't support C++17's implicitly synthesized
-// deduction guides from existing ctors, needed by default_searcher() below.
-// UNSUPPORTED: apple-clang-9
-
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.fail.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 #include <algorithm>
 #include <cstddef> // to_integer
 #include <functional> // identity
 #include <iterator>

libcxx/test/libcxx/diagnostics/nodiscard_extensions.verify.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// AppleClang9 doesn't yet support C++17's implicitly synthesized deduction
-// guides from existing ctors, needed by default_searcher() below.
-// UNSUPPORTED: apple-clang-9
-
 // Test that entities declared [[nodiscard]] as an extension by libc++, are
 // only actually declared such when _LIBCPP_ENABLE_NODISCARD is specified.
 
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.pass.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_NODISCARD

libcxx/test/libcxx/language.support/support.dynamic/aligned_alloc_availability.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure we get compile-time availability errors when trying to use aligned
-// allocation/deallocation on deployment targets that don't support it.
+// allocation/deallocation on deployment targets that don't support it (before macosx10.14).
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // Aligned allocation was not provided before macosx10.14.
-// Support for that is broken prior to Clang 8 and Apple Clang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
-
 // REQUIRES: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 #include <new>
 #include <cstddef>
 
 #include "test_macros.h"
 
 constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;

libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp

 // functions, so trying to force using those with -faligned-allocation results
 // in a link error.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
-// AppleClang < 10 incorrectly warns that aligned allocation is not supported
-// even when it is supported.
-// UNSUPPORTED: apple-clang-9
-
 // XFAIL: sanitizer-new-delete, ubsan
 
 // GCC doesn't support the aligned-allocation flags.
 // XFAIL: gcc
 
 // RUN: %{build} -faligned-allocation -fsized-deallocation
 // RUN: %{run}
 // RUN: %{build} -faligned-allocation -fno-sized-deallocation -DNO_SIZE

libcxx/test/libcxx/memory/aligned_allocation_macro.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// AppleClang <= 10 enables aligned allocation regardless of the deployment
-// target, so this test would fail.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 #include <new>
 
 #include "test_macros.h"
 
 
 #ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
 #   error "libc++ should have aligned allocation in C++17 and up when targeting a platform that supports it"
 #endif

libcxx/test/libcxx/memory/trivial_abi/shared_ptr_arg.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test shared_ptr<T> with trivial_abi as parameter type.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI
 
-// There were assertion failures in both parse and codegen, which are fixed in clang 11.
-// UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
+// XFAIL: gcc
 // UNSUPPORTED: c++03
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_arg.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test unique_ptr<T> with trivial_abi as parameter type.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
 
-// There were assertion failures in both parse and codegen, which are fixed in clang 11.
-// UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
+// XFAIL: gcc
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   int* shared_val;

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_array.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test unique_ptr<T[]> with trivial_abi as parameter type.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
 
-// There were assertion failures in both parse and codegen, which are fixed in clang 11.
-// UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
+// XFAIL: gcc
 // UNSUPPORTED: c++03
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test arguments destruction order involving unique_ptr<T> with trivial_abi.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
 
-// There were assertion failures in both parse and codegen, which are fixed in clang 11.
-// UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
-
+// XFAIL: gcc
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Base {
   char* shared_buff;

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_ret.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test unique_ptr<T> with trivial_abi as return-type.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
 
-// There were assertion failures in both parse and codegen, which are fixed in clang 11.
-// UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
+// XFAIL: gcc
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   explicit Node() {}

libcxx/test/libcxx/memory/trivial_abi/weak_ptr_ret.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // Test weak_ptr<T> with trivial_abi as return-type.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI
 
-// There were assertion failures in both parse and codegen, which are fixed in clang 11.
-// UNSUPPORTED: gcc, clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
+// XFAIL: gcc
 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   explicit Node() {}

libcxx/test/libcxx/thread/thread.lock/thread.lock.guard/nodiscard.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: libcpp-has-no-threads
 
-// [[nodiscard]] on constructors isn't supported by all compilers
-// UNSUPPORTED: clang-6, clang-7, clang-8, clang-9
-// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11
-
 // [[nodiscard]] isn't supported in C++03 (not even as an extension)
 // UNSUPPORTED: c++03
 
 // <mutex>
 
 // template <class Mutex> class lock_guard;
 
 // [[nodiscard]] explicit lock_guard(mutex_type& m);

libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// Clang doesn't support filename wildcards in verify tests until 05eedf1f5b44.
-// UNSUPPORTED: clang-10
-
 #include <memory>
 
 template <int> struct Tag {};
 
 template <int ID>
 using SPtr = std::shared_ptr<void(Tag<ID>)>;
 
 template <int ID>

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   constexpr OutIter   // constexpr after C++17
 //   copy(InIter first, InIter last, OutIter result);
 
 #include <algorithm>
 #include <cassert>

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
 //   requires OutputIterator<OutIter, InIter::reference>
 //   constexpr OutIter   // constexpr after C++17
 //   copy_backward(InIter first, InIter last, OutIter result);
 
 #include <algorithm>

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   constexpr OutIter   // constexpr after C++17
 //   copy_n(InIter first, InIter::difference_type n, OutIter result);
 
 #include <algorithm>
 #include <cassert>

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/contiguous_trivial_optimization.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// Older compilers don't support std::is_constant_evaluated
-// UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8
-// UNSUPPORTED: apple-clang-9, apple-clang-10
 // UNSUPPORTED: c++03
 
 // <algorithm>
 
 // We optimize std::copy(_backward) and std::move(_backward) into memmove
 // when the iterator is trivial and contiguous and the type in question
 // is also trivially (copyable, movable). This test verifies that the
 // optimization never eliminates an actually non-trivial copy or move.

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // template<InputIterator InIter, typename OutIter>
 //   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move(InIter first, InIter last, OutIter result);
 
-// Older compilers don't support std::is_constant_evaluated
-// UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8
-// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11
-
 #include <algorithm>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class InIter, class OutIter>

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// Older compilers don't support std::is_constant_evaluated
-// UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-
 // <algorithm>
 
 // template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
 //   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move_backward(InIter first, InIter last, OutIter result);
 
 #include <algorithm>

libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // template<ShuffleIterator Iter>
 //   Iter
 //   rotate(Iter first, Iter middle, Iter last);
 
-// Older compilers don't support std::is_constant_evaluated
-// UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-
 #include <algorithm>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class Iter>

libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // template<ForwardIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   constexpr OutIter          // constexpr after C++17
 //   rotate_copy(InIter first, InIter middle, InIter last, OutIter result);
 
-// Older compilers don't support std::is_constant_evaluated
-// UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 
 template <class InIter, class OutIter>

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && HasLess<InIter2::value_type, InIter1::value_type>
 //         && HasLess<InIter1::value_type, InIter2::value_type>
 //   constexpr OutIter       // constexpr after C++17

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
 //          CopyConstructible Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
 //         && Predicate<Compare, InIter2::value_type, InIter1::value_type>

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && HasLess<InIter2::value_type, InIter1::value_type>
 //         && HasLess<InIter1::value_type, InIter2::value_type>
 //   constexpr OutIter       // constexpr after C++17

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
 //          CopyConstructible Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
 //         && Predicate<Compare, InIter2::value_type, InIter1::value_type>

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && HasLess<InIter2::value_type, InIter1::value_type>
 //         && HasLess<InIter1::value_type, InIter2::value_type>
 //   constexpr OutIter       // constexpr after C++17

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
 //          CopyConstructible Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
 //         && Predicate<Compare, InIter2::value_type, InIter1::value_type>

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && HasLess<InIter2::value_type, InIter1::value_type>
 //         && HasLess<InIter1::value_type, InIter2::value_type>
 //   constexpr OutIter       // constexpr after C++17

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
 //          CopyConstructible Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
 //         && Predicate<Compare, InIter2::value_type, InIter1::value_type>

libcxx/test/std/algorithms/robust_against_adl.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
 // UNSUPPORTED: c++03
 
 // <algorithm>
 
 #include <algorithm>
 #include <functional>
 
 #include "test_macros.h"

libcxx/test/std/containers/associative/map/map.cons/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <map>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
-//  clang-6 gives different error messages.
+
+// <map>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // map(InputIterator, InputIterator,
 //          Compare = Compare(), Allocator = Allocator())
 //   -> map<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>

libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <map>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
-//  clang-6 gives different error messages.
+
+// <map>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // multimap(InputIterator, InputIterator,
 //          Compare = Compare(), Allocator = Allocator())
 //   -> multimap<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>

libcxx/test/std/containers/associative/multiset/multiset.cons/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <set>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
-//  clang-6 gives different error messages.
+
+// <set>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // multiset(InputIterator, InputIterator,
 //          Compare = Compare(), Allocator = Allocator())
 //   -> multiset<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>,

libcxx/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <set>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: apple-clang-9.1
+
+// <set>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // multiset(InputIterator, InputIterator,
 //          Compare = Compare(), Allocator = Allocator())
 //   -> multiset<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>,

libcxx/test/std/containers/associative/set/set.cons/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <set>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
-//  clang-6 gives different error messages.
+
+// <set>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // set(InputIterator, InputIterator,
 //     Compare = Compare(), Allocator = Allocator())
 //   -> set<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>,

libcxx/test/std/containers/associative/set/set.cons/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <set>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: apple-clang-9.1
+
+// <set>
 
 // template<class InputIterator,
 //          class Compare = less<iter-value-type<InputIterator>>,
 //          class Allocator = allocator<iter-value-type<InputIterator>>>
 // set(InputIterator, InputIterator,
 //     Compare = Compare(), Allocator = Allocator())
 //   -> set<iter-value-type<InputIterator>, Compare, Allocator>;
 // template<class Key, class Compare = less<Key>,

libcxx/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-5, apple-clang-9
-// Clang 5 will generate bad implicit deduction guides
-//  Specifically, for the copy constructor.
 
 // template<class Container>
 //   queue(Container) -> queue<typename Container::value_type, Container>;
 //
 // template<class Container, class Allocator>
 //   queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
 
 

libcxx/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <stack>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-5, apple-clang-9
-// Clang 5 will generate bad implicit deduction guides
-//  Specifically, for the copy constructor.
 
 // template<class Container>
 //   stack(Container) -> stack<typename Container::value_type, Container>;
 //
 // template<class Container, class Allocator>
 //   stack(Container, Allocator) -> stack<typename Container::value_type, Container>;
 
 

libcxx/test/std/containers/sequences/array/array.cons/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-5, apple-clang-9
-// Clang 5 will generate bad implicit deduction guides
-//  Specifically, for the copy constructor.
 
 // template <class T, class... U>
 //   array(T, U...) -> array<T, 1 + sizeof...(U)>;
 //
 //  Requires: (is_same_v<T, U> && ...) is true. Otherwise the program is ill-formed.
 
 #include <array>
 #include <cassert>

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_map>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
+
+// <unordered_map>
 
 // template<class InputIterator,
 //          class Hash = hash<iter-key-type<InputIterator>>,
 //          class Pred = equal_to<iter-key-type<InputIterator>>,
 //          class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
 // unordered_map(InputIterator, InputIterator, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_map>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
+
+// <unordered_map>
 
 // template<class InputIterator,
 //          class Hash = hash<iter-key-type<InputIterator>>,
 //          class Pred = equal_to<iter-key-type<InputIterator>>,
 //          class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
 // unordered_multimap(InputIterator, InputIterator, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_set>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
+
+// <unordered_set>
 
 // template<class InputIterator,
 //        class Hash = hash<iter-value-type<InputIterator>>,
 //        class Pred = equal_to<iter-value-type<InputIterator>>,
 //        class Allocator = allocator<iter-value-type<InputIterator>>>
 // unordered_multiset(InputIterator, InputIterator, typename see below::size_type = see below,
 //                    Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_multiset<iter-value-type<InputIterator>,

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_set>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: apple-clang-9.1
+
+// <unordered_set>
 
 // template<class InputIterator,
 //        class Hash = hash<iter-value-type<InputIterator>>,
 //        class Pred = equal_to<iter-value-type<InputIterator>>,
 //        class Allocator = allocator<iter-value-type<InputIterator>>>
 // unordered_multiset(InputIterator, InputIterator, typename see below::size_type = see below,
 //                    Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_multiset<iter-value-type<InputIterator>,

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_set>
 // UNSUPPORTED: c++03, c++11, c++14
-// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0.0
+
+// <unordered_set>
 
 // template<class InputIterator,
 //        class Hash = hash<iter-value-type<InputIterator>>,
 //        class Pred = equal_to<iter-value-type<InputIterator>>,
 //        class Allocator = allocator<iter-value-type<InputIterator>>>
 // unordered_set(InputIterator, InputIterator, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_set<iter-value-type<InputIterator>,

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_set>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: apple-clang-9.1
+
+// <unordered_set>
 
 // template<class InputIterator,
 //        class Hash = hash<iter-value-type<InputIterator>>,
 //        class Pred = equal_to<iter-value-type<InputIterator>>,
 //        class Allocator = allocator<iter-value-type<InputIterator>>>
 // unordered_set(InputIterator, InputIterator, typename see below::size_type = see below,
 //               Hash = Hash(), Pred = Pred(), Allocator = Allocator())
 //   -> unordered_set<iter-value-type<InputIterator>,

libcxx/test/std/depr/depr.c.headers/float_h.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// Before Clang 9.0, <float.h> does not define FLT_HAS_SUBNORM & friends in C++.
-// XFAIL: clang-4, clang-5, clang-6, clang-7, clang-8
-
 // test <float.h>
 
 #include <float.h>
 
 #include "test_macros.h"
 
 #ifndef FLT_ROUNDS
 #error FLT_ROUNDS not defined

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // bind1st
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::bind1st(test_func(1), 5); // expected-warning {{'bind1st<test_func, int>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // bind2nd
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::bind2nd(test_func(1), 5); // expected-warning {{'bind2nd<test_func, int>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // binder1st
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::binder1st<test_func> B1ST; // expected-warning {{'binder1st<test_func>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // binder2nd
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::binder2nd<test_func> B2ND; // expected-warning {{'binder2nd<test_func>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11, apple-clang-12.0.0
+// UNSUPPORTED: apple-clang-12
 
 // In MSVC mode, there's a slightly different number of errors printed for
 // each of these, so it doesn't add up to the exact expected count of 18.
-// UNSUPPORTED: msvc
+// XFAIL: msvc
 
 // <compare>
 
 // Ensure we reject all cases where an argument other than a literal 0 is used
 // for a comparison against a comparison category type.
 
 #include <compare>
 

libcxx/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11, apple-clang-12.0.0
+// UNSUPPORTED: apple-clang-12
 
 // <compare>
 
 // class partial_ordering
 
 
 #include <compare>
 #include <type_traits>

libcxx/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11, apple-clang-12.0.0
+// UNSUPPORTED: apple-clang-12
 
 // <compare>
 
 // class strong_ordering
 
 
 #include <compare>
 #include <type_traits>

libcxx/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11, apple-clang-12.0.0
+// UNSUPPORTED: apple-clang-12
 
 // <compare>
 
 // class weak_ordering
 
 
 #include <compare>
 #include <type_traits>

libcxx/test/std/language.support/support.dynamic/destroying_delete_t.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // struct destroying_delete_t {
 //   explicit destroying_delete_t() = default;
 // };
 // inline constexpr destroying_delete_t destroying_delete{};
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-6, clang-7
-
 #include <new>
 
 #include <cassert>
 #include "test_macros.h"
 
 struct A {
   void *data;
   A();

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // test aligned operator delete replacement.
 
 // UNSUPPORTED: sanitizer-new-delete, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
-
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete
 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // test operator new
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete
 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // test operator new (nothrow)
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // test operator new nothrow by replacing only operator new
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // test sized operator delete[] replacement.
 
 // UNSUPPORTED: sanitizer-new-delete, c++03, c++11
 
 // NOTE: Clang does not enable sized-deallocation in C++14 and beyond by
 // default. It is only enabled when -fsized-deallocation is given.
-// (except clang-3.6 which temporarily enabled sized-deallocation)
-// UNSUPPORTED: clang, apple-clang
+// XFAIL: clang, apple-clang
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // test aligned operator delete replacement.
 
 // UNSUPPORTED: sanitizer-new-delete, c++03, c++11, c++14
 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
-// However, support for that was broken prior to Clang 8 and AppleClang 11.
-// UNSUPPORTED: apple-clang-9, apple-clang-10
-// UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // test operator new nothrow by replacing only operator new
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // test sized operator delete replacement.
 
 // UNSUPPORTED: sanitizer-new-delete, c++03, c++11
 
 // NOTE: Clang does not enable sized-deallocation in C++14 and beyond by
 // default. It is only enabled when -fsized-deallocation is given.
-// (except clang-3.6 which temporarily enabled sized-deallocation)
-// UNSUPPORTED: clang, apple-clang
+// XFAIL: clang, apple-clang
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // test sized operator delete replacement.
 
 // Note that sized delete operator definitions below are simply ignored
 // when sized deallocation is not supported, e.g., prior to C++14.
 
 // UNSUPPORTED: sanitizer-new-delete
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
-// NOTE: Only clang-3.7 and GCC 5.1 and greater support -fsized-deallocation.
 // REQUIRES: -fsized-deallocation
 // ADDITIONAL_COMPILE_FLAGS: -fsized-deallocation, -O3
 
 #if !defined(__cpp_sized_deallocation)
 # error __cpp_sized_deallocation should be defined
 #endif
 
 #if !(__cpp_sized_deallocation >= 201309L)

libcxx/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// Before Clang 9.0, <float.h> does not define FLT_HAS_SUBNORM & friends in C++.
-// XFAIL: clang-4, clang-5, clang-6, clang-7, clang-8
-
 // test <cfloat>
 
 #include <cfloat>
 
 #include "test_macros.h"
 
 #ifndef FLT_ROUNDS
 #error FLT_ROUNDS not defined

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <InputIterator Iter, MoveConstructible T>
 //   requires HasPlus<T, Iter::reference>
 //         && HasAssign<T, HasPlus<T, Iter::reference>::result_type>
 //   T
 //   accumulate(Iter first, Iter last, T init);
 

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <InputIterator Iter, MoveConstructible T,
 //           Callable<auto, const T&, Iter::reference> BinaryOperation>
 //   requires HasAssign<T, BinaryOperation::result_type>
 //         && CopyConstructible<BinaryOperation>
 //   T
 //   accumulate(Iter first, Iter last, T init, BinaryOperation binary_op);

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <InputIterator InIter,
 //           OutputIterator<auto, const InIter::value_type&> OutIter>
 //   requires HasMinus<InIter::value_type, InIter::value_type>
 //         && Constructible<InIter::value_type, InIter::reference>
 //         && OutputIterator<OutIter,
 //                           HasMinus<InIter::value_type, InIter::value_type>::result_type>

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <InputIterator InIter,
 //           OutputIterator<auto, const InIter::value_type&> OutIter,
 //           Callable<auto, const InIter::value_type&, const InIter::value_type&> BinaryOperation>
 //   requires Constructible<InIter::value_type, InIter::reference>
 //         && OutputIterator<OutIter, BinaryOperation::result_type>
 //         && MoveAssignable<InIter::value_type>

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T>
 //     OutputIterator exclusive_scan(InputIterator first, InputIterator last,
 //                                   OutputIterator result, T init);
 //

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     exclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T>
 //     OutputIterator inclusive_scan(InputIterator first, InputIterator last,
 //                                   OutputIterator result, T init);
 //

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T>
 //   requires HasMultiply<Iter1::reference, Iter2::reference>
 //         && HasPlus<T, HasMultiply<Iter1::reference, Iter2::reference>::result_type>
 //         && HasAssign<T,
 //                      HasPlus<T,
 //                              HasMultiply<Iter1::reference,

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T,
 //           class BinaryOperation1,
 //           Callable<auto, Iter1::reference, Iter2::reference> BinaryOperation2>
 //   requires Callable<BinaryOperation1, const T&, BinaryOperation2::result_type>
 //         && HasAssign<T, BinaryOperation1::result_type>
 //         && CopyConstructible<BinaryOperation1>

libcxx/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <class ForwardIterator, class T>
 //     void iota(ForwardIterator first, ForwardIterator last, T value);
 
 #include <numeric>
 #include <cassert>
 

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter>
 //   requires HasPlus<InIter::value_type, InIter::reference>
 //         && HasAssign<InIter::value_type,
 //                      HasPlus<InIter::value_type, InIter::reference>::result_type>
 //         && Constructible<InIter::value_type, InIter::reference>
 //   OutIter

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
-// UNSUPPORTED: clang-8
 
 // Became constexpr in C++20
 // template<InputIterator InIter,
 //          OutputIterator<auto, const InIter::value_type&> OutIter,
 //          Callable<auto, const InIter::value_type&, InIter::reference> BinaryOperation>
 //   requires HasAssign<InIter::value_type, BinaryOperation::result_type>
 //         && Constructible<InIter::value_type, InIter::reference>
 //         && CopyConstructible<BinaryOperation>

libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
+
+// <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator>
 //     typename iterator_traits<InputIterator>::value_type
 //     reduce(InputIterator first, InputIterator last);
 
 #include <numeric>
 #include <cassert>

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
+
+// <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class T>
 //   T reduce(InputIterator first, InputIterator last, T init);
 
 #include <numeric>
 #include <cassert>
 

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
+
+// <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class T, class BinaryOperation>
 //   T reduce(InputIterator first, InputIterator last, T init, BinaryOperation op);
 
 #include <numeric>
 #include <cassert>
 

libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result, T init,

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
 
 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
+
+// <numeric>
 
 // Became constexpr in C++20
 // template <class InputIterator1, class T,
 //           class BinaryOperation, class UnaryOperation>
 //    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
 //                       T init, BinaryOperation binary_op, UnaryOperation unary_op);
 //
 

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
+
+// <numeric>
 
 // Became constexpr in C++20
 // template <class InputIterator1, class InputIterator2, class T>
 //   T transform_reduce(InputIterator1 first1, InputIterator1 last1,
 //                      InputIterator2 first2, T init);
 
 
 #include <numeric>

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-8
+
+// <numeric>
 
 // Became constexpr in C++20
 // template <class InputIterator1, class InputIterator2, class T,
 //           class BinaryOperation1, class BinaryOperation2>
 //    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
 //                       InputIterator2 first2, T init,
 //                       BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
 //

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: clang-10
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // unspecified begin;
 
 #include <ranges>
 
 #include <type_traits>
 
 using begin_t = decltype(std::ranges::begin);
 
-// clang-format off
 template <class T>
 requires(!std::invocable<begin_t&, T>)
 void f() {}
-// clang-format on
 
 void test() {
   struct incomplete;
   f<incomplete(&)[]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@-2 {{no matching function for call to 'f'}}
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@-2 {{no matching function for call to 'f'}}
   f<incomplete(&)[2][2]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@-2 {{no matching function for call to 'f'}}
 
   // This is okay because calling `std::ranges::begin` on any rvalue is ill-formed.
   f<incomplete(&&)[10]>();
 }

libcxx/test/std/ranges/range.access/range.access.cbegin/incomplete.compile.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: clang-10
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // ranges::cbegin;
 
 #include <ranges>
 
 #include <type_traits>
 
 using cbegin_t = decltype(std::ranges::cbegin);
 
-// clang-format off
 template <class T>
 requires(!std::invocable<cbegin_t&, T>)
 void f() {}
-// clang-format on
 
 void test() {
   struct incomplete;
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@-2 {{no matching function for call to 'f'}}
 
   // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
   f<incomplete(&&)[10]>();
 }

libcxx/test/std/ranges/range.access/range.access.cend/incomplete.compile.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: clang-10
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // unspecified begin;
 
 #include <ranges>
 
 #include <type_traits>
 
 using cend_t = decltype(std::ranges::cend);
 
-// clang-format off
 template <class T>
 requires(!std::invocable<cend_t&, T>)
 void f() {}
-// clang-format on
 
 void test() {
   struct incomplete;
   f<incomplete(&)[]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}

libcxx/test/std/ranges/range.access/range.access.end/incomplete.compile.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: clang-10
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // unspecified begin;
 
 #include <ranges>
 
 #include <type_traits>
 
 using end_t = decltype(std::ranges::end);
 
-// clang-format off
 template <class T>
 requires(!std::invocable<end_t&, T>)
 void f() {}
-// clang-format on
 
 void test() {
   struct incomplete;
   f<incomplete(&)[]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}

libcxx/test/std/ranges/range.access/range.prim/data.incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: clang-10
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // std::ranges::data
 
 #include <ranges>
 
 struct Incomplete;
 

libcxx/test/std/ranges/range.access/range.prim/empty.incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: clang-10
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // std::ranges::empty
 
 #include <ranges>
 
 struct Incomplete;
 

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-4.0
-// UNSUPPORTED: apple-clang-9
 
 // template<class InputIterator,
 //      class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //  basic_string(InputIterator, InputIterator, Allocator = Allocator())
 //    -> basic_string<typename iterator_traits<InputIterator>::value_type,
 //                 char_traits<typename iterator_traits<InputIterator>::value_type>,
 //                 Allocator>;
 //

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <string>
 
 // template<> struct char_traits<char>
 
 // static char_type* assign(char_type* s, size_t n, char_type a);
 
 #include <string>
 #include <cassert>

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
 // UNSUPPORTED: LIBCXX-DEBUG-FIXME
 
 // <string>
 
 // template<> struct char_traits<char>
 
 // static char_type* copy(char_type* s1, const char_type* s2, size_t n);
 

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <string>
 
 // template<> struct char_traits<char>
 
 // static char_type* move(char_type* s1, const char_type* s2, size_t n);
 
 #include <string>
 #include <cassert>

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-8
 
 // <string>
 
 // template<> struct char_traits<char8_t>
 
 // static char_type* assign(char_type* s, size_t n, char_type a);
 
 #include <string>

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-8
 // UNSUPPORTED: LIBCXX-DEBUG-FIXME
 
 // <string>
 
 // template<> struct char_traits<char8_t>
 
 // static char_type* copy(char_type* s1, const char_type* s2, size_t n);
 

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-8
 
 // <string>
 
 // template<> struct char_traits<char8_t>
 
 // static char_type* move(char_type* s1, const char_type* s2, size_t n);
 
 #include <string>

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <string>
 
 // template<> struct char_traits<wchar_t>
 
 // static char_type* assign(char_type* s, size_t n, char_type a);
 
 #include <string>
 #include <cassert>

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
 // UNSUPPORTED: LIBCXX-DEBUG-FIXME
 
 // <string>
 
 // template<> struct char_traits<wchar_t>
 
 // static char_type* copy(char_type* s1, const char_type* s2, size_t n);
 

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <string>
 
 // template<> struct char_traits<wchar_t>
 
 // static char_type* move(char_type* s1, const char_type* s2, size_t n);
 
 #include <string>
 #include <cassert>

libcxx/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // binary_negate
 //  deprecated in C++17
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {

libcxx/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // not1
 //  deprecated in C++17
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {

libcxx/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // not2
 //  deprecated in C++17
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {

libcxx/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // unary_negate
 //  deprecated in C++17
 
-// UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     static constexpr pointer allocate(allocator_type& a, size_type n, const_void_pointer hint);
 //     ...
 // };

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     template <class Ptr, class... Args>
 //     static constexpr void construct(allocator_type& a, Ptr p, Args&&... args);
 //     ...

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     template <class Ptr>
 //     static constexpr void destroy(allocator_type& a, Ptr p);
 //     ...

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: clang-8
-
 // <memory>
 
 // allocator:
 // constexpr T* allocate(size_t n);
 
 #include <memory>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t

libcxx/test/std/utilities/memory/default.allocator/allocator_types.deprecated_in_cxx17.verify.cpp

 //     typedef typename add_lvalue_reference<const T>::type const_reference;
 //
 //     template <class U> struct rebind {typedef allocator<U> other;};
 // ...
 // };
 
 // REQUIRES: c++17
 
-// Clang 6 does not handle the deprecated attribute on template members properly,
-// so the rebind<int> check below fails.
-// UNSUPPORTED: clang-6
-
 #include <memory>
 
 int main(int, char**) {
     {
         typedef std::allocator<char>::pointer Pointer;                  // expected-warning {{'pointer' is deprecated}}
         typedef std::allocator<char>::const_pointer ConstPointer;       // expected-warning {{'const_pointer' is deprecated}}
         typedef std::allocator<char>::reference Reference;              // expected-warning {{'reference' is deprecated}}
         typedef std::allocator<char>::const_reference ConstReference;   // expected-warning {{'const_reference' is deprecated}}

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/construct_at.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// constexpr destructors are only supported starting with clang 10
-// UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9
 
 // Investigation needed
-// UNSUPPORTED: gcc
+// XFAIL: gcc
 
 // <memory>
 
 // template <class T, class ...Args>
 // constexpr T* construct_at(T* location, Args&& ...args);
 
 #include <memory>
 #include <cassert>

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// constexpr destructors are only supported starting with clang 10
-// UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9
 
 // <memory>
 
 // template <class ForwardIt>
 // constexpr void destroy(ForwardIt, ForwardIt);
 
 #include <memory>
 #include <cassert>

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// constexpr destructors are only supported starting with clang 10
-// UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9
 
 // <memory>
 
 // template <class T>
 // constexpr void destroy_at(T*);
 
 #include <memory>
 #include <cassert>

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// constexpr destructors are only supported starting with clang 10
-// UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9
 
 // <memory>
 
 // template <class ForwardIt, class Size>
 // constexpr ForwardIt destroy_n(ForwardIt, Size s);
 
 #include <memory>
 #include <cassert>

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_arrow.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// Clang doesn't support filename wildcards in verify tests until 05eedf1f5b44.
-// UNSUPPORTED: clang-10
-
 // shared_ptr
 
 // element_type& operator[](ptrdiff_t i) const;
 
 #include "test_macros.h"
 
 #include <memory>
 #include <cassert>

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bracket.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// Clang doesn't support filename wildcards in verify tests until 05eedf1f5b44.
-// UNSUPPORTED: clang-10
-
 // shared_ptr
 
 // element_type& operator[](ptrdiff_t i) const;
 
 #include "test_macros.h"
 
 #include <memory>
 #include <cassert>
 
 int main(int, char**) {
   // Check that we get a static assertion when we try to use the bracket
   // operator on shared_ptr<T> when T is not an array type.
   const std::shared_ptr<int> p;
   (void)p[0]; // expected-error@*:* {{std::shared_ptr<T>::operator[] is only valid when T is an array type.}}
   return 0;
 }

libcxx/test/std/utilities/meta/meta.rel/is_base_of_union.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_base_of
 
 #include <type_traits>
 
 #include "test_macros.h"
 
-//  Clang before v9 and apple-clang up to and including v11 do not
-//  report that unions are never base classes - nor can they have bases.
-//  See https://reviews.llvm.org/D61858
-// XFAIL: apple-clang-9.0, apple-clang-9.1, apple-clang-10.0, apple-clang-11.0.0
-// XFAIL: clang-4.0, clang-5.0, clang-6.0, clang-7.0, clang-8.0
-
-
 template <class T, class U>
 void test_is_base_of()
 {
     static_assert((std::is_base_of<T, U>::value), "");
     static_assert((std::is_base_of<const T, U>::value), "");
     static_assert((std::is_base_of<T, const U>::value), "");
     static_assert((std::is_base_of<const T, const U>::value), "");
 #if TEST_STD_VER > 14

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-4, clang-5, apple-clang
 
 // type_traits
 
 // has_unique_object_representations
 
 #include <type_traits>
 
 #include "test_macros.h"

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_trivially_copyable
 
-// These compilers have not implemented Core 2094 which makes volatile
+// GCC has not implemented Core 2094 which makes volatile
 // qualified types trivially copyable.
-// XFAIL: clang-4, apple-clang-9.0, gcc
+// XFAIL: gcc
 
 #include <type_traits>
 #include <cassert>
 #include "test_macros.h"
 
 template <class T>
 void test_is_trivially_copyable()
 {

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: apple-clang-9
 
 // type_traits
 
 // is_trivially_destructible
 
 // Prevent warning when testing the Abstract test type.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wdelete-non-virtual-dtor"

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <optional>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-5
-// Clang 5 will generate bad implicit deduction guides
-//  Specifically, for the copy constructor.
+
+// <optional>
 
 // template<class T>
 //   optional(T) -> optional<T>;
 
 #include <optional>
 #include <cassert>
 
 struct A {};
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
 
 //  Test the implicit deduction guides
     {
 //  optional()
-    std::optional opt;   // expected-error-re {{{{declaration of variable 'opt' with deduced type 'std::optional' requires an initializer|no viable constructor or deduction guide for deduction of template arguments of 'optional'}}}}
-//  clang-6 gives a bogus error here:
-//      declaration of variable 'opt' with deduced type 'std::optional' requires an initializer
-//  clang-7 (and later) give a better message:
-//      no viable constructor or deduction guide for deduction of template arguments of 'optional'
-//  So we check for one or the other.
+    std::optional opt;   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'optional'}}
     }
 
     {
 //  optional(nullopt_t)
     std::optional opt(std::nullopt);   // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
     }
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <optional>
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: clang-5, apple-clang-9
-// Clang 5 will generate bad implicit deduction guides
-//  Specifically, for the copy constructor.
 
 // template<class T>
 //   optional(T) -> optional<T>;
 
 #include <optional>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/utilities/time/time.hms/hhmmss.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: apple-clang-9
+
 // <chrono>
 
 // template <class Duration> class hh_mm_ss;
 //   If Duration is not an instance of duration, the program is ill-formed.
 
 #include <chrono>
 #include <string>
 #include <cassert>

libcxx/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-5, clang-6
-// UNSUPPORTED: apple-clang-9, apple-clang-10
 
 // <chrono>
 // class day;
 
 // constexpr day operator""d(unsigned long long d) noexcept;
 
 #include <chrono>
 #include <type_traits>

libcxx/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-5, clang-6, clang-7
-// UNSUPPORTED: apple-clang-9, apple-clang-10
 
 // <chrono>
 // class day;
 
 // constexpr day operator""d(unsigned long long d) noexcept;
 
 #include <chrono>
 #include <type_traits>

libcxx/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-5, clang-6
-// UNSUPPORTED: apple-clang-9, apple-clang-10
 
 // <chrono>
 // class year;
 
 // constexpr year operator""y(unsigned long long y) noexcept;
 
 #include <chrono>
 #include <type_traits>

libcxx/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-5, clang-6, clang-7
-// UNSUPPORTED: apple-clang-9, apple-clang-10
 
 // <chrono>
 // class year;
 
 // constexpr year operator""y(unsigned long long y) noexcept;
 
 #include <chrono>
 #include <type_traits>

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/deduct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: apple-clang-9
 
 // GCC's implementation of class template deduction is still immature and runs
 // into issues with libc++. However GCC accepts this code when compiling
 // against libstdc++.
 // XFAIL: gcc-11
 
 // <tuple>
 

libcxxabi/test/test_exception_address_alignment.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 // UNSUPPORTED: c++03
 
 // The <unwind.h> header provided in the SDK of older Xcodes used to provide
 // an incorrectly aligned _Unwind_Exception type on non-ARM. That causes these
 // tests to fail when compiling against such a SDK, or when running against a
 // system libc++abi that was compiled with an incorrect definition of _Unwind_Exception.
 // XFAIL: apple-clang-12.0.0 && !target={{arm.*}}
-// XFAIL: apple-clang-11 && !target={{arm.*}}
-// XFAIL: apple-clang-10 && !target={{arm.*}}
-// XFAIL: apple-clang-9 && !target={{arm.*}}
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // Test that the address of the exception object is properly aligned as required
 // by the relevant ABI
 
 #include <cstdint>
 #include <cassert>
 #include <__cxxabi_config.h>

pstl/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp

for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
         invoke_on_all_policies(test_one_policy<cbi_iterator_type>(data.cbibegin(), std::next(data.cbibegin(), len)),
                                actual.begin(), actual.begin() + len);
     }
 }
 
 int
 main()
 {
-    // clang-3.8 fails to correctly auto vectorize the loop in some cases of different types of container's elements,
-    // for example: int32_t and int8_t. This issue isn't detected for clang-3.9 and newer versions.
     test<int16_t, int8_t>();
     test<uint16_t, float32_t>();
     test<float64_t, int64_t>();
     test<wrapper<float64_t>, wrapper<float64_t>>();
 
     std::cout << done() << std::endl;
     return 0;
 }