[libc++] Disable pragma system_header in the new testing configuration

[ldionne]

Summary

The new testing configuration did not turn off #pragma system_header,
which means we were not seeing warnings in system headers.

I expect this to start failing on GCC (see the removed comment), but
I'd like to fix the root cause before I ship this.

[ldionne]

Fix a bunch of warnings - I expect there are still some issues.

[ldionne]

Don't enable warnings in system headers for GCC - there's too many to fix for now.

libcxx/include/__config

 
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
 
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
-#if !__EXCEPTIONS
+#if !defined(__EXCEPTIONS)
 #  define _LIBCPP_NO_EXCEPTIONS
 #endif
 
 // Determine if GCC supports relaxed constexpr
 #if !defined(__cpp_constexpr) || __cpp_constexpr < 201304L
 #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR
 #endif
 

 #else
 #  define _LIBCPP_DEPRECATED_WITH_CHAR8_T
 #endif
 
 // Macros to enter and leave a state where deprecation warnings are suppressed.
 #if defined(_LIBCPP_COMPILER_CLANG_BASED) || defined(_LIBCPP_COMPILER_GCC)
 #   define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
         _Pragma("GCC diagnostic push") \
-        _Pragma("GCC diagnostic ignored \"-Wdeprecated\"")
+        _Pragma("GCC diagnostic ignored \"-Wdeprecated\"") \
+        _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
 #   define _LIBCPP_SUPPRESS_DEPRECATED_POP \
         _Pragma("GCC diagnostic pop")
 #else
 #   define _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 #   define _LIBCPP_SUPPRESS_DEPRECATED_POP
 #endif
 
 #if _LIBCPP_STD_VER <= 11

libcxx/include/__hash_table

