On Sat, 6 Dec 2025 at 09:47, Jakub Jelinek <[email protected]> wrote: > > Hi! > > Sorry, testing the last posted version of the patch revealed a forgotten > hunk in the testsuite (testsuite_shared.cc) which broke the whole libstdc++ > testing. > > This version has that hunk removed/ChangeLog adjusted and passed > bootstrap/regtest on x86_64-linux and i686-linux.
OK, thanks > > 2025-12-06 Jakub Jelinek <[email protected]> > > PR libstdc++/121114 > libstdc++-v3/ > * include/bits/version.def: Implement C++26 P3378R2 - constexpr > exception types. > (constexpr_exceptions): Change value from 1 to 202502, remove > no_stdname and TODO comments. > * include/bits/version.h: Regenerate. > * src/c++11/cow-stdexcept.cc (__cow_string(const char*)): New > ctor. > (__cow_string::c_str()): New method. > * config/abi/pre/gnu.ver (GLIBCXX_3.4.35): Export 8 __cow_string > symbols. > * include/bits/new_except.h: New file. > * include/bits/new_throw.h: New file. > * include/bits/stexcept_throw.h: New file. > * include/bits/stexcept_throwdef.h: New file. > * include/bits/stexcept_throwfwd.h: New file. > * include/std/stdexcept: Include bits/stdexcept_except.h and move > everything after <string> include except for std::range_error into > include/bits/stdexcept_except.h. > (std::range_error): If __cpp_lib_constexpr_exceptions >= 202502L > make all cdtors and methods constexpr. > * include/bits/stdexcept_except.h: New file. > * include/std/optional (__glibcxx_want_constexpr_exceptions): Define > before including bits/version.h. > (bad_optional_access::what): Make constexpr for > __cpp_lib_constexpr_exceptions >= 202502L. > (__throw_bad_optional_access): Likewise. > * include/std/expected (__glibcxx_want_constexpr_exceptions): Define > before including bits/version.h. > (bad_expected_access): Make cdtors and all methods constexpr for > __cpp_lib_constexpr_exceptions >= 202502L. > * include/std/format (__glibcxx_want_constexpr_exceptions): Define > before including bits/version.h. > (_GLIBCXX_CONSTEXPR_FORMAT_ERROR): Define and undef later. > (format_error): Use _GLIBCXX_CONSTEXPR_FORMAT_ERROR on ctors. > * include/std/variant (__glibcxx_want_constexpr_exceptions): Define > before including bits/version.h. > (_GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS): Define and undef later. > (bad_variant_access): Use it on ctors and what() method. > (__throw_bad_variant_access): Use it here too. > * testsuite/18_support/exception/version.cc: Adjust expected > __cpp_lib_constexpr_exceptions value. > * testsuite/19_diagnostics/runtime_error/constexpr.cc: New test. > * testsuite/19_diagnostics/headers/stdexcept/version.cc: New test. > * testsuite/19_diagnostics/logic_error/constexpr.cc: New test. > * testsuite/20_util/expected/observers.cc (test_value_throw): Change > return type to bool from void, return true at the end, add test > to dereference what() first character. Make it constexpr for > __cpp_lib_constexpr_exceptions >= 202502L and add static_assert. > * testsuite/20_util/expected/version.cc: Add tests for > __cpp_lib_constexpr_exceptions value. > * testsuite/20_util/variant/constexpr.cc: For > __cpp_lib_constexpr_exceptions >= 202502L include <string>. > (test_get): New function if __cpp_lib_constexpr_exceptions >= 202502L, > assert calling it is true. > * testsuite/20_util/variant/version.cc: Add tests for > __cpp_lib_constexpr_exceptions value. > * testsuite/20_util/optional/constexpr/observers/3.cc: Include > testsuite_hooks.h. > (eat, test01): New functions. Assert test01() is true. > * testsuite/20_util/optional/version.cc: Add tests for > __cpp_lib_constexpr_exceptions value. > * include/std/future: Add #include <bits/functexcept.h>. > * include/std/shared_mutex: Include <bits/new_throw.h>. > * include/std/flat_map: Include <bits/stdexcept_throw.h> instead of > <bits/functexcept.h>. > * include/std/syncstream: Remove <bits/functexcept.h> include. > * include/std/flat_set: Likewise. > * include/std/bitset: Include <bits/stdexcept_throw.h> instead of > <bits/functexcept.h>. > * include/std/string_view: Don't include <bits/functexcept.h>, include > <bits/stdexcept_throw.h> early if __glibcxx_exc_in_string is not > defined and include <bits/stdexcept_throw.h> at the end of > the header again if __glibcxx_exc_in_string is 2 and C++26 constexpr > exceptions are enabled. > (__glibcxx_exc_in_string): Define if __glibcxx_exc_in_string wasn't > defined before including <bits/stdexcept_throw.h>. > * include/std/array: Include <bits/stdexcept_throw.h> instead of > <bits/functexcept.h>. > * include/std/inplace_vector: Likewise. > * include/std/string: Include <bits/stdexcept_except.h> and > <bits/stdexcept_throw.h> after bits/basic_string.tcc include if > C++26 constexpr exceptions are enabled and include > <bits/stdexcept_throw.h> instead of <bits/functexcept.h> early. > (__glibcxx_exc_in_string): Define early to 1, undefine at the end. > * include/std/deque: Include <bits/stdexcept_throw.h>. > * include/bits/new_allocator.h: Include <bits/new_throw.h> instead > of <bits/functexcept.h>. > * include/bits/stl_algobase.h: Remove <bits/functexcept.h> include. > * include/bits/stl_vector.h: Include <bits/stdexcept_throw.h> instead > of <bits/functexcept.h>. > * include/bits/memory_resource.h: Include <bits/new_throw.h> instead > of <bits/functexcept.h>. > * include/bits/functexcept.h: Guard everything after includes with > #if _GLIBCXX_HOSTED. > (__throw_bad_alloc, __throw_bad_array_new_length, > __throw_logic_error, > __throw_domain_error, __throw_invalid_argument, __throw_length_error, > __throw_out_of_range, __throw_out_of_range_fmt, __throw_runtime_error, > __throw_overflow_error, __throw_underflow_error): Move declarations to > other headers - <bits/new_throw.h> and <bits/stdexcept_throwfwd.h>. > * include/bits/stl_map.h: Include <bits/stdexcept_throw.h> instead > of <bits/functexcept.h>. > * include/bits/hashtable_policy.h: Include <bits/stdexcept_throw.h> > instead of <bits/functexcept.h>. > * include/bits/formatfwd.h (std::__throw_format_error): Remove > declaration. > * include/bits/specfun.h: Include <bits/stdexcept_throw.h> instead of > <bits/functexcept.h>. > * include/tr1/cmath: Include <bits/stdexcept_throw.h> instead of > <bits/functexcept.h>. > * include/tr1/memory: Remove <bits/functexcept.h> include. > * include/tr1/array: Include <bits/stdexcept_throw.h>. > * include/ext/vstring_util.h: Include <bits/stdexcept_throw.h> instead > of <bits/functexcept.h>. > * include/ext/bitmap_allocator.h: Include <bits/new_throw.h> instead > of <bits/functexcept.h>. > * include/ext/mt_allocator.h: Likewise. > * include/ext/malloc_allocator.h: Likewise. > * include/ext/debug_allocator.h: Include <bits/stdexcept_throw.h> > instead of <bits/functexcept.h>. > * include/ext/concurrence.h: Include <bits/exception_defines.h> > instead of <bits/functexcept.h>. > * include/ext/throw_allocator.h: Include <bits/new_throw.h> and > <bits/stdexcept_throw.h> instead of <bits/functexcept.h>. > * include/ext/string_conversions.h: Include <bits/stdexcept_throw.h> > instead of <bits/functexcept.h>. > * include/ext/pool_allocator.h: Include <bits/new_throw.h> instead > of <bits/functexcept.h>. > * include/ext/ropeimpl.h: Include <bits/stdexcept_throw.h> instead of > <bits/functexcept.h>. > * include/tr2/dynamic_bitset: Likewise. > * include/experimental/optional: Include <bits/exception_defines.h> > instead of <bits/functexcept.h>. > * include/Makefile.am (bits_freestanding): Add > ${bits_srcdir}/{new,stdexcept}_{except,throw}.h > and ${bits_srcdir}/stdexcept_throw{fwd,def}.h. > * include/Makefile.in: Regenerate. > * src/c++17/floating_from_chars.cc: Remove <bits/functexcept.h> > include. > * src/c++11/regex.cc: Likewise. > * src/c++11/functexcept.cc: Likewise. > * src/c++11/snprintf_lite.cc: Include <bits/stdexcept_throw.h> instead > of <bits/functexcept.h>. > * src/c++11/thread.cc: Include <bits/functexcept.h>. > * testsuite/util/testsuite_hooks.h: Include <bits/stdexcept_throw.h> > instead of <bits/functexcept.h>. > * testsuite/util/io/verified_cmd_line_input.cc: Include > <bits/exception_defines.h> instead of <bits/functexcept.h>. > * testsuite/20_util/allocator/105975.cc: Expect different diagnostics > for C++26. > * testsuite/23_containers/inplace_vector/access/capacity.cc: Remove > #error, guard if consteval { return; } with > #ifndef __cpp_lib_constexpr_exceptions. > * testsuite/23_containers/inplace_vector/access/elem.cc: Likewise. > * testsuite/23_containers/inplace_vector/cons/1.cc: Likewise. > * testsuite/23_containers/inplace_vector/cons/from_range.cc: Likewise. > * testsuite/23_containers/inplace_vector/modifiers/single_insert.cc: > Likewise. > * testsuite/23_containers/inplace_vector/modifiers/assign.cc: > Likewise. > * testsuite/23_containers/inplace_vector/modifiers/multi_insert.cc: > Likewise. > * libsupc++/new: Include <bits/new_except.h>. > (std::bad_alloc, std::bad_array_new_length): Move defintion to > <bits/new_except.h>. > libgomp/ > * omp.h.in: Include <bits/new_throw.h> instead of > <bits/functexcept.h>. > gcc/testsuite/ > * g++.dg/tree-ssa/pr110819.C: Guard scan-tree-dump-not delete on > c++23_down and add comment explaining why C++26 fails that. > * g++.dg/tree-ssa/pr96945.C: Likewise. > * g++.dg/tree-ssa/pr109442.C: Likewise. > * g++.dg/tree-ssa/pr116868.C: Likewise. > * g++.dg/tree-ssa/pr58483.C: Likewise. > > --- libstdc++-v3/include/bits/version.def.jj 2025-12-03 17:33:41.079761702 > +0100 > +++ libstdc++-v3/include/bits/version.def 2025-12-04 15:09:31.589988034 > +0100 > @@ -2192,10 +2192,8 @@ ftms = { > > ftms = { > name = constexpr_exceptions; > - // TODO Remove when PR121114 is resolved > - no_stdname = true; > values = { > - v = 1; // TODO 202411; > + v = 202502; > cxxmin = 26; > extra_cond = "__cpp_constexpr_exceptions >= 202411L"; > }; > --- libstdc++-v3/include/bits/version.h.jj 2025-12-03 17:33:41.079761702 > +0100 > +++ libstdc++-v3/include/bits/version.h 2025-12-04 15:09:31.590382364 +0100 > @@ -2457,8 +2457,9 @@ > > #if !defined(__cpp_lib_constexpr_exceptions) > # if (__cplusplus > 202302L) && (__cpp_constexpr_exceptions >= 202411L) > -# define __glibcxx_constexpr_exceptions 1L > +# define __glibcxx_constexpr_exceptions 202502L > # if defined(__glibcxx_want_all) || > defined(__glibcxx_want_constexpr_exceptions) > +# define __cpp_lib_constexpr_exceptions 202502L > # endif > # endif > #endif /* !defined(__cpp_lib_constexpr_exceptions) */ > --- libstdc++-v3/src/c++11/cow-stdexcept.cc.jj 2025-09-06 11:18:17.997614418 > +0200 > +++ libstdc++-v3/src/c++11/cow-stdexcept.cc 2025-12-04 15:09:31.610396082 > +0100 > @@ -126,18 +126,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > __cow_string(); > __cow_string(const std::string& s); > + __cow_string(const char*); > __cow_string(const char*, size_t n); > __cow_string(const __cow_string&) noexcept; > __cow_string& operator=(const __cow_string&) noexcept; > ~__cow_string(); > __cow_string(__cow_string&&) noexcept; > __cow_string& operator=(__cow_string&&) noexcept; > + const char* c_str() const noexcept; > }; > > __cow_string::__cow_string() : _M_str() { } > > __cow_string::__cow_string(const std::string& s) : _M_str(s) { } > > + __cow_string::__cow_string(const char* s) : _M_str(s) { } > + > __cow_string::__cow_string(const char* s, size_t n) : _M_str(s, n) { } > > __cow_string::__cow_string(const __cow_string& s) noexcept > @@ -162,6 +166,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > return *this; > } > > + const char* > + __cow_string::c_str() const noexcept > + { > + return _M_str.c_str(); > + } > + > static_assert(sizeof(__cow_string) == sizeof(std::string), > "sizeof(std::string) has changed"); > static_assert(alignof(__cow_string) == alignof(std::string), > --- libstdc++-v3/config/abi/pre/gnu.ver.jj 2025-11-27 11:54:20.658258327 > +0100 > +++ libstdc++-v3/config/abi/pre/gnu.ver 2025-12-04 15:09:31.621395890 +0100 > @@ -2576,6 +2576,16 @@ GLIBCXX_3.4.35 { > > _ZN11__gnu_debug25_Safe_local_iterator_base16_M_attach_singleEPKNS_30_Safe_unordered_container_baseEb; > _ZNK11__gnu_debug30_Safe_unordered_container_base13_M_detach_allEv; > _ZNK11__gnu_debug30_Safe_unordered_container_base7_M_swapERKS0_; > + > + # std::__cow_string > + _ZNSt12__cow_stringC2EPKc; > + _ZNSt12__cow_stringC2EPKc[jmy]; > + _ZNSt12__cow_stringC2ERKS_; > + _ZNSt12__cow_stringC2EOS_; > + _ZNSt12__cow_stringD2Ev; > + _ZNSt12__cow_stringaSERKS_; > + _ZNSt12__cow_stringaSEOS_; > + _ZNKSt12__cow_string5c_strEv; > } GLIBCXX_3.4.34; > > # Symbols in the support library (libsupc++) have their own tag. > --- libstdc++-v3/include/bits/new_except.h.jj 2025-12-04 15:09:31.622719777 > +0100 > +++ libstdc++-v3/include/bits/new_except.h 2025-12-04 18:08:51.486144411 > +0100 > @@ -0,0 +1,110 @@ > +// Exception classes for <new> -*- C++ -*- > + > +// Copyright (C) 2001-2025 Free Software Foundation, Inc. > +// > +// This file is part of the GNU ISO C++ Library. This library is free > +// software; you can redistribute it and/or modify it under the > +// terms of the GNU General Public License as published by the > +// Free Software Foundation; either version 3, or (at your option) > +// any later version. > + > +// This library is distributed in the hope that it will be useful, > +// but WITHOUT ANY WARRANTY; without even the implied warranty of > +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +// GNU General Public License for more details. > + > +// Under Section 7 of GPL version 3, you are granted additional > +// permissions described in the GCC Runtime Library Exception, version > +// 3.1, as published by the Free Software Foundation. > + > +// You should have received a copy of the GNU General Public License and > +// a copy of the GCC Runtime Library Exception along with this program; > +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +// <http://www.gnu.org/licenses/>. > + > +/** @file bits/new_except.h > + * This is an internal header file, included by other library headers. > + * Do not attempt to use it directly. @headername{new} > + */ > + > +// > +// ISO C++ 14882: 19.1 Exception classes > +// > + > +#ifndef _NEW_EXCEPT_H > +#define _NEW_EXCEPT_H 1 > + > +#include <bits/c++config.h> > +#include <bits/exception_defines.h> > +#include <bits/exception.h> > + > +extern "C++" > +{ > + > +namespace std _GLIBCXX_VISIBILITY(default) > +{ > +_GLIBCXX_BEGIN_NAMESPACE_VERSION > + > + /** > + * @brief Exception possibly thrown by @c new. > + * @ingroup exceptions > + * > + * @c bad_alloc (or classes derived from it) is used to report allocation > + * errors from the throwing forms of @c new. */ > + class bad_alloc : public exception > + { > + public: > + _GLIBCXX26_CONSTEXPR bad_alloc() throw() { } > + > +#if __cplusplus >= 201103L > + _GLIBCXX26_CONSTEXPR bad_alloc(const bad_alloc&) = default; > + _GLIBCXX26_CONSTEXPR bad_alloc& operator=(const bad_alloc&) = default; > +#endif > + > +#if __cplusplus >= 202400L > + constexpr virtual ~bad_alloc() noexcept {} > + > + constexpr virtual const char* what() const noexcept > + { > + return "std::bad_alloc"; > + } > +#else > + // This declaration is not useless: > + // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 > + virtual ~bad_alloc() throw(); > + > + // See comment in eh_exception.cc. > + virtual const char* what() const throw(); > +#endif > + }; > + > +#if __cplusplus >= 201103L > + class bad_array_new_length : public bad_alloc > + { > + public: > + _GLIBCXX26_CONSTEXPR bad_array_new_length() throw() { } > + > +#if __cplusplus >= 202400L > + constexpr virtual ~bad_array_new_length() noexcept {} > + > + constexpr virtual const char* what() const noexcept > + { > + return "std::bad_array_new_length"; > + } > +#else > + // This declaration is not useless: > + // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 > + virtual ~bad_array_new_length() throw(); > + > + // See comment in eh_exception.cc. > + virtual const char* what() const throw(); > +#endif > + }; > +#endif > + > +_GLIBCXX_END_NAMESPACE_VERSION > +} // namespace > + > +} > + > +#endif > --- libstdc++-v3/include/bits/new_throw.h.jj 2025-12-04 15:09:31.622832661 > +0100 > +++ libstdc++-v3/include/bits/new_throw.h 2025-12-04 18:09:00.031995707 > +0100 > @@ -0,0 +1,76 @@ > +// Function-Based Exception Support -*- C++ -*- > + > +// Copyright (C) 2001-2025 Free Software Foundation, Inc. > +// > +// This file is part of the GNU ISO C++ Library. This library is free > +// software; you can redistribute it and/or modify it under the > +// terms of the GNU General Public License as published by the > +// Free Software Foundation; either version 3, or (at your option) > +// any later version. > + > +// This library is distributed in the hope that it will be useful, > +// but WITHOUT ANY WARRANTY; without even the implied warranty of > +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +// GNU General Public License for more details. > + > +// Under Section 7 of GPL version 3, you are granted additional > +// permissions described in the GCC Runtime Library Exception, version > +// 3.1, as published by the Free Software Foundation. > + > +// You should have received a copy of the GNU General Public License and > +// a copy of the GCC Runtime Library Exception along with this program; > +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +// <http://www.gnu.org/licenses/>. > + > +/** @file bits/new_throw.h > + * This is an internal header file, included by other library headers. > + * Do not attempt to use it directly. @headername{new} > + */ > + > +// > +// ISO C++ 14882: 19.1 Exception classes > +// > + > +#ifndef _NEW_THROW_H > +#define _NEW_THROW_H 1 > + > +#include <bits/c++config.h> > +#include <bits/exception_defines.h> > +#if (_GLIBCXX_HOSTED && __cpp_exceptions && __cplusplus > 202302L \ > + && __cpp_constexpr_exceptions >= 202411L) > +#include <bits/new_except.h> > +#endif > + > +namespace std _GLIBCXX_VISIBILITY(default) > +{ > +_GLIBCXX_BEGIN_NAMESPACE_VERSION > + > +#if _GLIBCXX_HOSTED > +#if (__cpp_exceptions && __cplusplus > 202302L \ > + && __cpp_constexpr_exceptions >= 202411L) > + // Helper for exception objects in <new> > + [[noreturn, __gnu__::__always_inline__]] constexpr void > + __throw_bad_alloc(void) > + { > + throw bad_alloc(); > + } > + > + [[noreturn, __gnu__::__always_inline__]] constexpr void > + __throw_bad_array_new_length(void) > + { > + throw bad_array_new_length(); > + } > +#else > + // Helper for exception objects in <new> > + void > + __throw_bad_alloc(void) __attribute__((__noreturn__)); > + > + void > + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); > +#endif > +#endif // HOSTED > + > +_GLIBCXX_END_NAMESPACE_VERSION > +} // namespace > + > +#endif > --- libstdc++-v3/include/bits/stdexcept_except.h.jj 2025-12-04 > 15:09:31.622929661 +0100 > +++ libstdc++-v3/include/bits/stdexcept_except.h 2025-12-04 > 18:06:56.738141082 +0100 > @@ -0,0 +1,552 @@ > +// Exception classes for <stdexcept> -*- C++ -*- > + > +// Copyright (C) 2001-2025 Free Software Foundation, Inc. > +// > +// This file is part of the GNU ISO C++ Library. This library is free > +// software; you can redistribute it and/or modify it under the > +// terms of the GNU General Public License as published by the > +// Free Software Foundation; either version 3, or (at your option) > +// any later version. > + > +// This library is distributed in the hope that it will be useful, > +// but WITHOUT ANY WARRANTY; without even the implied warranty of > +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +// GNU General Public License for more details. > + > +// Under Section 7 of GPL version 3, you are granted additional > +// permissions described in the GCC Runtime Library Exception, version > +// 3.1, as published by the Free Software Foundation. > + > +// You should have received a copy of the GNU General Public License and > +// a copy of the GCC Runtime Library Exception along with this program; > +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +// <http://www.gnu.org/licenses/>. > + > +/** @file bits/stdexcept_except.h > + * This is an internal header file, included by other library headers. > + * Do not attempt to use it directly. @headername{stdexcept} */ > + > +#ifndef _STDEXCEPT_EXCEPT_H > +#define _STDEXCEPT_EXCEPT_H 1 > + > +#include <exception> > +#include <string> > + > +namespace std _GLIBCXX_VISIBILITY(default) > +{ > +_GLIBCXX_BEGIN_NAMESPACE_VERSION > + > +#if _GLIBCXX_USE_DUAL_ABI > +#if _GLIBCXX_USE_CXX11_ABI > +#if __cpp_lib_constexpr_exceptions >= 202502L > + struct __cow_constexpr_string; > + namespace __detail > + { > + extern "C" > + { > + void _ZNSt12__cow_stringC2EPKcm(__cow_constexpr_string*, const char*, > + unsigned long); > + void _ZNSt12__cow_stringC2EPKcj(__cow_constexpr_string*, const char*, > + unsigned int); > + void _ZNSt12__cow_stringC2EPKcy(__cow_constexpr_string*, const char*, > + unsigned long long); > + void _ZNSt12__cow_stringC2EPKc(__cow_constexpr_string*, const char*); > + void _ZNSt12__cow_stringC2ERKS_(__cow_constexpr_string*, > + const __cow_constexpr_string&) noexcept; > + void _ZNSt12__cow_stringC2EOS_(__cow_constexpr_string*, > + __cow_constexpr_string&&) noexcept; > + void _ZNSt12__cow_stringD2Ev(__cow_constexpr_string*); > + __cow_constexpr_string& > + _ZNSt12__cow_stringaSERKS_(__cow_constexpr_string*, > + const __cow_constexpr_string&) noexcept; > + __cow_constexpr_string& > + _ZNSt12__cow_stringaSEOS_(__cow_constexpr_string*, > + __cow_constexpr_string&&) noexcept; > + const char* > + _ZNKSt12__cow_string5c_strEv(const __cow_constexpr_string*) noexcept; > + } > + } // namespace __detail > + > + // Emulates an old COW string when the new std::string is in use, > + // but in addition is constexpr and uses the __cow_string out of > + // line cdtors/methods unless manifestly constant evaluated. > + struct __cow_constexpr_string > + { > + union { > + const char* _M_p; > + char _M_bytes[sizeof(const char*)]; > + string* _M_str; > + }; > + > + [[__gnu__::__always_inline__]] constexpr > + __cow_constexpr_string(const string& __o) > + { > + if consteval { > + _M_str = new string(__o); > + } else { > + __cow_constexpr_string_ctor(__o.c_str(), __o.length()); > + } > + } > + > + [[__gnu__::__always_inline__]] inline void > + __cow_constexpr_string_ctor(const char *__s, unsigned long __l) > + { > + __detail::_ZNSt12__cow_stringC2EPKcm(this, __s, __l); > + } > + > + [[__gnu__::__always_inline__]] inline void > + __cow_constexpr_string_ctor(const char *__s, unsigned int __l) > + { > + __detail::_ZNSt12__cow_stringC2EPKcj(this, __s, __l); > + } > + > + [[__gnu__::__always_inline__]] inline void > + __cow_constexpr_string_ctor(const char *__s, unsigned long long __l) > + { > + __detail::_ZNSt12__cow_stringC2EPKcy(this, __s, __l); > + } > + > + [[__gnu__::__always_inline__]] constexpr > + __cow_constexpr_string(const char* __o) > + { > + if consteval { > + _M_str = new string(__o); > + } else { > + __detail::_ZNSt12__cow_stringC2EPKc(this, __o); > + } > + } > + > + [[__gnu__::__always_inline__]] constexpr > + __cow_constexpr_string(const __cow_constexpr_string& __o) noexcept > + { > + if consteval { > + _M_str = new string(*__o._M_str); > + } else { > + __detail::_ZNSt12__cow_stringC2ERKS_(this, __o); > + } > + } > + > + [[__gnu__::__always_inline__]] constexpr __cow_constexpr_string& > + operator=(const __cow_constexpr_string& __o) noexcept > + { > + if consteval { > + string* __p = _M_str; > + _M_str = new string(*__o._M_str); > + delete __p; > + return *this; > + } else { > + return __detail::_ZNSt12__cow_stringaSERKS_(this, __o); > + } > + } > + > + [[__gnu__::__always_inline__]] constexpr > + ~__cow_constexpr_string() > + { > + if consteval { > + delete _M_str; > + } else { > + __detail::_ZNSt12__cow_stringD2Ev(this); > + } > + } > + > + [[__gnu__::__always_inline__]] constexpr > + __cow_constexpr_string(__cow_constexpr_string&& __o) noexcept > + { > + if consteval { > + _M_str = new string(std::move(*__o._M_str)); > + } else { > + __detail::_ZNSt12__cow_stringC2EOS_(this, std::move(__o)); > + } > + } > + > + [[__gnu__::__always_inline__]] constexpr __cow_constexpr_string& > + operator=(__cow_constexpr_string&& __o) noexcept > + { > + if consteval { > + string* __p = _M_str; > + _M_str = new string(std::move(*__o._M_str)); > + delete __p; > + return *this; > + } else { > + return __detail::_ZNSt12__cow_stringaSEOS_(this, std::move(__o)); > + } > + } > + > + [[__gnu__::__always_inline__]] constexpr const char* > + c_str() const noexcept > + { > + if consteval { > + return _M_str->c_str(); > + } else { > + return __detail::_ZNKSt12__cow_string5c_strEv(this); > + } > + } > + }; > + > + typedef __cow_constexpr_string __cow_string; > +#else > + // Emulates an old COW string when the new std::string is in use. > + struct __cow_string > + { > + union { > + const char* _M_p; > + char _M_bytes[sizeof(const char*)]; > + }; > + > + __cow_string(); > + __cow_string(const std::string&); > + __cow_string(const char*, size_t); > + __cow_string(const __cow_string&) _GLIBCXX_NOTHROW; > + __cow_string& operator=(const __cow_string&) _GLIBCXX_NOTHROW; > + ~__cow_string(); > +#if __cplusplus >= 201103L > + __cow_string(__cow_string&&) noexcept; > + __cow_string& operator=(__cow_string&&) noexcept; > +#endif > + }; > +#endif > + > + typedef basic_string<char> __sso_string; > +#else // _GLIBCXX_USE_CXX11_ABI > + typedef basic_string<char> __cow_string; > + > + // Emulates a new SSO string when the old std::string is in use. > + struct __sso_string > + { > + struct __str > + { > + const char* _M_p; > + size_t _M_string_length; > + char _M_local_buf[16]; > + }; > + > + union { > + __str _M_s; > + char _M_bytes[sizeof(__str)]; > + }; > + > + __sso_string() _GLIBCXX_NOTHROW; > + __sso_string(const std::string&); > + __sso_string(const char*, size_t); > + __sso_string(const __sso_string&); > + __sso_string& operator=(const __sso_string&); > + ~__sso_string(); > +#if __cplusplus >= 201103L > + __sso_string(__sso_string&&) noexcept; > + __sso_string& operator=(__sso_string&&) noexcept; > +#endif > + }; > +#endif // _GLIBCXX_USE_CXX11_ABI > +#else // _GLIBCXX_USE_DUAL_ABI > + typedef basic_string<char> __sso_string; > + typedef basic_string<char> __cow_string; > +#endif > + > + /** > + * @addtogroup exceptions > + * @{ > + */ > + > + /** Logic errors represent problems in the internal logic of a program; > + * in theory, these are preventable, and even detectable before the > + * program runs (e.g., violations of class invariants). > + * @brief One of two subclasses of exception. > + */ > + class logic_error : public exception > + { > + __cow_string _M_msg; > + > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit > + logic_error(const string& __arg) _GLIBCXX_TXN_SAFE > + : _M_msg(__arg) {} > + > + constexpr explicit > + logic_error(const char* __arg) _GLIBCXX_TXN_SAFE > + : _M_msg(__arg) {} > + > + constexpr logic_error(logic_error&& __arg) noexcept = default; > + constexpr logic_error& operator=(logic_error&& __arg) noexcept = default; > + constexpr logic_error(const logic_error&) noexcept = default; > + constexpr logic_error& operator=(const logic_error&) noexcept = default; > + > + constexpr virtual ~logic_error() _GLIBCXX_TXN_SAFE_DYN noexcept { } > + > + constexpr virtual const char* > + what() const _GLIBCXX_TXN_SAFE_DYN noexcept > + { > + return _M_msg.c_str(); > + } > +#else > + /** Takes a character string describing the error. */ > + explicit > + logic_error(const string& __arg) _GLIBCXX_TXN_SAFE; > + > +#if __cplusplus >= 201103L > + explicit > + logic_error(const char*) _GLIBCXX_TXN_SAFE; > + > + logic_error(logic_error&&) noexcept; > + logic_error& operator=(logic_error&&) noexcept; > +#endif > + > +#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS > + logic_error(const logic_error&) _GLIBCXX_NOTHROW; > + logic_error& operator=(const logic_error&) _GLIBCXX_NOTHROW; > +#elif __cplusplus >= 201103L > + logic_error(const logic_error&) = default; > + logic_error& operator=(const logic_error&) = default; > +#endif > + > + virtual ~logic_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > + > + /** Returns a C-style character string describing the general cause of > + * the current error (the same string passed to the ctor). */ > + virtual const char* > + what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > +#endif > + > +# ifdef _GLIBCXX_TM_TS_INTERNAL > + friend void* > + ::_txnal_logic_error_get_msg(void* e); > +# endif > + }; > + > + /** Thrown by the library, or by you, to report domain errors (domain in > + * the mathematical sense). */ > + class domain_error : public logic_error > + { > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr explicit domain_error(const char* __arg) _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr domain_error(const domain_error&) = default; > + constexpr domain_error& operator=(const domain_error&) = default; > + constexpr domain_error(domain_error&&) = default; > + constexpr domain_error& operator=(domain_error&&) = default; > + constexpr virtual ~domain_error() _GLIBCXX_NOTHROW { } > +#else > + explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE; > +#if __cplusplus >= 201103L > + explicit domain_error(const char*) _GLIBCXX_TXN_SAFE; > + domain_error(const domain_error&) = default; > + domain_error& operator=(const domain_error&) = default; > + domain_error(domain_error&&) = default; > + domain_error& operator=(domain_error&&) = default; > +#endif > + virtual ~domain_error() _GLIBCXX_NOTHROW; > +#endif > + }; > + > + /** Thrown to report invalid arguments to functions. */ > + class invalid_argument : public logic_error > + { > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit invalid_argument(const string& __arg) > _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr explicit invalid_argument(const char* __arg) _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr invalid_argument(const invalid_argument&) = default; > + constexpr invalid_argument& operator=(const invalid_argument&) = default; > + constexpr invalid_argument(invalid_argument&&) = default; > + constexpr invalid_argument& operator=(invalid_argument&&) = default; > + constexpr virtual ~invalid_argument() _GLIBCXX_NOTHROW { } > +#else > + explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE; > +#if __cplusplus >= 201103L > + explicit invalid_argument(const char*) _GLIBCXX_TXN_SAFE; > + invalid_argument(const invalid_argument&) = default; > + invalid_argument& operator=(const invalid_argument&) = default; > + invalid_argument(invalid_argument&&) = default; > + invalid_argument& operator=(invalid_argument&&) = default; > +#endif > + virtual ~invalid_argument() _GLIBCXX_NOTHROW; > +#endif > + }; > + > + /** Thrown when an object is constructed that would exceed its maximum > + * permitted size (e.g., a basic_string instance). */ > + class length_error : public logic_error > + { > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr explicit length_error(const char* __arg) _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr length_error(const length_error&) = default; > + constexpr length_error& operator=(const length_error&) = default; > + constexpr length_error(length_error&&) = default; > + constexpr length_error& operator=(length_error&&) = default; > + constexpr virtual ~length_error() _GLIBCXX_NOTHROW { } > +#else > + explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE; > +#if __cplusplus >= 201103L > + explicit length_error(const char*) _GLIBCXX_TXN_SAFE; > + length_error(const length_error&) = default; > + length_error& operator=(const length_error&) = default; > + length_error(length_error&&) = default; > + length_error& operator=(length_error&&) = default; > +#endif > + virtual ~length_error() _GLIBCXX_NOTHROW; > +#endif > + }; > + > + /** This represents an argument whose value is not within the expected > + * range (e.g., boundary checks in basic_string). */ > + class out_of_range : public logic_error > + { > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr explicit out_of_range(const char* __arg) _GLIBCXX_TXN_SAFE > + : logic_error(__arg) { } > + constexpr out_of_range(const out_of_range&) = default; > + constexpr out_of_range& operator=(const out_of_range&) = default; > + constexpr out_of_range(out_of_range&&) = default; > + constexpr out_of_range& operator=(out_of_range&&) = default; > + constexpr virtual ~out_of_range() _GLIBCXX_NOTHROW { } > +#else > + explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE; > +#if __cplusplus >= 201103L > + explicit out_of_range(const char*) _GLIBCXX_TXN_SAFE; > + out_of_range(const out_of_range&) = default; > + out_of_range& operator=(const out_of_range&) = default; > + out_of_range(out_of_range&&) = default; > + out_of_range& operator=(out_of_range&&) = default; > +#endif > + virtual ~out_of_range() _GLIBCXX_NOTHROW; > +#endif > + }; > + > + /** Runtime errors represent problems outside the scope of a program; > + * they cannot be easily predicted and can generally only be caught as > + * the program executes. > + * @brief One of two subclasses of exception. > + */ > + class runtime_error : public exception > + { > + __cow_string _M_msg; > + > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit > + runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE > + : _M_msg(__arg) {} > + > + constexpr explicit > + runtime_error(const char* __arg) _GLIBCXX_TXN_SAFE > + : _M_msg(__arg) {} > + > + constexpr runtime_error(runtime_error&&) noexcept = default; > + constexpr runtime_error& operator=(runtime_error&&) noexcept = default; > + constexpr runtime_error(const runtime_error&) noexcept = default; > + runtime_error& operator=(const runtime_error&) noexcept = default; > + > + constexpr virtual ~runtime_error() _GLIBCXX_TXN_SAFE_DYN noexcept { } > + > + constexpr virtual const char* > + what() const _GLIBCXX_TXN_SAFE_DYN noexcept > + { > + return _M_msg.c_str(); > + } > +#else > + /** Takes a character string describing the error. */ > + explicit > + runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE; > + > +#if __cplusplus >= 201103L > + explicit > + runtime_error(const char*) _GLIBCXX_TXN_SAFE; > + > + runtime_error(runtime_error&&) noexcept; > + runtime_error& operator=(runtime_error&&) noexcept; > +#endif > + > +#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS > + runtime_error(const runtime_error&) _GLIBCXX_NOTHROW; > + runtime_error& operator=(const runtime_error&) _GLIBCXX_NOTHROW; > +#elif __cplusplus >= 201103L > + runtime_error(const runtime_error&) = default; > + runtime_error& operator=(const runtime_error&) = default; > +#endif > + > + virtual ~runtime_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > + > + /** Returns a C-style character string describing the general cause of > + * the current error (the same string passed to the ctor). */ > + virtual const char* > + what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > +#endif > + > +# ifdef _GLIBCXX_TM_TS_INTERNAL > + friend void* > + ::_txnal_runtime_error_get_msg(void* e); > +# endif > + }; > + > + /** Thrown to indicate arithmetic overflow. */ > + class overflow_error : public runtime_error > + { > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE > + : runtime_error(__arg) { } > + constexpr explicit overflow_error(const char* __arg) _GLIBCXX_TXN_SAFE > + : runtime_error(__arg) { } > + constexpr overflow_error(const overflow_error&) = default; > + constexpr overflow_error& operator=(const overflow_error&) = default; > + constexpr overflow_error(overflow_error&&) = default; > + constexpr overflow_error& operator=(overflow_error&&) = default; > + constexpr virtual ~overflow_error() noexcept { } > +#else > + explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; > +#if __cplusplus >= 201103L > + explicit overflow_error(const char*) _GLIBCXX_TXN_SAFE; > + overflow_error(const overflow_error&) = default; > + overflow_error& operator=(const overflow_error&) = default; > + overflow_error(overflow_error&&) = default; > + overflow_error& operator=(overflow_error&&) = default; > +#endif > + virtual ~overflow_error() _GLIBCXX_NOTHROW; > +#endif > + }; > + > + /** Thrown to indicate arithmetic underflow. */ > + class underflow_error : public runtime_error > + { > + public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE > + : runtime_error(__arg) { } > + constexpr explicit underflow_error(const char* __arg) _GLIBCXX_TXN_SAFE > + : runtime_error(__arg) { } > + constexpr underflow_error(const underflow_error&) = default; > + constexpr underflow_error& operator=(const underflow_error&) = default; > + constexpr underflow_error(underflow_error&&) = default; > + constexpr underflow_error& operator=(underflow_error&&) = default; > + constexpr virtual ~underflow_error() noexcept { } > +#else > + explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; > +#if __cplusplus >= 201103L > + explicit underflow_error(const char*) _GLIBCXX_TXN_SAFE; > + underflow_error(const underflow_error&) = default; > + underflow_error& operator=(const underflow_error&) = default; > + underflow_error(underflow_error&&) = default; > + underflow_error& operator=(underflow_error&&) = default; > +#endif > + virtual ~underflow_error() _GLIBCXX_NOTHROW; > +#endif > + }; > + > + /// @} group exceptions > + > +_GLIBCXX_END_NAMESPACE_VERSION > +} // namespace > + > +#endif /* _STDEXCEPT_EXCEPT_H */ > --- libstdc++-v3/include/bits/stdexcept_throw.h.jj 2025-12-04 > 15:09:31.623133546 +0100 > +++ libstdc++-v3/include/bits/stdexcept_throw.h 2025-12-04 18:09:21.534621554 > +0100 > @@ -0,0 +1,61 @@ > +// Function-Based Exception Support -*- C++ -*- > + > +// Copyright (C) 2001-2025 Free Software Foundation, Inc. > +// > +// This file is part of the GNU ISO C++ Library. This library is free > +// software; you can redistribute it and/or modify it under the > +// terms of the GNU General Public License as published by the > +// Free Software Foundation; either version 3, or (at your option) > +// any later version. > + > +// This library is distributed in the hope that it will be useful, > +// but WITHOUT ANY WARRANTY; without even the implied warranty of > +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +// GNU General Public License for more details. > + > +// Under Section 7 of GPL version 3, you are granted additional > +// permissions described in the GCC Runtime Library Exception, version > +// 3.1, as published by the Free Software Foundation. > + > +// You should have received a copy of the GNU General Public License and > +// a copy of the GCC Runtime Library Exception along with this program; > +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +// <http://www.gnu.org/licenses/>. > + > +/** @file bits/stdexcept_throw.h > + * This is an internal header file, included by other library headers. > + * Do not attempt to use it directly. @headername{stdexcept} > + */ > + > +// > +// ISO C++ 14882: 19.1 Exception classes > +// > + > +#include <bits/c++config.h> > +#include <bits/exception_defines.h> > + > +#if (_GLIBCXX_HOSTED && __cpp_exceptions && __cplusplus > 202302L \ > + && __cpp_constexpr_exceptions >= 202411L) > +// This is a complicated case. Classes like std::logic_error > +// are defined in <stdexcept> but need std::string and <string> > +// needs __throw_logic_error and a few others. So, for C++26 > +// constant expression we need to forward declare the constexpr > +// __throw_logic_error etc. functions when included recursively > +// from <string> and then at the end of that header make sure > +// <stdexcept> is included and define those. > +// If <string> hasn't been included yet, include it at the end > +// of this header and that will arrange for all these to be > +// defined. > +#if defined(_GLIBCXX_STRING) || __glibcxx_exc_in_string == 2 > +#ifdef __glibcxx_exc_in_string > +#include <bits/stdexcept_throwfwd.h> > +#else > +#include <bits/stdexcept_throwdef.h> > +#endif > +#endif > +#if !defined(_GLIBCXX_STRING) && __glibcxx_exc_in_string != 2 > +#include <string> > +#endif > +#else > +#include <bits/stdexcept_throwfwd.h> > +#endif > --- libstdc++-v3/include/bits/stdexcept_throwdef.h.jj 2025-12-04 > 15:09:31.623236770 +0100 > +++ libstdc++-v3/include/bits/stdexcept_throwdef.h 2025-12-04 > 18:09:40.037299595 +0100 > @@ -0,0 +1,177 @@ > +// Function-Based Exception Support -*- C++ -*- > + > +// Copyright (C) 2001-2025 Free Software Foundation, Inc. > +// > +// This file is part of the GNU ISO C++ Library. This library is free > +// software; you can redistribute it and/or modify it under the > +// terms of the GNU General Public License as published by the > +// Free Software Foundation; either version 3, or (at your option) > +// any later version. > + > +// This library is distributed in the hope that it will be useful, > +// but WITHOUT ANY WARRANTY; without even the implied warranty of > +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +// GNU General Public License for more details. > + > +// Under Section 7 of GPL version 3, you are granted additional > +// permissions described in the GCC Runtime Library Exception, version > +// 3.1, as published by the Free Software Foundation. > + > +// You should have received a copy of the GNU General Public License and > +// a copy of the GCC Runtime Library Exception along with this program; > +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +// <http://www.gnu.org/licenses/>. > + > +/** @file bits/stdexcept_throwdef.h > + * This is an internal header file, included by other library headers. > + * Do not attempt to use it directly. @headername{stdexcept} > + */ > + > +// > +// ISO C++ 14882: 19.1 Exception classes > +// > + > +#ifndef _STDEXCEPT_THROWDEF_H > +#define _STDEXCEPT_THROWDEF_H 1 > + > +#include <bits/c++config.h> > +#include <bits/exception_defines.h> > +#if (_GLIBCXX_HOSTED && __cpp_exceptions && __cplusplus > 202302L \ > + && __cpp_constexpr_exceptions >= 202411L) > + > +namespace std _GLIBCXX_VISIBILITY(default) > +{ > +_GLIBCXX_BEGIN_NAMESPACE_VERSION > + > + // Helpers for exception objects in <stdexcept> > + namespace __detail > + { > + extern "C" > + { > + [[noreturn, __gnu__::__cold__]] void > + _ZSt19__throw_logic_errorPKc(const char*); > + > + [[noreturn, __gnu__::__cold__]] void > + _ZSt20__throw_domain_errorPKc(const char*); > + > + [[noreturn, __gnu__::__cold__]] void > + _ZSt24__throw_invalid_argumentPKc(const char*); > + > + [[noreturn, __gnu__::__cold__]] void > + _ZSt20__throw_length_errorPKc(const char*); > + > + [[noreturn, __gnu__::__cold__]] void > + _ZSt20__throw_out_of_rangePKc(const char*); > + > + [[noreturn, __gnu__::__cold__]] > + [[__gnu__::__format__(__gnu_printf__, 1, 2)]] void > + _ZSt24__throw_out_of_range_fmtPKcz(const char*, ...); > + > + [[noreturn, __gnu__::__cold__]] void > + _ZSt21__throw_runtime_errorPKc(const char*); > + > + [[noreturn, __gnu__::__cold__]] void > + _ZSt22__throw_overflow_errorPKc(const char*); > + > + [[noreturn, __gnu__::__cold__]] void > + _ZSt23__throw_underflow_errorPKc(const char*); > + } > + } // namespace __detail > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_logic_error(const char* __s) > + { > + if consteval { > + throw logic_error(__s); > + } else { > + __detail::_ZSt19__throw_logic_errorPKc(__s); > + } > + } > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_domain_error(const char* __s) > + { > + if consteval { > + throw domain_error(__s); > + } else { > + __detail::_ZSt20__throw_domain_errorPKc(__s); > + } > + } > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_invalid_argument(const char* __s) > + { > + if consteval { > + throw invalid_argument(__s); > + } else { > + __detail::_ZSt24__throw_invalid_argumentPKc(__s); > + } > + } > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_length_error(const char* __s) > + { > + if consteval { > + throw length_error(__s); > + } else { > + __detail::_ZSt20__throw_length_errorPKc(__s); > + } > + } > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_out_of_range(const char* __s) > + { > + if consteval { > + throw out_of_range(__s); > + } else { > + __detail::_ZSt20__throw_out_of_rangePKc(__s); > + } > + } > + > + template <typename... _Args> > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_out_of_range_fmt(const char* __s, _Args... __args) > + { > + if consteval { > + throw out_of_range(__s); > + } else { > + __detail::_ZSt24__throw_out_of_range_fmtPKcz(__s, __args...); > + } > + } > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_runtime_error(const char* __s) > + { > + if consteval { > + throw runtime_error(__s); > + } else { > + __detail::_ZSt21__throw_runtime_errorPKc(__s); > + } > + } > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_overflow_error(const char* __s) > + { > + if consteval { > + throw overflow_error(__s); > + } else { > + __detail::_ZSt22__throw_overflow_errorPKc(__s); > + } > + } > + > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_underflow_error(const char* __s) > + { > + if consteval { > + throw underflow_error(__s); > + } else { > + __detail::_ZSt23__throw_underflow_errorPKc(__s); > + } > + } > + > +_GLIBCXX_END_NAMESPACE_VERSION > +} // namespace > + > +#endif > + > +#endif > --- libstdc++-v3/include/bits/stdexcept_throwfwd.h.jj 2025-12-04 > 15:09:31.632395697 +0100 > +++ libstdc++-v3/include/bits/stdexcept_throwfwd.h 2025-12-04 > 18:09:32.079438068 +0100 > @@ -0,0 +1,125 @@ > +// Function-Based Exception Support -*- C++ -*- > + > +// Copyright (C) 2001-2025 Free Software Foundation, Inc. > +// > +// This file is part of the GNU ISO C++ Library. This library is free > +// software; you can redistribute it and/or modify it under the > +// terms of the GNU General Public License as published by the > +// Free Software Foundation; either version 3, or (at your option) > +// any later version. > + > +// This library is distributed in the hope that it will be useful, > +// but WITHOUT ANY WARRANTY; without even the implied warranty of > +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +// GNU General Public License for more details. > + > +// Under Section 7 of GPL version 3, you are granted additional > +// permissions described in the GCC Runtime Library Exception, version > +// 3.1, as published by the Free Software Foundation. > + > +// You should have received a copy of the GNU General Public License and > +// a copy of the GCC Runtime Library Exception along with this program; > +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +// <http://www.gnu.org/licenses/>. > + > +/** @file bits/stdexcept_throwfwd.h > + * This is an internal header file, included by other library headers. > + * Do not attempt to use it directly. @headername{stdexcept} > + */ > + > +// > +// ISO C++ 14882: 19.1 Exception classes > +// > + > +#ifndef _STDEXCEPT_THROWFWD_H > +#define _STDEXCEPT_THROWFWD_H 1 > + > +#include <bits/c++config.h> > +#include <bits/exception_defines.h> > + > +namespace std _GLIBCXX_VISIBILITY(default) > +{ > +_GLIBCXX_BEGIN_NAMESPACE_VERSION > + > +#if _GLIBCXX_HOSTED > +#if (__cpp_exceptions && __cplusplus > 202302L \ > + && __cpp_constexpr_exceptions >= 202411L) > + // Helper for exception objects in <stdexcept> > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_logic_error(const char*); > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_domain_error(const char*); > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_invalid_argument(const char*); > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_length_error(const char*); > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_out_of_range(const char*); > + template <typename... _Args> > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_out_of_range_fmt(const char* __s, _Args... __args); > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_runtime_error(const char*); > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_overflow_error(const char*); > + [[noreturn, __gnu__::__always_inline__, __gnu__::__cold__]] constexpr void > + __throw_underflow_error(const char*); > +#else > + // Helpers for exception objects in <stdexcept> > + void > + __throw_logic_error(const char*) __attribute__((__noreturn__,__cold__)); > + > + void > + __throw_domain_error(const char*) __attribute__((__noreturn__,__cold__)); > + > + void > + __throw_invalid_argument(const char*) > __attribute__((__noreturn__,__cold__)); > + > + void > + __throw_length_error(const char*) __attribute__((__noreturn__,__cold__)); > + > + void > + __throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__)); > + > + void > + __throw_out_of_range_fmt(const char*, ...) > + __attribute__((__noreturn__,__cold__,__format__(__gnu_printf__, 1, 2))); > + > + void > + __throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__)); > + > + void > + __throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__)); > + > + void > + __throw_underflow_error(const char*) > __attribute__((__noreturn__,__cold__)); > +#endif > + > +#else // ! HOSTED > + > + __attribute__((__noreturn__)) inline void > + __throw_invalid_argument(const char*) > + { std::__terminate(); } > + > + __attribute__((__noreturn__)) inline void > + __throw_out_of_range(const char*) > + { std::__terminate(); } > + > + __attribute__((__noreturn__)) inline void > + __throw_out_of_range_fmt(const char*, ...) > + { std::__terminate(); } > + > + __attribute__((__noreturn__)) inline void > + __throw_runtime_error(const char*) > + { std::__terminate(); } > + > + __attribute__((__noreturn__)) inline void > + __throw_overflow_error(const char*) > + { std::__terminate(); } > + > +#endif // HOSTED > + > +_GLIBCXX_END_NAMESPACE_VERSION > +} // namespace > + > +#endif > --- libstdc++-v3/include/std/stdexcept.jj 2025-09-06 11:18:17.969614761 > +0200 > +++ libstdc++-v3/include/std/stdexcept 2025-12-04 18:03:48.356419026 +0100 > @@ -39,227 +39,32 @@ > > #include <exception> > #include <string> > +#include <bits/stdexcept_except.h> > > namespace std _GLIBCXX_VISIBILITY(default) > { > _GLIBCXX_BEGIN_NAMESPACE_VERSION > > -#if _GLIBCXX_USE_DUAL_ABI > -#if _GLIBCXX_USE_CXX11_ABI > - // Emulates an old COW string when the new std::string is in use. > - struct __cow_string > - { > - union { > - const char* _M_p; > - char _M_bytes[sizeof(const char*)]; > - }; > - > - __cow_string(); > - __cow_string(const std::string&); > - __cow_string(const char*, size_t); > - __cow_string(const __cow_string&) _GLIBCXX_NOTHROW; > - __cow_string& operator=(const __cow_string&) _GLIBCXX_NOTHROW; > - ~__cow_string(); > -#if __cplusplus >= 201103L > - __cow_string(__cow_string&&) noexcept; > - __cow_string& operator=(__cow_string&&) noexcept; > -#endif > - }; > - > - typedef basic_string<char> __sso_string; > -#else // _GLIBCXX_USE_CXX11_ABI > - typedef basic_string<char> __cow_string; > - > - // Emulates a new SSO string when the old std::string is in use. > - struct __sso_string > - { > - struct __str > - { > - const char* _M_p; > - size_t _M_string_length; > - char _M_local_buf[16]; > - }; > - > - union { > - __str _M_s; > - char _M_bytes[sizeof(__str)]; > - }; > - > - __sso_string() _GLIBCXX_NOTHROW; > - __sso_string(const std::string&); > - __sso_string(const char*, size_t); > - __sso_string(const __sso_string&); > - __sso_string& operator=(const __sso_string&); > - ~__sso_string(); > -#if __cplusplus >= 201103L > - __sso_string(__sso_string&&) noexcept; > - __sso_string& operator=(__sso_string&&) noexcept; > -#endif > - }; > -#endif // _GLIBCXX_USE_CXX11_ABI > -#else // _GLIBCXX_USE_DUAL_ABI > - typedef basic_string<char> __sso_string; > - typedef basic_string<char> __cow_string; > -#endif > - > /** > * @addtogroup exceptions > * @{ > */ > > - /** Logic errors represent problems in the internal logic of a program; > - * in theory, these are preventable, and even detectable before the > - * program runs (e.g., violations of class invariants). > - * @brief One of two subclasses of exception. > - */ > - class logic_error : public exception > - { > - __cow_string _M_msg; > - > - public: > - /** Takes a character string describing the error. */ > - explicit > - logic_error(const string& __arg) _GLIBCXX_TXN_SAFE; > - > -#if __cplusplus >= 201103L > - explicit > - logic_error(const char*) _GLIBCXX_TXN_SAFE; > - > - logic_error(logic_error&&) noexcept; > - logic_error& operator=(logic_error&&) noexcept; > -#endif > - > -#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS > - logic_error(const logic_error&) _GLIBCXX_NOTHROW; > - logic_error& operator=(const logic_error&) _GLIBCXX_NOTHROW; > -#elif __cplusplus >= 201103L > - logic_error(const logic_error&) = default; > - logic_error& operator=(const logic_error&) = default; > -#endif > - > - virtual ~logic_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > - > - /** Returns a C-style character string describing the general cause of > - * the current error (the same string passed to the ctor). */ > - virtual const char* > - what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > - > -# ifdef _GLIBCXX_TM_TS_INTERNAL > - friend void* > - ::_txnal_logic_error_get_msg(void* e); > -# endif > - }; > - > - /** Thrown by the library, or by you, to report domain errors (domain in > - * the mathematical sense). */ > - class domain_error : public logic_error > - { > - public: > - explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE; > -#if __cplusplus >= 201103L > - explicit domain_error(const char*) _GLIBCXX_TXN_SAFE; > - domain_error(const domain_error&) = default; > - domain_error& operator=(const domain_error&) = default; > - domain_error(domain_error&&) = default; > - domain_error& operator=(domain_error&&) = default; > -#endif > - virtual ~domain_error() _GLIBCXX_NOTHROW; > - }; > - > - /** Thrown to report invalid arguments to functions. */ > - class invalid_argument : public logic_error > - { > - public: > - explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE; > -#if __cplusplus >= 201103L > - explicit invalid_argument(const char*) _GLIBCXX_TXN_SAFE; > - invalid_argument(const invalid_argument&) = default; > - invalid_argument& operator=(const invalid_argument&) = default; > - invalid_argument(invalid_argument&&) = default; > - invalid_argument& operator=(invalid_argument&&) = default; > -#endif > - virtual ~invalid_argument() _GLIBCXX_NOTHROW; > - }; > - > - /** Thrown when an object is constructed that would exceed its maximum > - * permitted size (e.g., a basic_string instance). */ > - class length_error : public logic_error > - { > - public: > - explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE; > -#if __cplusplus >= 201103L > - explicit length_error(const char*) _GLIBCXX_TXN_SAFE; > - length_error(const length_error&) = default; > - length_error& operator=(const length_error&) = default; > - length_error(length_error&&) = default; > - length_error& operator=(length_error&&) = default; > -#endif > - virtual ~length_error() _GLIBCXX_NOTHROW; > - }; > - > - /** This represents an argument whose value is not within the expected > - * range (e.g., boundary checks in basic_string). */ > - class out_of_range : public logic_error > - { > - public: > - explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE; > -#if __cplusplus >= 201103L > - explicit out_of_range(const char*) _GLIBCXX_TXN_SAFE; > - out_of_range(const out_of_range&) = default; > - out_of_range& operator=(const out_of_range&) = default; > - out_of_range(out_of_range&&) = default; > - out_of_range& operator=(out_of_range&&) = default; > -#endif > - virtual ~out_of_range() _GLIBCXX_NOTHROW; > - }; > - > - /** Runtime errors represent problems outside the scope of a program; > - * they cannot be easily predicted and can generally only be caught as > - * the program executes. > - * @brief One of two subclasses of exception. > - */ > - class runtime_error : public exception > - { > - __cow_string _M_msg; > - > - public: > - /** Takes a character string describing the error. */ > - explicit > - runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE; > - > -#if __cplusplus >= 201103L > - explicit > - runtime_error(const char*) _GLIBCXX_TXN_SAFE; > - > - runtime_error(runtime_error&&) noexcept; > - runtime_error& operator=(runtime_error&&) noexcept; > -#endif > - > -#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS > - runtime_error(const runtime_error&) _GLIBCXX_NOTHROW; > - runtime_error& operator=(const runtime_error&) _GLIBCXX_NOTHROW; > -#elif __cplusplus >= 201103L > - runtime_error(const runtime_error&) = default; > - runtime_error& operator=(const runtime_error&) = default; > -#endif > - > - virtual ~runtime_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > - > - /** Returns a C-style character string describing the general cause of > - * the current error (the same string passed to the ctor). */ > - virtual const char* > - what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW; > - > -# ifdef _GLIBCXX_TM_TS_INTERNAL > - friend void* > - ::_txnal_runtime_error_get_msg(void* e); > -# endif > - }; > - > /** Thrown to indicate range errors in internal computations. */ > class range_error : public runtime_error > { > public: > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE > + : runtime_error(__arg) { } > + constexpr explicit range_error(const char* __arg) _GLIBCXX_TXN_SAFE > + : runtime_error(__arg) { } > + constexpr range_error(const range_error&) = default; > + constexpr range_error& operator=(const range_error&) = default; > + constexpr range_error(range_error&&) = default; > + constexpr range_error& operator=(range_error&&) = default; > + constexpr virtual ~range_error() noexcept { } > +#else > explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE; > #if __cplusplus >= 201103L > explicit range_error(const char*) _GLIBCXX_TXN_SAFE; > @@ -269,36 +74,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > range_error& operator=(range_error&&) = default; > #endif > virtual ~range_error() _GLIBCXX_NOTHROW; > - }; > - > - /** Thrown to indicate arithmetic overflow. */ > - class overflow_error : public runtime_error > - { > - public: > - explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; > -#if __cplusplus >= 201103L > - explicit overflow_error(const char*) _GLIBCXX_TXN_SAFE; > - overflow_error(const overflow_error&) = default; > - overflow_error& operator=(const overflow_error&) = default; > - overflow_error(overflow_error&&) = default; > - overflow_error& operator=(overflow_error&&) = default; > -#endif > - virtual ~overflow_error() _GLIBCXX_NOTHROW; > - }; > - > - /** Thrown to indicate arithmetic underflow. */ > - class underflow_error : public runtime_error > - { > - public: > - explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; > -#if __cplusplus >= 201103L > - explicit underflow_error(const char*) _GLIBCXX_TXN_SAFE; > - underflow_error(const underflow_error&) = default; > - underflow_error& operator=(const underflow_error&) = default; > - underflow_error(underflow_error&&) = default; > - underflow_error& operator=(underflow_error&&) = default; > #endif > - virtual ~underflow_error() _GLIBCXX_NOTHROW; > }; > > /// @} group exceptions > --- libstdc++-v3/include/std/optional.jj 2025-11-24 17:17:33.888960268 > +0100 > +++ libstdc++-v3/include/std/optional 2025-12-04 15:09:31.661395188 +0100 > @@ -38,6 +38,7 @@ > #define __glibcxx_want_optional > #define __glibcxx_want_optional_range_support > #define __glibcxx_want_constrained_equality > +#define __glibcxx_want_constexpr_exceptions > #include <bits/version.h> > > #ifdef __cpp_lib_optional // C++ >= 17 > @@ -106,12 +107,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > bad_optional_access() = default; > virtual ~bad_optional_access() = default; > > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr > +#endif > const char* what() const noexcept override > { return "bad optional access"; } > }; > > // XXX Does not belong here. > - [[__noreturn__]] inline void > + [[__noreturn__]] > +#if __cpp_lib_constexpr_exceptions >= 202502L > + constexpr > +#else > + inline > +#endif > + void > __throw_bad_optional_access() > { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); } > > --- libstdc++-v3/include/std/expected.jj 2025-11-24 17:17:33.888960268 > +0100 > +++ libstdc++-v3/include/std/expected 2025-12-04 15:09:31.674394960 +0100 > @@ -36,6 +36,7 @@ > #define __glibcxx_want_expected > #define __glibcxx_want_freestanding_expected > #define __glibcxx_want_constrained_equality > +#define __glibcxx_want_constexpr_exceptions > #include <bits/version.h> > > #ifdef __cpp_lib_expected // C++ >= 23 && __cpp_concepts >= 202002L > @@ -77,21 +78,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > template<typename _Er> > class bad_expected_access; > > +#if __cpp_lib_constexpr_exceptions >= 202502L > +#define _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS constexpr > +#else > +#define _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS > +#endif > + > template<> > class bad_expected_access<void> : public exception > { > protected: > - bad_expected_access() noexcept { } > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS bad_expected_access() noexcept > { } > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS > bad_expected_access(const bad_expected_access&) noexcept = default; > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS > bad_expected_access(bad_expected_access&&) noexcept = default; > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS > bad_expected_access& operator=(const bad_expected_access&) noexcept = > default; > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS > bad_expected_access& operator=(bad_expected_access&&) noexcept = > default; > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS > ~bad_expected_access() = default; > > public: > > [[nodiscard]] > - const char* > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS const char* > what() const noexcept override > { return "bad access to std::expected without expected value"; } > }; > @@ -99,28 +111,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > template<typename _Er> > class bad_expected_access : public bad_expected_access<void> { > public: > - explicit > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS explicit > bad_expected_access(_Er __e) : _M_unex(std::move(__e)) { } > > // XXX const char* what() const noexcept override; > > [[nodiscard]] > - _Er& > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS _Er& > error() & noexcept > { return _M_unex; } > > [[nodiscard]] > - const _Er& > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS const _Er& > error() const & noexcept > { return _M_unex; } > > [[nodiscard]] > - _Er&& > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS _Er&& > error() && noexcept > { return std::move(_M_unex); } > > [[nodiscard]] > - const _Er&& > + _GLIBCXX_CONSTEXPR_BAD_EXPECTED_ACCESS const _Er&& > error() const && noexcept > { return std::move(_M_unex); } > > --- libstdc++-v3/include/std/format.jj 2025-11-15 11:57:53.213053653 +0100 > +++ libstdc++-v3/include/std/format 2025-12-04 15:09:31.692394645 +0100 > @@ -38,6 +38,7 @@ > #define __glibcxx_want_format > #define __glibcxx_want_format_ranges > #define __glibcxx_want_format_uchar > +#define __glibcxx_want_constexpr_exceptions > #include <bits/version.h> > > #ifdef __cpp_lib_format // C++ >= 20 && HOSTED > @@ -219,12 +220,20 @@ namespace __format > formatter& operator=(const formatter&) = delete; > }; > > +#if __cpp_lib_constexpr_exceptions >= 202502L > +#define _GLIBCXX_CONSTEXPR_FORMAT_ERROR constexpr > +#else > +#define _GLIBCXX_CONSTEXPR_FORMAT_ERROR > +#endif > + > // [format.error], class format_error > class format_error : public runtime_error > { > public: > - explicit format_error(const string& __what) : runtime_error(__what) { } > - explicit format_error(const char* __what) : runtime_error(__what) { } > + _GLIBCXX_CONSTEXPR_FORMAT_ERROR explicit format_error(const string& > __what) > + : runtime_error(__what) { } > + _GLIBCXX_CONSTEXPR_FORMAT_ERROR explicit format_error(const char* __what) > + : runtime_error(__what) { } > }; > > /// @cond undocumented > @@ -233,6 +242,8 @@ namespace __format > __throw_format_error(const char* __what) > { _GLIBCXX_THROW_OR_ABORT(format_error(__what)); } > > +#undef _GLIBCXX_CONSTEXPR_FORMAT_ERROR > + > namespace __format > { > // XXX use named functions for each constexpr error? > --- libstdc++-v3/include/std/variant.jj 2025-09-06 11:18:17.975614688 +0200 > +++ libstdc++-v3/include/std/variant 2025-12-04 15:09:31.704394434 +0100 > @@ -36,6 +36,7 @@ > #define __glibcxx_want_freestanding_variant > #define __glibcxx_want_variant > #define __glibcxx_want_constrained_equality > +#define __glibcxx_want_constexpr_exceptions > #include <bits/version.h> > > #ifdef __cpp_lib_variant // C++ >= 17 > @@ -1394,24 +1395,33 @@ namespace __detail::__variant > && (is_swappable_v<_Types> && ...))> > swap(variant<_Types...>&, variant<_Types...>&) = delete; > > - [[noreturn]] void __throw_bad_variant_access(unsigned); > +#if __cpp_lib_constexpr_exceptions >= 202502L > +#define _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS constexpr > +#else > +#define _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS > +#endif > + [[noreturn]] _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS void > + __throw_bad_variant_access(unsigned); > > class bad_variant_access : public exception > { > public: > - bad_variant_access() noexcept { } > + _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS bad_variant_access() noexcept { } > > - const char* what() const noexcept override > + _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS const char* what() > + const noexcept override > { return _M_reason; } > > private: > // Must only be called with a string literal > + _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS > bad_variant_access(const char* __reason) noexcept : _M_reason(__reason) > { } > > // Must point to a string with static storage duration: > const char* _M_reason = "bad variant access"; > > - friend void __throw_bad_variant_access([[maybe_unused]] unsigned __n) > + friend _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS void > + __throw_bad_variant_access([[maybe_unused]] unsigned __n) > { > [[maybe_unused]] static constexpr const char* __reasons[] = { > "std::get: wrong index for variant", > @@ -1421,6 +1431,7 @@ namespace __detail::__variant > }; > _GLIBCXX_THROW_OR_ABORT(bad_variant_access(__reasons[__n % 4u])); > } > +#undef _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS > }; > > template<typename... _Types> > --- libstdc++-v3/testsuite/18_support/exception/version.cc.jj 2025-09-06 > 11:18:18.007614296 +0200 > +++ libstdc++-v3/testsuite/18_support/exception/version.cc 2025-12-04 > 15:09:31.708394364 +0100 > @@ -3,7 +3,8 @@ > > #include <exception> > > -#ifdef __cpp_lib_constexpr_exceptions > -# error "Feature test macro for constexpr_exceptions should not be provided > by <exception>" > +#ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in > <exception>" > +#elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <exception>" > #endif > - > --- libstdc++-v3/testsuite/19_diagnostics/runtime_error/constexpr.cc.jj > 2025-12-04 15:09:31.709712203 +0100 > +++ libstdc++-v3/testsuite/19_diagnostics/runtime_error/constexpr.cc > 2025-12-04 15:09:31.709712203 +0100 > @@ -0,0 +1,73 @@ > +// { dg-do compile { target c++26 } } > + > +#include <string> > +#include <stdexcept> > +#include <testsuite_hooks.h> > + > +template <typename T> > +constexpr bool test01() > +{ > + try > + { > + std::string s = "This is the first runtime error"; > + throw T(s); > + } > + catch (const T &x) > + { > + VERIFY( std::string(x.what()) == "This is the first runtime error" ); > + } > + try > + { > + throw T("This is the second runtime error"); > + } > + catch (const std::runtime_error &x) > + { > + VERIFY( std::string(x.what()) == "This is the second runtime error" ); > + } > + std::string s = "This is the third runtime error"; > + T l(s); > + try > + { > + throw T(l); > + } > + catch (const std::runtime_error &x) > + { > + VERIFY( std::string(x.what()) == "This is the third runtime error" ); > + } > + VERIFY( std::string(l.what()) == "This is the third runtime error" ); > + s = "This is the fourth runtime error"; > + l = T(s); > + try > + { > + throw T(std::move(l)); > + } > + catch (const T &x) > + { > + VERIFY( std::string(x.what()) == "This is the fourth runtime error" ); > + } > + T l2(s); > + l2 = T("This is the fifth runtime error"); > + VERIFY( std::string(l2.what()) == "This is the fifth runtime error" ); > + T l3("This is the sixth runtime error"); > + VERIFY( std::string(l3.what()) == "This is the sixth runtime error" ); > + l3 = l2; > + VERIFY( std::string(l2.what()) == "This is the fifth runtime error" ); > + VERIFY( std::string(l3.what()) == "This is the fifth runtime error" ); > + l3 = T("This is the seventh runtime error"); > + l2 = std::move(l3); > + VERIFY( std::string(l2.what()) == "This is the seventh runtime error" ); > + return true; > +} > + > +static_assert(test01<std::runtime_error>()); > +static_assert(test01<std::range_error>()); > +static_assert(test01<std::overflow_error>()); > +static_assert(test01<std::underflow_error>()); > + > +int main(void) > +{ > + test01<std::runtime_error>(); > + test01<std::range_error>(); > + test01<std::overflow_error>(); > + test01<std::underflow_error>(); > +} > --- libstdc++-v3/testsuite/19_diagnostics/headers/stdexcept/version.cc.jj > 2025-12-04 15:09:31.709801987 +0100 > +++ libstdc++-v3/testsuite/19_diagnostics/headers/stdexcept/version.cc > 2025-12-04 15:09:31.709801987 +0100 > @@ -0,0 +1,10 @@ > +// { dg-do preprocess { target c++26 } } > +// { dg-add-options no_pch } > + > +#include <stdexcept> > + > +#ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in > <stdexcept>" > +#elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <stdexcept>" > +#endif > --- libstdc++-v3/testsuite/19_diagnostics/logic_error/constexpr.cc.jj > 2025-12-04 15:09:31.709889502 +0100 > +++ libstdc++-v3/testsuite/19_diagnostics/logic_error/constexpr.cc > 2025-12-04 15:09:31.709889502 +0100 > @@ -0,0 +1,75 @@ > +// { dg-do compile { target c++26 } } > + > +#include <string> > +#include <stdexcept> > +#include <testsuite_hooks.h> > + > +template <typename T> > +constexpr bool test01() > +{ > + try > + { > + std::string s = "This is the first logic error"; > + throw T(s); > + } > + catch (const T &x) > + { > + VERIFY( std::string(x.what()) == "This is the first logic error" ); > + } > + try > + { > + throw T("This is the second logic error"); > + } > + catch (const std::logic_error &x) > + { > + VERIFY( std::string(x.what()) == "This is the second logic error" ); > + } > + std::string s = "This is the third logic error"; > + T l(s); > + try > + { > + throw T(l); > + } > + catch (const std::logic_error &x) > + { > + VERIFY( std::string(x.what()) == "This is the third logic error" ); > + } > + VERIFY( std::string(l.what()) == "This is the third logic error" ); > + s = "This is the fourth logic error"; > + l = T(s); > + try > + { > + throw T(std::move(l)); > + } > + catch (const T &x) > + { > + VERIFY( std::string(x.what()) == "This is the fourth logic error" ); > + } > + T l2(s); > + l2 = T("This is the fifth logic error"); > + VERIFY( std::string(l2.what()) == "This is the fifth logic error" ); > + T l3("This is the sixth logic error"); > + VERIFY( std::string(l3.what()) == "This is the sixth logic error" ); > + l3 = l2; > + VERIFY( std::string(l2.what()) == "This is the fifth logic error" ); > + VERIFY( std::string(l3.what()) == "This is the fifth logic error" ); > + l3 = T("This is the seventh logic error"); > + l2 = std::move(l3); > + VERIFY( std::string(l2.what()) == "This is the seventh logic error" ); > + return true; > +} > + > +static_assert(test01<std::logic_error>()); > +static_assert(test01<std::domain_error>()); > +static_assert(test01<std::invalid_argument>()); > +static_assert(test01<std::length_error>()); > +static_assert(test01<std::out_of_range>()); > + > +int main(void) > +{ > + test01<std::logic_error>(); > + test01<std::domain_error>(); > + test01<std::invalid_argument>(); > + test01<std::length_error>(); > + test01<std::out_of_range>(); > +} > --- libstdc++-v3/testsuite/20_util/expected/observers.cc.jj 2025-09-06 > 11:18:18.026614063 +0200 > +++ libstdc++-v3/testsuite/20_util/expected/observers.cc 2025-12-04 > 15:09:31.723394101 +0100 > @@ -77,7 +77,10 @@ test_value() > return true; > } > > -void > +#if __cpp_lib_constexpr_exceptions >= 202502L > +constexpr > +#endif > +bool > test_value_throw() > { > std::expected<int, int> e1 = std::unexpected(9); > @@ -87,6 +90,8 @@ test_value_throw() > VERIFY( false ); > } catch (const std::bad_expected_access<int>& e) { > VERIFY( e.error() == 9 ); > + long c = e.what()[0]; > + VERIFY( c == e.what()[0] ); > } > try { > std::move(e1).value(); > @@ -122,6 +127,7 @@ test_value_throw() > } catch (const std::bad_expected_access<int>& e) { > VERIFY( e.error() == 8 ); > } > + return true; > } > > constexpr bool > @@ -218,6 +224,9 @@ int main() > test_has_value(); > static_assert( test_value() ); > test_value(); > +#if __cpp_lib_constexpr_exceptions >= 202502L > + static_assert( test_value_throw() ); > +#endif > test_value_throw(); > static_assert( test_error() ); > test_error(); > --- libstdc++-v3/testsuite/20_util/expected/version.cc.jj 2025-09-06 > 11:18:18.036613940 +0200 > +++ libstdc++-v3/testsuite/20_util/expected/version.cc 2025-12-04 > 15:09:31.731393961 +0100 > @@ -15,8 +15,17 @@ > # error "Feature-test macro for freestanding expected has wrong value in > <version>" > #endif > > +#if __cplusplus > 202302L > +# ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in > <version>" > +# elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <version>" > +# endif > +#endif > + > #undef __cpp_lib_expected > #undef __cpp_lib_freestanding_expected > +#undef __cpp_lib_constexpr_exceptions > #include <expected> > > #ifndef __cpp_lib_expected > @@ -30,3 +39,11 @@ > #elif __cpp_lib_freestanding_expected != 202311L > # error "Feature-test macro for freestanding expected has wrong value in > <expected>" > #endif > + > +#if __cplusplus > 202302L > +# ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in > <expected>" > +# elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <expected>" > +# endif > +#endif > --- libstdc++-v3/testsuite/20_util/variant/constexpr.cc.jj 2025-09-06 > 11:18:18.059613658 +0200 > +++ libstdc++-v3/testsuite/20_util/variant/constexpr.cc 2025-12-04 > 15:09:31.743393751 +0100 > @@ -11,6 +11,9 @@ > # error "Feature test macro for variant has wrong value for C++20 in > <variant>" > #endif > > +#if __cpp_lib_constexpr_exceptions >= 202502L > +#include <string> > +#endif > #include <testsuite_hooks.h> > > > @@ -51,6 +54,39 @@ test_assign() > > static_assert( test_assign() ); > > +#if __cpp_lib_constexpr_exceptions >= 202502L > +constexpr bool test_get() > +{ > + VERIFY(std::get<1>(std::variant<int, std::string>("a")) == "a"); > + VERIFY(std::get<std::string>(std::variant<int, std::string>("a")) == "a"); > + { > + try > + { > + std::get<0>(std::variant<int, std::string>("a")); > + } > + catch (const std::bad_variant_access& x) > + { > + long c = x.what()[0]; > + VERIFY( c == x.what()[0] ); > + } > + } > + { > + try > + { > + std::get<int>(std::variant<int, std::string>("a")); > + } > + catch (const std::bad_variant_access& x) > + { > + long c = x.what()[0]; > + VERIFY( c == x.what()[0] ); > + } > + } > + return true; > +} > + > +static_assert (test_get() ); > +#endif > + > constexpr bool > test_emplace() > { > --- libstdc++-v3/testsuite/20_util/variant/version.cc.jj 2025-09-06 > 11:18:18.059613658 +0200 > +++ libstdc++-v3/testsuite/20_util/variant/version.cc 2025-12-04 > 15:09:31.744663533 +0100 > @@ -19,8 +19,17 @@ > #endif > #endif > > +#if __cplusplus > 202302L > +#ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in <version>" > +#elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <version>" > +#endif > +#endif > + > #undef __cpp_lib_variant > #undef __cpp_lib_freestanding_variant > +#undef __cpp_lib_constexpr_exceptions > #include <variant> > > #if __cplusplus >= 202302L > @@ -30,3 +39,11 @@ > # error "Feature test macro for freestanding std::variant has wrong value in > <variant>" > #endif > #endif > + > +#if __cplusplus > 202302L > +#ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in <variant>" > +#elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <variant>" > +#endif > +#endif > --- libstdc++-v3/testsuite/20_util/optional/constexpr/observers/3.cc.jj > 2025-09-06 11:18:18.043613854 +0200 > +++ libstdc++-v3/testsuite/20_util/optional/constexpr/observers/3.cc > 2025-12-04 15:09:31.744852877 +0100 > @@ -18,12 +18,45 @@ > // <http://www.gnu.org/licenses/>. > > #include <optional> > +#include <testsuite_hooks.h> > > struct value_type > { > int i; > }; > > +#if __cpp_lib_constexpr_exceptions >= 202502L > +void eat(int x) > +{ > +} > + > +constexpr bool test01() > +{ > + enum outcome_type { nothrow, caught, bad_catch }; > + > + outcome_type outcome {}; > + std::optional<value_type> o = std::nullopt; > + > + try > + { > + eat(o.value().i); > + } > + catch(std::bad_optional_access const& x) > + { > + outcome = caught; > + long c = x.what()[0]; > + VERIFY( c == x.what()[0] ); > + } > + catch(...) > + { outcome = bad_catch; } > + > + VERIFY( outcome == caught ); > + return true; > +} > + > +static_assert( test01() ); > +#endif > + > int main() > { > constexpr std::optional<value_type> o { value_type { 51 } }; > --- libstdc++-v3/testsuite/20_util/optional/version.cc.jj 2025-10-22 > 13:09:42.526215696 +0200 > +++ libstdc++-v3/testsuite/20_util/optional/version.cc 2025-12-04 > 15:09:31.765393365 +0100 > @@ -29,11 +29,18 @@ > # elif __cpp_lib_optional_range_support != 202406L > # error "Feature test macro for optional range support has wrong value for > C++26 in <version>" > # endif > + > +# ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in > <version>" > +# elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <version>" > +# endif > #endif > > #undef __cpp_lib_optional > #undef __cpp_lib_freestanding_optional > #undef __cpp_lib_optional_range_support > +#undef __cpp_lib_constexpr_exceptions > #include <optional> > > #if __cplusplus >= 202302L > @@ -51,4 +58,10 @@ > # if __cpp_lib_optional_range_support != 202406L > # error "Feature test macro for optional range support has wrong value for > C++26 in <optional>" > # endif > + > +# ifndef __cpp_lib_constexpr_exceptions > +# error "Feature test macro for constexpr_exceptions is missing in > <optional>" > +# elif __cpp_lib_constexpr_exceptions < 202502L > +# error "Feature test macro for constexpr_exceptions has wrong value in > <optional>" > +# endif > #endif > --- libstdc++-v3/include/std/future.jj 2025-09-06 11:18:17.963614835 +0200 > +++ libstdc++-v3/include/std/future 2025-12-04 15:09:31.793392874 +0100 > @@ -34,6 +34,7 @@ > #endif > > #include <bits/requires_hosted.h> // concurrency > +#include <bits/functexcept.h> > > #if __cplusplus < 201103L > # include <bits/c++0x_warning.h> > --- libstdc++-v3/include/std/shared_mutex.jj 2025-11-19 09:28:46.776827411 > +0100 > +++ libstdc++-v3/include/std/shared_mutex 2025-12-04 15:09:31.802392716 > +0100 > @@ -39,6 +39,7 @@ > > #include <bits/chrono.h> > #include <bits/error_constants.h> > +#include <bits/new_throw.h> > #include <bits/functexcept.h> > #include <bits/move.h> // move, __exchange > #include <bits/std_mutex.h> // defer_lock_t > --- libstdc++-v3/include/std/flat_map.jj 2025-12-02 10:35:17.768693830 > +0100 > +++ libstdc++-v3/include/std/flat_map 2025-12-04 15:09:31.816392471 +0100 > @@ -47,7 +47,7 @@ > #include <ranges> // views::zip > #include <type_traits> > #include <vector> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <bits/stl_algo.h> > #include <bits/stl_function.h> // less > #include <bits/stl_pair.h> > --- libstdc++-v3/include/std/syncstream.jj 2025-09-15 10:28:58.997352913 > +0200 > +++ libstdc++-v3/include/std/syncstream 2025-12-04 15:11:57.395840189 +0100 > @@ -45,7 +45,6 @@ > > #include <bits/alloc_traits.h> > #include <bits/allocator.h> > -#include <bits/functexcept.h> > #include <bits/std_mutex.h> > > namespace std _GLIBCXX_VISIBILITY(default) > --- libstdc++-v3/include/std/flat_set.jj 2025-09-06 11:18:17.959614884 > +0200 > +++ libstdc++-v3/include/std/flat_set 2025-12-04 15:09:31.846391945 +0100 > @@ -46,7 +46,6 @@ > #include <optional> > #include <type_traits> > #include <vector> > -#include <bits/functexcept.h> > #include <bits/stl_algo.h> > #include <bits/stl_function.h> // less > #include <bits/stl_pair.h> > --- libstdc++-v3/include/std/bitset.jj 2025-11-14 16:32:39.817788713 +0100 > +++ libstdc++-v3/include/std/bitset 2025-12-04 15:09:31.875391437 +0100 > @@ -46,8 +46,8 @@ > #pragma GCC system_header > #endif > > -#include <bits/functexcept.h> // For invalid_argument, out_of_range, > - // overflow_error > +#include <bits/stdexcept_throw.h> // For invalid_argument, out_of_range, > + // overflow_error > #include <bits/stl_algobase.h> // For std::fill > > #if _GLIBCXX_HOSTED > --- libstdc++-v3/include/std/string_view.jj 2025-12-03 17:33:41.117761046 > +0100 > +++ libstdc++-v3/include/std/string_view 2025-12-04 15:09:31.876077909 > +0100 > @@ -49,7 +49,10 @@ > #if __cplusplus >= 201703L > > #include <bits/char_traits.h> > -#include <bits/functexcept.h> > +#ifndef __glibcxx_exc_in_string > +#define __glibcxx_exc_in_string 2 > +#include <bits/stdexcept_throw.h> > +#endif > #include <bits/functional_hash.h> > #include <bits/range_access.h> > #include <bits/stl_algobase.h> > @@ -918,6 +921,14 @@ _GLIBCXX_END_NAMESPACE_VERSION > > #include <bits/string_view.tcc> > > +#if __glibcxx_exc_in_string == 2 > +#undef __glibcxx_exc_in_string > +#if (_GLIBCXX_HOSTED && __cpp_exceptions && __cplusplus > 202302L \ > + && __cpp_constexpr_exceptions >= 202411L) > +#include <bits/stdexcept_throw.h> > +#endif > +#endif > + > #endif // __cplusplus <= 201402L > > -#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW > +#endif // _GLIBCXX_STRING_VIEW > --- libstdc++-v3/include/std/array.jj 2025-09-06 11:18:17.953614957 +0200 > +++ libstdc++-v3/include/std/array 2025-12-04 15:09:31.897391051 +0100 > @@ -41,7 +41,7 @@ > #include <initializer_list> > > #include <type_traits> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <bits/stl_algobase.h> > #include <bits/range_access.h> // std::begin, std::end etc. > #include <bits/utility.h> // std::index_sequence, std::tuple_size > --- libstdc++-v3/include/std/inplace_vector.jj 2025-12-03 09:57:55.487104659 > +0100 > +++ libstdc++-v3/include/std/inplace_vector 2025-12-04 15:09:31.910390823 > +0100 > @@ -38,6 +38,7 @@ > #ifdef __glibcxx_inplace_vector // C++ >= 26 > #include <compare> > #include <initializer_list> > +#include <bits/stdexcept_throw.h> > #include <bits/range_access.h> > #include <bits/ranges_base.h> // borrowed_iterator_t, > __detail::__container_compatible_range > #include <bits/ranges_util.h> // subrange > --- libstdc++-v3/include/std/string.jj 2025-12-03 17:33:41.100761340 +0100 > +++ libstdc++-v3/include/std/string 2025-12-04 15:11:18.522400438 +0100 > @@ -40,6 +40,7 @@ > #include <bits/requires_hosted.h> // containers > > #include <bits/c++config.h> > +#define __glibcxx_exc_in_string 1 > #include <bits/stringfwd.h> > #include <bits/char_traits.h> > #include <bits/allocator.h> > @@ -50,10 +51,19 @@ > #include <bits/stl_iterator.h> > #include <bits/stl_function.h> // For less > #include <ext/numeric_traits.h> > +#include <bits/stdexcept_throw.h> > #include <bits/stl_algobase.h> > #include <bits/range_access.h> > #include <bits/basic_string.h> > #include <bits/basic_string.tcc> > +#if (_GLIBCXX_HOSTED && __cpp_exceptions && __cplusplus > 202302L \ > + && __cpp_constexpr_exceptions >= 202411L) > +#include <bits/stdexcept_except.h> > +#undef __glibcxx_exc_in_string > +#include <bits/stdexcept_throw.h> > +#else > +#undef __glibcxx_exc_in_string > +#endif > > #define __glibcxx_want_algorithm_default_value_type > #define __glibcxx_want_allocator_traits_is_always_equal > --- libstdc++-v3/include/std/deque.jj 2025-09-29 15:01:30.036550725 +0200 > +++ libstdc++-v3/include/std/deque 2025-12-04 15:09:31.933390420 +0100 > @@ -61,6 +61,7 @@ > > #include <bits/requires_hosted.h> // containers are hosted only > > +#include <bits/stdexcept_throw.h> > #include <bits/stl_algobase.h> > #include <bits/allocator.h> > #include <bits/stl_construct.h> > --- libstdc++-v3/include/bits/new_allocator.h.jj 2025-09-06 > 11:18:17.881615839 +0200 > +++ libstdc++-v3/include/bits/new_allocator.h 2025-12-04 15:09:31.952390086 > +0100 > @@ -32,7 +32,7 @@ > > #include <bits/c++config.h> > #include <new> > -#include <bits/functexcept.h> > +#include <bits/new_throw.h> > #include <bits/move.h> > #if __cplusplus >= 201103L > #include <type_traits> > --- libstdc++-v3/include/bits/stl_algobase.h.jj 2025-09-29 15:01:30.032550780 > +0200 > +++ libstdc++-v3/include/bits/stl_algobase.h 2025-12-04 15:09:31.967389824 > +0100 > @@ -57,7 +57,6 @@ > #define _STL_ALGOBASE_H 1 > > #include <bits/c++config.h> > -#include <bits/functexcept.h> > #include <bits/cpp_type_traits.h> > #include <ext/type_traits.h> > #include <ext/numeric_traits.h> > --- libstdc++-v3/include/bits/stl_vector.h.jj 2025-09-06 11:18:17.902615582 > +0200 > +++ libstdc++-v3/include/bits/stl_vector.h 2025-12-04 15:09:31.979389613 > +0100 > @@ -57,7 +57,7 @@ > #define _STL_VECTOR_H 1 > > #include <bits/stl_iterator_base_funcs.h> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <bits/concept_check.h> > #if __cplusplus >= 201103L > #include <initializer_list> > --- libstdc++-v3/include/bits/memory_resource.h.jj 2025-09-06 > 11:18:17.881615839 +0200 > +++ libstdc++-v3/include/bits/memory_resource.h 2025-12-04 15:09:31.999389262 > +0100 > @@ -38,7 +38,7 @@ > > #include <new> // operator new(size_t, void*) > #include <cstddef> // size_t, max_align_t, byte > -#include <bits/functexcept.h> // __throw_bad_array_new_length > +#include <bits/new_throw.h> // __throw_bad_array_new_length > #include <bits/uses_allocator.h> // allocator_arg_t, __use_alloc > #include <bits/uses_allocator_args.h> // uninitialized_construct_using_alloc > #include <ext/numeric_traits.h> // __int_traits > --- libstdc++-v3/include/bits/functexcept.h.jj 2025-09-06 11:18:17.839616354 > +0200 > +++ libstdc++-v3/include/bits/functexcept.h 2025-12-04 17:24:07.846866537 > +0100 > @@ -39,22 +39,14 @@ > #include <bits/c++config.h> > #include <bits/exception_defines.h> > > +#if _GLIBCXX_HOSTED > namespace std _GLIBCXX_VISIBILITY(default) > { > _GLIBCXX_BEGIN_NAMESPACE_VERSION > - > -#if _GLIBCXX_HOSTED > // Helper for exception objects in <except> > void > __throw_bad_exception(void) __attribute__((__noreturn__)); > > - // Helper for exception objects in <new> > - void > - __throw_bad_alloc(void) __attribute__((__noreturn__)); > - > - void > - __throw_bad_array_new_length(void) __attribute__((__noreturn__)); > - > // Helper for exception objects in <typeinfo> > void > __throw_bad_cast(void) __attribute__((__noreturn__,__cold__)); > @@ -64,36 +56,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > // Helpers for exception objects in <stdexcept> > void > - __throw_logic_error(const char*) __attribute__((__noreturn__,__cold__)); > - > - void > - __throw_domain_error(const char*) __attribute__((__noreturn__,__cold__)); > - > - void > - __throw_invalid_argument(const char*) > __attribute__((__noreturn__,__cold__)); > - > - void > - __throw_length_error(const char*) __attribute__((__noreturn__,__cold__)); > - > - void > - __throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__)); > - > - void > - __throw_out_of_range_fmt(const char*, ...) > __attribute__((__noreturn__,__cold__)) > - __attribute__((__format__(__gnu_printf__, 1, 2))); > - > - void > - __throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__)); > - > - void > __throw_range_error(const char*) __attribute__((__noreturn__,__cold__)); > > - void > - __throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__)); > - > - void > - __throw_underflow_error(const char*) > __attribute__((__noreturn__,__cold__)); > - > // Helpers for exception objects in <ios> > void > __throw_ios_failure(const char*) __attribute__((__noreturn__,__cold__)); > @@ -113,31 +77,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > void > __throw_bad_function_call() __attribute__((__noreturn__,__cold__)); > > -#else // ! HOSTED > - > - __attribute__((__noreturn__)) inline void > - __throw_invalid_argument(const char*) > - { std::__terminate(); } > - > - __attribute__((__noreturn__)) inline void > - __throw_out_of_range(const char*) > - { std::__terminate(); } > - > - __attribute__((__noreturn__)) inline void > - __throw_out_of_range_fmt(const char*, ...) > - { std::__terminate(); } > - > - __attribute__((__noreturn__)) inline void > - __throw_runtime_error(const char*) > - { std::__terminate(); } > - > - __attribute__((__noreturn__)) inline void > - __throw_overflow_error(const char*) > - { std::__terminate(); } > - > -#endif // HOSTED > - > _GLIBCXX_END_NAMESPACE_VERSION > } // namespace > +#endif // HOSTED > > #endif > --- libstdc++-v3/include/bits/stl_map.h.jj 2025-10-21 11:27:06.044866865 > +0200 > +++ libstdc++-v3/include/bits/stl_map.h 2025-12-04 15:09:32.028388754 +0100 > @@ -56,7 +56,7 @@ > #ifndef _STL_MAP_H > #define _STL_MAP_H 1 > > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <bits/concept_check.h> > #if __cplusplus >= 201103L > #include <initializer_list> > --- libstdc++-v3/include/bits/locale_classes.h.jj 2025-09-06 > 11:18:17.872615950 +0200 > +++ libstdc++-v3/include/bits/locale_classes.h 2025-12-04 17:32:44.025870864 > +0100 > @@ -38,6 +38,7 @@ > #pragma GCC system_header > #endif > > +#include <bits/functexcept.h> > #include <bits/localefwd.h> > #include <string> > #include <ext/atomicity.h> > --- libstdc++-v3/include/bits/hashtable_policy.h.jj 2025-09-06 > 11:18:17.871615962 +0200 > +++ libstdc++-v3/include/bits/hashtable_policy.h 2025-12-04 > 15:09:32.057388245 +0100 > @@ -32,6 +32,7 @@ > #define _HASHTABLE_POLICY_H 1 > > #include <tuple> // for std::tuple, std::forward_as_tuple > +#include <bits/stdexcept_throw.h> > #include <bits/functional_hash.h> // for __is_fast_hash > #include <bits/stl_algobase.h> // for std::min > #include <bits/stl_pair.h> // for std::pair > --- libstdc++-v3/include/bits/formatfwd.h.jj 2025-10-10 18:26:05.086639216 > +0200 > +++ libstdc++-v3/include/bits/formatfwd.h 2025-12-04 15:09:32.076387912 > +0100 > @@ -56,11 +56,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > // [format.formatter], formatter > template<typename _Tp, typename _CharT = char> struct formatter; > > -/// @cond undocumented > - [[noreturn]] > - inline void > - __throw_format_error(const char* __what); > - > namespace __format > { > #ifdef _GLIBCXX_USE_WCHAR_T > --- libstdc++-v3/include/bits/specfun.h.jj 2025-09-06 11:18:17.885615790 > +0200 > +++ libstdc++-v3/include/bits/specfun.h 2025-12-04 15:09:32.084387772 +0100 > @@ -40,6 +40,7 @@ > # error include <cmath> and define __STDCPP_WANT_MATH_SPEC_FUNCS__ > #endif > > +#include <bits/stdexcept_throw.h> > #include <bits/stl_algobase.h> > #include <limits> > #include <type_traits> > --- libstdc++-v3/include/bits/basic_ios.h.jj 2025-09-06 11:18:17.800616832 > +0200 > +++ libstdc++-v3/include/bits/basic_ios.h 2025-12-04 17:32:32.184077236 > +0100 > @@ -34,6 +34,7 @@ > #pragma GCC system_header > #endif > > +#include <bits/functexcept.h> > #include <bits/localefwd.h> > #include <bits/locale_classes.h> > #include <bits/locale_facets.h> > --- libstdc++-v3/include/tr1/cmath.jj 2025-09-06 11:18:17.976614675 +0200 > +++ libstdc++-v3/include/tr1/cmath 2025-12-04 15:09:32.097387544 +0100 > @@ -34,6 +34,7 @@ > #endif > > #include <bits/requires_hosted.h> // TR1 > +#include <bits/stdexcept_throw.h> > > #include <cmath> > > --- libstdc++-v3/include/tr1/memory.jj 2025-09-06 11:18:17.976614675 +0200 > +++ libstdc++-v3/include/tr1/memory 2025-12-04 15:09:32.110387316 +0100 > @@ -47,7 +47,6 @@ > #include <iosfwd> // std::basic_ostream > #include <ext/atomicity.h> > #include <ext/concurrence.h> > -#include <bits/functexcept.h> > #include <bits/stl_function.h> // std::less > #include <debug/debug.h> > #include <tr1/type_traits> > --- libstdc++-v3/include/tr1/array.jj 2025-09-06 11:18:17.975614688 +0200 > +++ libstdc++-v3/include/tr1/array 2025-12-04 15:09:32.137386843 +0100 > @@ -34,6 +34,7 @@ > #endif > > #include <bits/requires_hosted.h> // TR1 > +#include <bits/stdexcept_throw.h> > > #include <bits/stl_algobase.h> > > --- libstdc++-v3/include/ext/vstring_util.h.jj 2025-09-06 11:18:17.945615055 > +0200 > +++ libstdc++-v3/include/ext/vstring_util.h 2025-12-04 15:09:32.160386439 > +0100 > @@ -39,7 +39,7 @@ > #include <ext/vstring_fwd.h> > #include <debug/debug.h> > #include <bits/stl_function.h> // For less > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <bits/localefwd.h> > #include <bits/ostream_insert.h> > #include <bits/stl_iterator.h> > --- libstdc++-v3/include/ext/bitmap_allocator.h.jj 2025-09-06 > 11:18:17.929615251 +0200 > +++ libstdc++-v3/include/ext/bitmap_allocator.h 2025-12-04 15:09:32.186385984 > +0100 > @@ -32,7 +32,7 @@ > #include <bits/requires_hosted.h> // GNU extensions are currently omitted > > #include <utility> // For std::pair. > -#include <bits/functexcept.h> // For __throw_bad_alloc(). > +#include <bits/new_throw.h> // For __throw_bad_alloc(). > #include <bits/stl_function.h> // For greater_equal, and less_equal. > #include <new> // For operator new. > #include <debug/debug.h> // _GLIBCXX_DEBUG_ASSERT > --- libstdc++-v3/include/ext/mt_allocator.h.jj 2025-09-06 11:18:17.931615227 > +0200 > +++ libstdc++-v3/include/ext/mt_allocator.h 2025-12-04 15:09:32.213385510 > +0100 > @@ -33,7 +33,7 @@ > > #include <new> > #include <cstdlib> > -#include <bits/functexcept.h> > +#include <bits/new_throw.h> > #include <ext/atomicity.h> > #include <bits/move.h> > #if __cplusplus >= 201103L > --- libstdc++-v3/include/ext/malloc_allocator.h.jj 2025-09-06 > 11:18:17.930615239 +0200 > +++ libstdc++-v3/include/ext/malloc_allocator.h 2025-12-04 15:09:32.222385353 > +0100 > @@ -34,7 +34,7 @@ > #include <cstdlib> > #include <cstddef> > #include <new> > -#include <bits/functexcept.h> > +#include <bits/new_throw.h> > #include <bits/move.h> > #if __cplusplus >= 201103L > #include <type_traits> > --- libstdc++-v3/include/ext/debug_allocator.h.jj 2025-09-06 > 11:18:17.930615239 +0200 > +++ libstdc++-v3/include/ext/debug_allocator.h 2025-12-04 15:09:32.241385020 > +0100 > @@ -45,7 +45,7 @@ > #include <bits/requires_hosted.h> // GNU extensions are currently omitted > > #include <stdexcept> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <ext/alloc_traits.h> > > namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) > --- libstdc++-v3/include/ext/concurrence.h.jj 2025-09-06 11:18:17.929615251 > +0200 > +++ libstdc++-v3/include/ext/concurrence.h 2025-12-04 15:09:32.260384687 > +0100 > @@ -35,7 +35,7 @@ > > #include <exception> > #include <bits/gthr.h> > -#include <bits/functexcept.h> > +#include <bits/exception_defines.h> > #include <bits/cpp_type_traits.h> > #include <ext/type_traits.h> > > --- libstdc++-v3/include/ext/throw_allocator.h.jj 2025-09-06 > 11:18:17.944615068 +0200 > +++ libstdc++-v3/include/ext/throw_allocator.h 2025-12-04 15:09:32.272384476 > +0100 > @@ -55,7 +55,8 @@ > #include <ostream> > #include <stdexcept> > #include <utility> > -#include <bits/functexcept.h> > +#include <bits/new_throw.h> > +#include <bits/stdexcept_throw.h> > #include <bits/move.h> > #if __cplusplus >= 201103L > # include <functional> > --- libstdc++-v3/include/ext/string_conversions.h.jj 2025-09-06 > 11:18:17.943615080 +0200 > +++ libstdc++-v3/include/ext/string_conversions.h 2025-12-04 > 15:09:32.273978973 +0100 > @@ -41,7 +41,7 @@ > > #include <bits/c++config.h> > #include <ext/numeric_traits.h> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <cstdlib> > #include <cwchar> > #include <cstdio> > --- libstdc++-v3/include/ext/pool_allocator.h.jj 2025-09-06 > 11:18:17.939615129 +0200 > +++ libstdc++-v3/include/ext/pool_allocator.h 2025-12-04 15:09:32.287384213 > +0100 > @@ -47,7 +47,7 @@ > #include <bits/c++config.h> > #include <cstdlib> > #include <new> > -#include <bits/functexcept.h> > +#include <bits/new_throw.h> > #include <ext/atomicity.h> > #include <ext/concurrence.h> > #include <bits/move.h> > --- libstdc++-v3/include/ext/ropeimpl.h.jj 2025-10-08 09:24:15.353328696 > +0200 > +++ libstdc++-v3/include/ext/ropeimpl.h 2025-12-04 15:09:32.307383863 +0100 > @@ -42,7 +42,7 @@ > > #include <cstdio> > #include <ostream> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > > #include <ext/algorithm> // For copy_n and lexicographical_compare_3way > #include <ext/memory> // For uninitialized_copy_n > --- libstdc++-v3/include/tr2/dynamic_bitset.jj 2025-09-06 11:18:17.980614626 > +0200 > +++ libstdc++-v3/include/tr2/dynamic_bitset 2025-12-04 15:09:32.315383722 > +0100 > @@ -37,7 +37,7 @@ > #include <vector> > #include <string> > #include <istream> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <bits/stl_algo.h> // For fill > #include <bits/cxxabi_forced.h> > > --- libstdc++-v3/include/experimental/optional.jj 2025-09-06 > 11:18:17.925615300 +0200 > +++ libstdc++-v3/include/experimental/optional 2025-12-04 15:09:32.321383617 > +0100 > @@ -38,7 +38,7 @@ > #include <stdexcept> > #include <new> > #include <initializer_list> > -#include <bits/functexcept.h> > +#include <bits/exception_defines.h> > #include <bits/functional_hash.h> > #include <bits/enable_special_members.h> > #include <bits/move.h> > --- libstdc++-v3/include/Makefile.am.jj 2025-12-03 09:57:55.359106880 +0100 > +++ libstdc++-v3/include/Makefile.am 2025-12-04 17:31:09.028526425 +0100 > @@ -136,6 +136,8 @@ bits_freestanding = \ > ${bits_srcdir}/functional_hash.h \ > ${bits_srcdir}/invoke.h \ > ${bits_srcdir}/iterator_concepts.h \ > + ${bits_srcdir}/new_except.h \ > + ${bits_srcdir}/new_throw.h \ > ${bits_srcdir}/max_size_type.h \ > ${bits_srcdir}/memoryfwd.h \ > ${bits_srcdir}/monostate.h \ > @@ -154,6 +156,10 @@ bits_freestanding = \ > ${bits_srcdir}/ranges_util.h \ > ${bits_srcdir}/refwrap.h \ > ${bits_srcdir}/sat_arith.h \ > + ${bits_srcdir}/stdexcept_except.h \ > + ${bits_srcdir}/stdexcept_throw.h \ > + ${bits_srcdir}/stdexcept_throwdef.h \ > + ${bits_srcdir}/stdexcept_throwfwd.h \ > ${bits_srcdir}/stl_algo.h \ > ${bits_srcdir}/stl_algobase.h \ > ${bits_srcdir}/stl_construct.h \ > --- libstdc++-v3/include/Makefile.in.jj 2025-12-03 09:57:55.379106533 +0100 > +++ libstdc++-v3/include/Makefile.in 2025-12-04 17:32:04.511559497 +0100 > @@ -494,6 +494,8 @@ bits_freestanding = \ > ${bits_srcdir}/functional_hash.h \ > ${bits_srcdir}/invoke.h \ > ${bits_srcdir}/iterator_concepts.h \ > + ${bits_srcdir}/new_except.h \ > + ${bits_srcdir}/new_throw.h \ > ${bits_srcdir}/max_size_type.h \ > ${bits_srcdir}/memoryfwd.h \ > ${bits_srcdir}/monostate.h \ > @@ -512,6 +514,10 @@ bits_freestanding = \ > ${bits_srcdir}/ranges_util.h \ > ${bits_srcdir}/refwrap.h \ > ${bits_srcdir}/sat_arith.h \ > + ${bits_srcdir}/stdexcept_except.h \ > + ${bits_srcdir}/stdexcept_throw.h \ > + ${bits_srcdir}/stdexcept_throwdef.h \ > + ${bits_srcdir}/stdexcept_throwfwd.h \ > ${bits_srcdir}/stl_algo.h \ > ${bits_srcdir}/stl_algobase.h \ > ${bits_srcdir}/stl_construct.h \ > --- libstdc++-v3/src/c++17/floating_from_chars.cc.jj 2025-09-06 > 11:18:18.001614369 +0200 > +++ libstdc++-v3/src/c++17/floating_from_chars.cc 2025-12-04 > 15:09:32.359382951 +0100 > @@ -45,7 +45,6 @@ > #include <cstdlib> > #include <cstring> > #include <locale.h> > -#include <bits/functexcept.h> > #if _GLIBCXX_HAVE_XLOCALE_H > # include <xlocale.h> > #endif > --- libstdc++-v3/src/c++11/regex.cc.jj 2025-09-06 11:18:17.998614406 +0200 > +++ libstdc++-v3/src/c++11/regex.cc 2025-12-04 15:09:32.360485787 +0100 > @@ -24,7 +24,6 @@ > > #include <stdexcept> > #include <bits/regex_error.h> > -#include <bits/functexcept.h> > > namespace std _GLIBCXX_VISIBILITY(default) > { > --- libstdc++-v3/src/c++11/functexcept.cc.jj 2025-09-06 11:18:17.998614406 > +0200 > +++ libstdc++-v3/src/c++11/functexcept.cc 2025-12-04 15:09:32.360669487 > +0100 > @@ -20,7 +20,6 @@ > // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > // <http://www.gnu.org/licenses/>. > > -#include <bits/functexcept.h> > #include <cstdlib> > #include <exception> > #include <stdexcept> > --- libstdc++-v3/src/c++11/snprintf_lite.cc.jj 2025-09-06 11:18:17.999614394 > +0200 > +++ libstdc++-v3/src/c++11/snprintf_lite.cc 2025-12-04 15:09:32.371382740 > +0100 > @@ -25,7 +25,7 @@ > > #include <stdarg.h> > #include <stddef.h> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > > namespace __gnu_cxx { > > --- libstdc++-v3/src/c++11/thread.cc.jj 2025-10-21 11:27:06.127865710 +0200 > +++ libstdc++-v3/src/c++11/thread.cc 2025-12-04 15:09:32.390382408 +0100 > @@ -30,6 +30,7 @@ > #include <system_error> > #include <cerrno> > #include <cxxabi_forced.h> > +#include <bits/functexcept.h> > > #ifndef _GLIBCXX_USE_NANOSLEEP > # ifdef _GLIBCXX_HAVE_SLEEP > --- libstdc++-v3/testsuite/util/testsuite_hooks.h.jj 2025-09-06 > 11:18:18.093613241 +0200 > +++ libstdc++-v3/testsuite/util/testsuite_hooks.h 2025-12-04 > 15:09:32.408382092 +0100 > @@ -44,7 +44,7 @@ > #define _GLIBCXX_TESTSUITE_HOOKS_H > > #include <bits/c++config.h> > -#include <bits/functexcept.h> > +#include <bits/stdexcept_throw.h> > #include <ctime> > #include <stdio.h> > > --- libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc.jj > 2025-09-06 11:18:18.090613278 +0200 > +++ libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc 2025-12-04 > 15:09:32.415381969 +0100 > @@ -38,7 +38,7 @@ > #include <limits.h> > #include <utility> > #include <stdlib.h> > -#include <bits/functexcept.h> > +#include <bits/exception_defines.h> > > namespace __gnu_pbds > { > --- libstdc++-v3/testsuite/20_util/allocator/105975.cc.jj 2025-09-06 > 11:18:18.017614173 +0200 > +++ libstdc++-v3/testsuite/20_util/allocator/105975.cc 2025-12-04 > 15:09:32.426381776 +0100 > @@ -9,10 +9,11 @@ consteval bool test_pr105957() > { > std::allocator<long long> a; > auto n = std::size_t(-1) / (sizeof(long long) - 1); > - auto p = a.allocate(n); // { dg-error "constexpr" } > + auto p = a.allocate(n); // { dg-error "constexpr" "" { target c++23_down } > } > a.deallocate(p, n); > return true; > } > static_assert( test_pr105957() ); // { dg-error "non-constant" } > +// { dg-error "uncaught exception of type 'std::bad_array_new_length'" "" { > target c++26 } 16 } > > -// { dg-error "throw_bad_array_new_length" "" { target *-*-* } 0 } > +// { dg-error "throw_bad_array_new_length" "" { target c++23_down } 0 } > --- libstdc++-v3/testsuite/23_containers/inplace_vector/access/capacity.cc.jj > 2025-09-06 11:18:18.069613536 +0200 > +++ libstdc++-v3/testsuite/23_containers/inplace_vector/access/capacity.cc > 2025-12-04 15:09:32.438381566 +0100 > @@ -20,12 +20,11 @@ test_reserve() > v.reserve(N); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > --- libstdc++-v3/testsuite/23_containers/inplace_vector/access/elem.cc.jj > 2025-09-06 11:18:18.069613536 +0200 > +++ libstdc++-v3/testsuite/23_containers/inplace_vector/access/elem.cc > 2025-12-04 15:09:32.444381461 +0100 > @@ -14,12 +14,11 @@ test_out_of_capacity() > std::inplace_vector<T, N> v; > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > @@ -82,12 +81,11 @@ test_access() > VERIFY( e4a == T(5) ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > --- libstdc++-v3/testsuite/23_containers/inplace_vector/cons/1.cc.jj > 2025-12-03 09:57:55.503104382 +0100 > +++ libstdc++-v3/testsuite/23_containers/inplace_vector/cons/1.cc > 2025-12-04 15:09:32.445894484 +0100 > @@ -166,10 +166,9 @@ test_n() > VERIFY( z0.begin() == z0.end() ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if not consteval { > +#endif > try > { > std::inplace_vector<int, 2> ct(3); > @@ -188,8 +187,10 @@ test_n() > { > } > > +#ifndef __cpp_lib_constexpr_exceptions > } > #endif > +#endif > > #ifdef __cpp_lib_constexpr_inplace_vector > #error remove the consteval check > @@ -243,10 +244,9 @@ test_n_val() > VERIFY( z0.begin() == z0.end() ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if not consteval { > +#endif > try > { > std::inplace_vector<int, 2> ct(3, 11); > @@ -264,8 +264,10 @@ test_n_val() > catch (std::bad_alloc const&) > { > } > +#ifndef __cpp_lib_constexpr_exceptions > } > #endif > +#endif > > #ifdef __cpp_lib_constexpr_inplace_vector > #error remove the consteval check > @@ -319,10 +321,9 @@ test_initializer_list() > VERIFY( z0.begin() == z0.end() ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if not consteval { > +#endif > try > { > std::inplace_vector<int, 2> ct{11, 22, 33}; > @@ -340,8 +341,10 @@ test_initializer_list() > catch (std::bad_alloc const&) > { > } > +#ifndef __cpp_lib_constexpr_exceptions > } > #endif > +#endif > > #ifdef __cpp_lib_constexpr_inplace_vector > #error remove the consteval check > --- libstdc++-v3/testsuite/23_containers/inplace_vector/cons/from_range.cc.jj > 2025-09-06 11:18:18.069613536 +0200 > +++ libstdc++-v3/testsuite/23_containers/inplace_vector/cons/from_range.cc > 2025-12-04 15:09:32.446163683 +0100 > @@ -41,12 +41,11 @@ do_test_it() > VERIFY( eq<T>(v4, {a, 4}) ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > bounds = typename It::ContainerType(a, a+9); > try > @@ -104,12 +103,11 @@ do_test_r() > VERIFY( eq<T>(v4, {a, 4}) ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > --- > libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/single_insert.cc.jj > 2025-09-06 11:18:18.070613523 +0200 > +++ > libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/single_insert.cc > 2025-12-04 15:09:32.446396820 +0100 > @@ -48,12 +48,11 @@ test_add_to_full() > VERIFY( eq<T>(v, {a, N}) ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > --- > libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/assign.cc.jj > 2025-09-06 11:18:18.070613523 +0200 > +++ libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/assign.cc > 2025-12-04 15:09:32.446627364 +0100 > @@ -60,12 +60,11 @@ test_assign_empty_it() > VERIFY( v.empty() ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > static_assert(N < 9); > > @@ -136,12 +135,11 @@ test_assign_empty_other() > VERIFY( v.empty() ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > static_assert(N < 9); > > --- > libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/multi_insert.cc.jj > 2025-09-06 11:18:18.070613523 +0200 > +++ > libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/multi_insert.cc > 2025-12-04 15:09:32.450381356 +0100 > @@ -105,12 +105,11 @@ test_add_to_full_it() > VERIFY( rit4.base() == a+2 ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > @@ -191,12 +190,11 @@ test_add_to_full_other() > VERIFY( it == v.begin() ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > v = std::inplace_vector<T, N>(std::from_range, std::span(a, a+N)); > try > @@ -249,12 +247,11 @@ test_append_range() > VERIFY( eq<T>(v, {a, 15}) ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > @@ -313,12 +310,11 @@ test_insert_range() > VERIFY( it == v.begin() + 5 ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > const bool seg = std::ranges::sized_range<Range> || > std::ranges::forward_range<Range>; > auto vc = v; > @@ -390,12 +386,11 @@ test_insert_iterators() > VERIFY( it == v.begin() + 5 ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > const bool seg = std::forward_iterator<It>; > auto vc = v; > @@ -457,12 +452,11 @@ test_insert_initializer_list() > VERIFY( it == v.begin() + 5 ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > std::initializer_list<T> il > = {T(0), T(1), T(2), T(3), T(4), T(5), T(6), T(7), T(8), T(9)}; > @@ -520,12 +514,11 @@ test_insert_repeated() > VERIFY( it == v.begin() + 5 ); > > #ifdef __cpp_exceptions > -#ifdef __cpp_lib_constexpr_exceptions > -#error remove the consteval check > -#endif > +#ifndef __cpp_lib_constexpr_exceptions > if consteval { > return; > } > +#endif > > try > { > --- libstdc++-v3/libsupc++/new.jj 2025-11-19 09:38:09.806078452 +0100 > +++ libstdc++-v3/libsupc++/new 2025-12-04 15:09:32.477380882 +0100 > @@ -47,6 +47,7 @@ > #define __glibcxx_want_destroying_delete > #define __glibcxx_want_constexpr_new > #include <bits/version.h> > +#include <bits/new_except.h> // std::bad_alloc, std::bad_array_new_length > > #pragma GCC diagnostic push > #pragma GCC diagnostic ignored "-Wc++11-extensions" // scoped enum > @@ -57,63 +58,6 @@ extern "C++" { > > namespace std > { > - /** > - * @brief Exception possibly thrown by @c new. > - * @ingroup exceptions > - * > - * @c bad_alloc (or classes derived from it) is used to report allocation > - * errors from the throwing forms of @c new. */ > - class bad_alloc : public exception > - { > - public: > - _GLIBCXX26_CONSTEXPR bad_alloc() throw() { } > - > -#if __cplusplus >= 201103L > - _GLIBCXX26_CONSTEXPR bad_alloc(const bad_alloc&) = default; > - _GLIBCXX26_CONSTEXPR bad_alloc& operator=(const bad_alloc&) = default; > -#endif > - > -#if __cplusplus >= 202400L > - constexpr virtual ~bad_alloc() noexcept {} > - > - constexpr virtual const char* what() const noexcept > - { > - return "std::bad_alloc"; > - } > -#else > - // This declaration is not useless: > - // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 > - virtual ~bad_alloc() throw(); > - > - // See comment in eh_exception.cc. > - virtual const char* what() const throw(); > -#endif > - }; > - > -#if __cplusplus >= 201103L > - class bad_array_new_length : public bad_alloc > - { > - public: > - _GLIBCXX26_CONSTEXPR bad_array_new_length() throw() { } > - > -#if __cplusplus >= 202400L > - constexpr virtual ~bad_array_new_length() noexcept {} > - > - constexpr virtual const char* what() const noexcept > - { > - return "std::bad_array_new_length"; > - } > -#else > - // This declaration is not useless: > - // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 > - virtual ~bad_array_new_length() throw(); > - > - // See comment in eh_exception.cc. > - virtual const char* what() const throw(); > -#endif > - }; > -#endif > - > #if __cpp_aligned_new > enum class align_val_t: size_t {}; > #endif > --- libgomp/omp.h.in.jj 2025-06-02 21:58:22.142775820 +0200 > +++ libgomp/omp.h.in 2025-09-06 03:19:29.002729171 +0200 > @@ -439,7 +439,7 @@ extern const char *omp_get_uid_from_devi > #if __cplusplus >= 201103L > > /* std::__throw_bad_alloc and std::__throw_bad_array_new_length. */ > -#include <bits/functexcept.h> > +#include <bits/new_throw.h> > > namespace omp > { > --- gcc/testsuite/g++.dg/tree-ssa/pr110819.C.jj 2025-04-08 14:09:01.684136626 > +0200 > +++ gcc/testsuite/g++.dg/tree-ssa/pr110819.C 2025-09-05 12:42:46.247135888 > +0200 > @@ -11,4 +11,5 @@ void use_idx_const_size_reserve() { > for (std::vector<int>::size_type i = 0; i < s; i++) > f(v[i]); > } > -// { dg-final { scan-tree-dump-not "delete" "optimized" } } > +// For C++26 delete appears in ~bad_array() and ~bad_array_new_length() > dtors. > +// { dg-final { scan-tree-dump-not "delete" "optimized" { target c++23_down > } } } > --- gcc/testsuite/g++.dg/tree-ssa/pr96945.C.jj 2025-04-08 14:09:01.711136251 > +0200 > +++ gcc/testsuite/g++.dg/tree-ssa/pr96945.C 2025-09-05 12:42:46.258135743 > +0200 > @@ -57,4 +57,5 @@ struct c7 { > void foo7(){ > std::vector<c7> vi = {c7(),c7(),c7()}; > } > -// { dg-final { scan-tree-dump-not "delete" "optimized" } } > +// For C++26 delete appears in ~bad_array() and ~bad_array_new_length() > dtors. > +// { dg-final { scan-tree-dump-not "delete" "optimized" { target c++23_down > } } } > --- gcc/testsuite/g++.dg/tree-ssa/pr109442.C.jj 2025-04-08 14:09:01.684136626 > +0200 > +++ gcc/testsuite/g++.dg/tree-ssa/pr109442.C 2025-09-05 12:42:46.269135599 > +0200 > @@ -9,4 +9,5 @@ T vat1(std::vector<T> v1) { > // This should compile to empty function; check that no size of > // vector is determined and there is no allocation > // { dg-final { scan-tree-dump-not "_M_start" "optimized" } } > -// { dg-final { scan-tree-dump-not "delete" "optimized" } } > +// For C++26 delete appears in ~bad_array() and ~bad_array_new_length() > dtors. > +// { dg-final { scan-tree-dump-not "delete" "optimized" { target c++23_down > } } } > --- gcc/testsuite/g++.dg/tree-ssa/pr116868.C.jj 2025-04-08 14:09:01.684136626 > +0200 > +++ gcc/testsuite/g++.dg/tree-ssa/pr116868.C 2025-09-05 12:42:46.281135441 > +0200 > @@ -9,4 +9,5 @@ int sumVector() { > } > return sum; > } > -// { dg-final { scan-tree-dump-not "delete" "optimized" } } > +// For C++26 delete appears in ~bad_array() and ~bad_array_new_length() > dtors. > +// { dg-final { scan-tree-dump-not "delete" "optimized" { target c++23_down > } } } > --- gcc/testsuite/g++.dg/tree-ssa/pr58483.C.jj 2025-04-08 14:09:01.693136501 > +0200 > +++ gcc/testsuite/g++.dg/tree-ssa/pr58483.C 2025-09-05 12:42:46.284135402 > +0200 > @@ -11,4 +11,5 @@ void use_idx_const_size_reserve() { > for (std::vector<int>::size_type i = 0; i < s; i++) > f(v[i]); > } > -// { dg-final { scan-tree-dump-not "delete" "optimized" } } > +// For C++26 delete appears in ~bad_array() and ~bad_array_new_length() > dtors. > +// { dg-final { scan-tree-dump-not "delete" "optimized" { target c++23_down > } } } > > > Jakub >
