[libc++] Remove more test-suite workarounds for unsupported GCC versions

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp

 #include <type_traits>
 #include <functional>
 #include <memory>
 #include <utility>
 #include "test_macros.h"
 
 // Ignore warnings about volatile in parameters being deprecated.
 // We know it is, but we still have to test it.
-#if defined(__GNUC__) && (__GNUC__ >= 10) && !defined(__clang__)
+#if defined(TEST_COMPILER_GCC)
 #   pragma GCC diagnostic ignored "-Wvolatile"
 #endif
 
 struct wat
 {
     wat& operator*() { return *this; }
     void foo();
 };

libcxx/test/std/utilities/variant/variant.get/get_index.pass.cpp

 #include <type_traits>
 #include <utility>
 #include <variant>
 
 void test_const_lvalue_get() {
   {
     using V = std::variant<int, const long>;
     constexpr V v(42);
-#ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
-    ASSERT_NOEXCEPT(std::get<0>(v));
-#else
     ASSERT_NOT_NOEXCEPT(std::get<0>(v));
-#endif
     ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     static_assert(std::get<0>(v) == 42, "");
   }
   {
     using V = std::variant<int, const long>;
     const V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<0>(v));
     ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     assert(std::get<0>(v) == 42);
   }
   {
     using V = std::variant<int, const long>;
     constexpr V v(42l);
-#ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
-    ASSERT_NOEXCEPT(std::get<1>(v));
-#else
     ASSERT_NOT_NOEXCEPT(std::get<1>(v));
-#endif
     ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
     static_assert(std::get<1>(v) == 42, "");
   }
   {
     using V = std::variant<int, const long>;
     const V v(42l);
     ASSERT_NOT_NOEXCEPT(std::get<1>(v));
     ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);

libcxx/test/std/utilities/variant/variant.get/get_type.pass.cpp

 #include <type_traits>
 #include <utility>
 #include <variant>
 
 void test_const_lvalue_get() {
   {
     using V = std::variant<int, const long>;
     constexpr V v(42);
-#ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
-    ASSERT_NOEXCEPT(std::get<int>(v));
-#else
     ASSERT_NOT_NOEXCEPT(std::get<int>(v));
-#endif
     ASSERT_SAME_TYPE(decltype(std::get<int>(v)), const int &);
     static_assert(std::get<int>(v) == 42, "");
   }
   {
     using V = std::variant<int, const long>;
     const V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<int>(v));
     ASSERT_SAME_TYPE(decltype(std::get<int>(v)), const int &);
     assert(std::get<int>(v) == 42);
   }
   {
     using V = std::variant<int, const long>;
     constexpr V v(42l);
-#ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
-    ASSERT_NOEXCEPT(std::get<const long>(v));
-#else
     ASSERT_NOT_NOEXCEPT(std::get<const long>(v));
-#endif
     ASSERT_SAME_TYPE(decltype(std::get<const long>(v)), const long &);
     static_assert(std::get<const long>(v) == 42, "");
   }
   {
     using V = std::variant<int, const long>;
     const V v(42l);
     ASSERT_NOT_NOEXCEPT(std::get<const long>(v));
     ASSERT_SAME_TYPE(decltype(std::get<const long>(v)), const long &);

libcxx/test/support/test_workarounds.h

 # if _MSC_VER < 1927
 #  define TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE // VSO-117743
 # endif
 # ifndef _MSC_EXTENSIONS
 #  define TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK // VSO-119998
 # endif
 #endif
 
-#if defined(TEST_COMPILER_GCC)
-# if __GNUC__ < 9
-#  define TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT // GCC-87603
-# endif
-#endif
-
 #endif // SUPPORT_TEST_WORKAROUNDS_H

libcxxabi/test/dynamic_cast.pass.cpp

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 #include <cassert>
 
 // This test explicitly tests dynamic cast with types that have inaccessible
 // bases.
 #if defined(__clang__)
 #   pragma clang diagnostic ignored "-Winaccessible-base"
-#elif defined(__GNUC__) && (__GNUC__ >= 10)
+#elif defined(__GNUC__)
 #   pragma GCC diagnostic ignored "-Winaccessible-base"
 #endif
 
 typedef char Pad1[43981];
 typedef char Pad2[34981];
 typedef char Pad3[93481];
 typedef char Pad4[13489];
 typedef char Pad5[81349];

libcxxabi/test/dynamic_cast3.pass.cpp

 //===------------------------- dynamic_cast3.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include "support/timer.h"
 
 // This test explicitly tests dynamic cast with types that have inaccessible
 // bases.
 #if defined(__clang__)
 #   pragma clang diagnostic ignored "-Winaccessible-base"
-#elif defined(__GNUC__) && (__GNUC__ >= 10)
+#elif defined(__GNUC__)
 #   pragma GCC diagnostic ignored "-Winaccessible-base"
 #endif
 
 /*
 
 A1   A2   A3
 
 */

libcxxabi/test/dynamic_cast5.pass.cpp

 //===------------------------- dynamic_cast5.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include "support/timer.h"
 
 // This test explicitly tests dynamic cast with types that have inaccessible
 // bases.
 #if defined(__clang__)
 #   pragma clang diagnostic ignored "-Winaccessible-base"
-#elif defined(__GNUC__) && (__GNUC__ >= 10)
+#elif defined(__GNUC__)
 #   pragma GCC diagnostic ignored "-Winaccessible-base"
 #endif
 
 namespace t1
 {
 
 struct A1
 {

libcxxabi/test/unwind_06.pass.cpp

 //===------------------------- unwind_06.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
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 
 // Suppress diagnostics about deprecated volatile operations
-#if defined(__GNUC__) && (__GNUC__ >= 10) && !defined(__clang__)
+#if defined(__GNUC__) && !defined(__clang__)
 # pragma GCC diagnostic ignored "-Wvolatile"
 #endif
 
 // Compile with -Os to get compiler uses float registers to hold float variables
 
 double get_(int x) { return (double)x; }
 
 double (* volatile get)(int) = get_;