#endif // _LIBCPP_DEBUG_LEVEL == 2
     }
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
         {return !(__x == __y);}
 
 private:
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator(__next_pointer __node, size_t __bucket,
+    __hash_const_local_iterator(__next_pointer __node_ptr, size_t __bucket,
                                 size_t __bucket_count, const void* __c) _NOEXCEPT
-        : __node_(__node),
+        : __node_(__node_ptr),
           __bucket_(__bucket),
           __bucket_count_(__bucket_count)
         {
             __get_db()->__insert_ic(this, __c);
             if (__node_ != nullptr)
                 __node_ = __node_->__next_;
         }
 #else
     _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator(__next_pointer __node, size_t __bucket,
+    __hash_const_local_iterator(__next_pointer __node_ptr, size_t __bucket,
                                 size_t __bucket_count) _NOEXCEPT
-        : __node_(__node),
+        : __node_(__node_ptr),
           __bucket_(__bucket),
           __bucket_count_(__bucket_count)
         {
             if (__node_ != nullptr)
                 __node_ = __node_->__next_;
         }
 #endif
     template <class, class, class, class> friend class __hash_table;

libcxx/include/__ranges/transform_view.h

class transform_view<_View, _Fn>::__sentinel {
   friend class transform_view<_View, _Fn>::__iterator;
 
   template<bool>
   friend class transform_view<_View, _Fn>::__sentinel;
 
 public:
   __sentinel() = default;
 
-  constexpr explicit __sentinel(sentinel_t<_Base> __end_) : __end_(__end_) {}
+  constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(__end) {}
 
   // Note: `__i` should always be `__sentinel<false>`, but directly using
   // `__sentinel<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
   constexpr __sentinel(__sentinel<!_Const> __i)
     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
     : __end_(_VSTD::move(__i.__end_)) {}
 

libcxx/include/any

static void* __handle(_Action __act, any const * __this,
         case _Action::_Move:
           __move(const_cast<any &>(*__this), *__other);
           return nullptr;
         case _Action::_Get:
             return __get(const_cast<any &>(*__this), __info, __fallback_info);
         case _Action::_TypeInfo:
           return __type_info();
         }
+        _LIBCPP_ASSERT(false && "unreachable");
     }
 
     template <class ..._Args>
     _LIBCPP_INLINE_VISIBILITY
     static _Tp& __create(any & __dest, _Args&&... __args) {
         typedef allocator<_Tp> _Alloc;
         typedef allocator_traits<_Alloc> _ATraits;
         typedef __allocator_destructor<_Alloc> _Dp;

libcxx/include/barrier

 bool __arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier,
                                      __barrier_phase_t __old_phase);
 
 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
 void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier);
 
 template<class _CompletionF>
 class __barrier_base {
-
     ptrdiff_t                                               __expected;
     unique_ptr<__barrier_algorithm_base,
                void (*)(__barrier_algorithm_base*)>         __base;
     __atomic_base<ptrdiff_t>                                __expected_adjustment;
     _CompletionF                                            __completion;
     __atomic_base<__barrier_phase_t>                        __phase;
 
 public:
arrival_token arrive(ptrdiff_t update)
                 __phase.store(__old_phase + 2, memory_order_release);
                 __phase.notify_all();
             }
         return __old_phase;
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void wait(arrival_token&& __old_phase) const
     {
-        auto const __test_fn = [=]() -> bool {
+        auto const __test_fn = [this, __old_phase]() -> bool {
             return __phase.load(memory_order_acquire) != __old_phase;
         };
         __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void arrive_and_drop()
     {
         __expected_adjustment.fetch_sub(1, memory_order_relaxed);

libcxx/include/charconv

 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
     if (__base == 10)
         return __from_chars_atoi(__first, __last, __value);
 
     return __subject_seq_combinator(
         __first, __last, __value,
-        [](const char* __p, const char* __last, _Tp& __value,
+        [](const char* __p, const char* __lastx, _Tp& __value,
            int __base) -> from_chars_result {
             using __tl = numeric_limits<_Tp>;
             auto __digits = __tl::digits / log2f(float(__base));
             _Tp __a = __in_pattern(*__p++, __base).__val, __b = 0;
 
-            for (int __i = 1; __p != __last; ++__i, ++__p)
+            for (int __i = 1; __p != __lastx; ++__i, ++__p)
             {
                 if (auto __c = __in_pattern(*__p, __base))
                 {
                     if (__i < __digits - 1)
                         __a = __a * __base + __c.__val;
                     else
                     {
                         if (!__itoa::__mul_overflowed(__a, __base, __a))
                             ++__p;
                         __b = __c.__val;
                         break;
                     }
                 }
                 else
                     break;
             }
 
-            if (__p == __last || !__in_pattern(*__p, __base))
+            if (__p == __lastx || !__in_pattern(*__p, __base))
             {
                 if (__tl::max() - __a >= __b)
                 {
                     __value = __a + __b;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};

libcxx/include/chrono

 } // chrono
 
 #if _LIBCPP_STD_VER > 11
 // Suffixes for duration literals [time.duration.literals]
 inline namespace literals
 {
   inline namespace chrono_literals
   {
-
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
     constexpr chrono::hours operator""h(unsigned long long __h)
     {
         return chrono::hours(static_cast<chrono::hours::rep>(__h));
     }
 
     constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
     {
         return chrono::duration<long double, ratio<3600,1>>(__h);
constexpr chrono::day operator ""d(unsigned long long __d) noexcept
         return chrono::day(static_cast<unsigned>(__d));
     }
 
     constexpr chrono::year operator ""y(unsigned long long __y) noexcept
     {
         return chrono::year(static_cast<int>(__y));
     }
 #endif
+#pragma GCC diagnostic pop
 }}
 
 namespace chrono { // hoist the literals into namespace std::chrono
    using namespace literals::chrono_literals;
 }
 
 #endif
 

libcxx/include/cmath

 template <typename _Fp>
 constexpr
 _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
     if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
         return __t * __b + (1 - __t) * __a;
 
     if (__t == 1) return __b;
     const _Fp __x = __a + __t * (__b - __a);
-    if (__t > 1 == __b > __a)
+    if ((__t > 1) == (__b > __a))
         return __b < __x ? __x : __b;
     else
         return __x < __b ? __x : __b;
 }
 
 constexpr float
 lerp(float __a, float __b, float __t)                   _NOEXCEPT { return __lerp(__a, __b, __t); }
 

libcxx/include/compare

if (__seen[_None])
     return _None;
   if (__seen[_PartialOrd])
     return _PartialOrd;
   if (__seen[_WeakOrd])
     return _WeakOrd;
   return _StrongOrd;
 }
 
-template <class ..._Ts>
+template <class ..._Ts, bool _False = false>
 constexpr auto __get_comp_type() {
   using _CCC = _ClassifyCompCategory;
   constexpr _CCC __type_kinds[] = {_StrongOrd, __type_to_enum<_Ts>()...};
   constexpr _CCC _Cat = __compute_comp_type(__type_kinds);
   if constexpr (_Cat == _None)
     return void();
   else if constexpr (_Cat == _PartialOrd)
     return partial_ordering::equivalent;
   else if constexpr (_Cat == _WeakOrd)
     return weak_ordering::equivalent;
   else if constexpr (_Cat == _StrongOrd)
     return strong_ordering::equivalent;
   else
-    static_assert(_Cat != _Cat, "unhandled case");
+    static_assert(_False, "unhandled case");
 }
 } // namespace __comp_detail
 
 // [cmp.common], common comparison category type
 template<class... _Ts>
 struct _LIBCPP_TEMPLATE_VIS common_comparison_category {
   using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
 };

libcxx/include/complex

 #endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 #if _LIBCPP_STD_VER > 11
 // Literal suffix for complex number literals [complex.literals]
 inline namespace literals
 {
   inline namespace complex_literals
   {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
     constexpr complex<long double> operator""il(long double __im)
     {
         return { 0.0l, __im };
     }
 
     constexpr complex<long double> operator""il(unsigned long long __im)
     {
         return { 0.0l, static_cast<long double>(__im) };
#pragma GCC diagnostic ignored "-Wliteral-suffix"
     {
         return { 0.0f, static_cast<float>(__im) };
     }
 
     constexpr complex<float> operator""if(unsigned long long __im)
     {
         return { 0.0f, static_cast<float>(__im) };
     }
+#pragma GCC diagnostic pop
   }
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_COMPLEX

libcxx/include/memory

template <class _Alloc, class _Tp, class = typename enable_if<
     (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Tp*, _Tp>::value) &&
     is_trivially_move_constructible<_Tp>::value
 >::type>
 _LIBCPP_INLINE_VISIBILITY
 void __construct_backward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2) {
     ptrdiff_t _Np = __end1 - __begin1;
     __end2 -= _Np;
     if (_Np > 0)
-        _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
+        _VSTD::memcpy(static_cast<void*>(__end2), static_cast<void const*>(__begin1), _Np * sizeof(_Tp));
 }
 
 struct __destruct_n
 {
 private:
     size_t __size_;
 
     template <class _Tp>

libcxx/include/random

static _LIBCPP_CONSTEXPR const bool value =
               !is_same<typename remove_cv<_Sseq>::type, _Engine>::value;
 };
 
 // linear_congruential_engine
 
 template <unsigned long long __a, unsigned long long __c,
           unsigned long long __m, unsigned long long _Mp,
           bool _MightOverflow = (__a != 0 && __m != 0 && __m-1 > (_Mp-__c)/__a),
-          bool _OverflowOK = ((__m|__m-1) > __m), // m = 2^n
+          bool _OverflowOK = ((__m | (__m-1)) > __m), // m = 2^n
           bool _SchrageOK = (__a != 0 && __m != 0 && __m % __a <= __m / __a)> // r <= q
 struct __lce_alg_picker
 {
     static_assert(__a != 0 || __m != 0 || !_MightOverflow || _OverflowOK || _SchrageOK,
                   "The current values of a, c, and m cannot generate a number "
                   "within bounds of linear_congruential_engine.");
 
     static _LIBCPP_CONSTEXPR const bool __use_schrage = _MightOverflow &&

libcxx/include/regex

 }
 
 template <class _CharT>
 class __l_anchor_multiline
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
-    bool __multiline;
+    bool __multiline_;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __l_anchor_multiline(bool __multiline, __node<_CharT>* __s)
-        : base(__s), __multiline(__multiline) {}
+        : base(__s), __multiline_(__multiline) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __l_anchor_multiline<_CharT>::__exec(__state& __s) const
 {
     if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
         !(__s.__flags_ & regex_constants::match_not_bol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
-    else if (__multiline &&
+    else if (__multiline_ &&
              !__s.__at_first_ &&
              __is_eol(*_VSTD::prev(__s.__current_)))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else
     {
if (__first != __last)
             __sum = 16 * __sum + static_cast<unsigned>(__hd);
             ++__first;
             if (__first == __last)
                 __throw_regex_error<regex_constants::error_escape>();
             __hd = __traits_.value(*__first, 16);
             if (__hd == -1)
                 __throw_regex_error<regex_constants::error_escape>();
             __sum = 16 * __sum + static_cast<unsigned>(__hd);
-            // drop through
+            // fallthrough
         case 'x':
             ++__first;
             if (__first == __last)
                 __throw_regex_error<regex_constants::error_escape>();
             __hd = __traits_.value(*__first, 16);
             if (__hd == -1)
                 __throw_regex_error<regex_constants::error_escape>();
             __sum = 16 * __sum + static_cast<unsigned>(__hd);

libcxx/include/semaphore

void release(ptrdiff_t __update = 1)
         else if(__update > 1)
             __a.notify_all();
         else
             __a.notify_one();
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void acquire()
     {
-        auto const __test_fn = [=]() -> bool {
+        auto const __test_fn = [this]() -> bool {
             auto __old = __a.load(memory_order_relaxed);
             return (__old != 0) && __a.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed);
         };
         __cxx_atomic_wait(&__a.__a_, __test_fn);
     }
     template <class Rep, class Period>
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
     {
-        auto const __test_fn = [=]() -> bool {
+        auto const __test_fn = [this]() -> bool {
             auto __old = __a.load(memory_order_acquire);
             while(1) {
                 if (__old == 0)
                     return false;
                 if(__a.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed))
                     return true;
             }
         };

libcxx/include/string

 #endif // _LIBCPP_DEBUG_LEVEL == 2
 
 #if _LIBCPP_STD_VER > 11
 // Literal suffixes for basic_string [basic.string.literals]
 inline namespace literals
 {
   inline namespace string_literals
   {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<char> operator "" s( const char *__str, size_t __len )
     {
         return basic_string<char> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
         return basic_string<char16_t> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
     {
         return basic_string<char32_t> (__str, __len);
     }
+#pragma GCC diagnostic pop
   }
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_STRING

libcxx/include/string_view

 };
 
 
 #if _LIBCPP_STD_VER > 11
 inline namespace literals
 {
   inline namespace string_view_literals
   {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     basic_string_view<char> operator "" sv(const char *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     basic_string_view<wchar_t> operator "" sv(const wchar_t *__str, size_t __len) _NOEXCEPT
basic_string_view<char16_t> operator "" sv(const char16_t *__str, size_t __len) _NOEXCEPT
         return basic_string_view<char16_t> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     basic_string_view<char32_t> operator "" sv(const char32_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char32_t> (__str, __len);
     }
+#pragma GCC diagnostic pop
   }
 }
 #endif
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_STRING_VIEW

libcxx/include/vector

#endif
     bool __invariants() const;
 
 private:
     _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
     void __vallocate(size_type __n);
     void __vdeallocate() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     static size_type __align_it(size_type __new_size) _NOEXCEPT
-        {return __new_size + (__bits_per_word-1) & ~((size_type)__bits_per_word-1);}
+        {return __new_size + ((__bits_per_word-1) & ~((size_type)__bits_per_word-1));}
     _LIBCPP_INLINE_VISIBILITY  size_type __recommend(size_type __new_size) const;
     _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x);
     template <class _ForwardIterator>
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type

libcxx/utils/libcxx/test/config.py

def configure_default_compile_flags(self):
         # being elided.
         if self.target_info.is_windows() and self.debug_build:
             self.cxx.compile_flags += ['-D_DEBUG']
 
         # Add includes for support headers used in the tests.
         support_path = os.path.join(self.libcxx_src_root, 'test/support')
         self.cxx.compile_flags += ['-I' + support_path]
 
-        # On GCC, the libc++ headers cause errors due to throw() decorators
-        # on operator new clashing with those from the test suite, so we
-        # don't enable warnings in system headers on GCC.
-        if self.cxx.type != 'gcc':
-            self.cxx.compile_flags += ['-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER']
-
         # Add includes for the PSTL headers
         pstl_src_root = self.get_lit_conf('pstl_src_root')
         pstl_obj_root = self.get_lit_conf('pstl_obj_root')
         if pstl_src_root is not None and pstl_obj_root is not None:
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_src_root, 'include')]
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_obj_root, 'generated_headers')]
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_src_root, 'test')]
             self.config.available_features.add('parallel-algorithms')

libcxx/utils/libcxx/test/params.py

Parameter(name='enable_rtti', choices=[True, False], type=bool, default=True,
             help="Whether to enable RTTI when compiling the test suite.",
             actions=lambda rtti: [] if rtti else [
               AddFeature('no-rtti'),
               AddCompileFlag('-fno-rtti')
             ]),
 
   Parameter(name='stdlib', choices=['libc++', 'libstdc++', 'msvc'], type=str, default='libc++',
             help="The C++ Standard Library implementation being tested.",
-            actions=lambda stdlib: [
-              AddFeature(stdlib)
-            ]),
+            actions=lambda stdlib: filter(None, [
+              AddFeature(stdlib),
+              AddCompileFlag('-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER') if stdlib == 'libc++' else None
+            ])),
 
   Parameter(name='enable_warnings', choices=[True, False], type=bool, default=True,
             help="Whether to enable warnings when compiling the test suite.",
             actions=lambda warnings: [] if not warnings else [
               AddOptionalWarningFlag(w) for w in _warningFlags
             ]),
 
   Parameter(name='debug_level', choices=['', '0', '1'], type=str, default='',