https://gcc.gnu.org/g:62c126db6b6017011dcbe6945aab371ab48f8ded
commit r16-6038-g62c126db6b6017011dcbe6945aab371ab48f8ded Author: Jakub Jelinek <[email protected]> Date: Thu Dec 11 19:37:22 2025 +0100 libstdc++: Implement C++26 P3378R2 - constexpr exception types The following patch attempts to implement the C++26 P3378R2 - constexpr exception types paper. This is quite complicated, because most of these classes which should be constexpr-ized use solely or mostly out of line definitions in libstdc++, both for historical, code size and dual ABI reasons, so that one can throw these as exceptions between TUs with old vs. new (or vice versa) ABIs. For this reason, logic_error/runtime_error and classes derived from it have the old ABI std::string object inside of them and the exported APIs from libstdc++.so.6 ensure the right thing. Now, because new invoked during constant evaluation needs to be deleted during the same constant evaluation and can't leak into the constant expressions, I think we don't have to use COW strings under the hood (which aren't constexpr I guess because of reference counting/COW) and we can use something else, the patch uses heap allocated std::string object (where __cow_constexpr_string class has just a pointer to that). As I think we still want to hide the ugly details if !consteval in the library, the patch exports 8 __cow_string class symbols (6 existing which were previously just not exported and 2 new ones) and if !consteval calls those through extern "C" _Zmangled_name symbols. The functions are always_inline. And then logic_error etc. have for C++26 (precisely for __cpp_lib_constexpr_exceptions >= 202502L) constexpr definitions of cdtors/methods. This results in slightly larger code (a few insns at most) at runtime for C++26, e.g. instead of calling say some logic error cdtor/method with 2 arguments it calls some __cow_string one with 2 arguments but + 8 bytes pointer additions on both. The patch also removes the __throw_format_error forward declaration which apparently wasn't needed for anything as all __throw_format_error users were either in <format> or included <format> before the uses, reverts the https://gcc.gnu.org/pipermail/libstdc++/2025-July/062598.html patch and makes sure __throw_* functions (only those for exception types which the P3378R2 or P3068R5 papers made constexpr usable and there are actually constexpr/consteval uses of those) are constexpr for C++26 constexpr exceptions. The patch does that by splitting the bits/functexcept.h header: 1) bits/functexcept.h stays for the __throw_* functions which are (at least for now) never constexpr (the <ios>, <system_error>, <future> and <functional> std::exception derived classes) or are never used or never used in constexpr/consteval contexts (<exception>, <typeinfo> std::exception derived classes and std::range_error). 2) bits/new_{throw,except}.h for __throw_bad_alloc/__throw_bad_array_new_length and std::bad_alloc/std::bad_array_new_length (where <new> includes <bits/new_except.h> and <bits/new_throw.h> as well for the C++26 constexpr exceptions case) 3) for the most complicated <stdexcept> stuff, one header addition to bits/stdexcept.h one header for the __throw_logic_error etc. forward declarations, one header for the __throw_logic_error etc. definitions and one header without header guards which will depending on __glibcxx_exc_in_string include one or the other because <string> vs. <string_view> vs. <stdexcept> have heavy interdependencies 2025-12-11 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/stdexcept_throw.h: New file. * include/bits/stdexcept_throwdef.h: New file. * include/bits/stdexcept_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/bits/basic_ios.h: Include <bits/functexcept.h>. * include/bits/locale_classes.h: Likewise. * 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. Diff: --- gcc/testsuite/g++.dg/tree-ssa/pr109442.C | 3 +- gcc/testsuite/g++.dg/tree-ssa/pr110819.C | 3 +- gcc/testsuite/g++.dg/tree-ssa/pr116868.C | 3 +- gcc/testsuite/g++.dg/tree-ssa/pr58483.C | 3 +- gcc/testsuite/g++.dg/tree-ssa/pr96945.C | 3 +- libgomp/omp.h.in | 2 +- libstdc++-v3/config/abi/pre/gnu.ver | 10 + libstdc++-v3/include/Makefile.am | 6 + libstdc++-v3/include/Makefile.in | 6 + libstdc++-v3/include/bits/basic_ios.h | 1 + libstdc++-v3/include/bits/formatfwd.h | 5 - libstdc++-v3/include/bits/functexcept.h | 63 +-- libstdc++-v3/include/bits/hashtable_policy.h | 1 + libstdc++-v3/include/bits/locale_classes.h | 1 + libstdc++-v3/include/bits/memory_resource.h | 2 +- libstdc++-v3/include/bits/new_allocator.h | 2 +- libstdc++-v3/include/bits/new_except.h | 110 ++++ libstdc++-v3/include/bits/new_throw.h | 76 +++ libstdc++-v3/include/bits/specfun.h | 1 + libstdc++-v3/include/bits/stdexcept_except.h | 552 +++++++++++++++++++++ libstdc++-v3/include/bits/stdexcept_throw.h | 61 +++ libstdc++-v3/include/bits/stdexcept_throwdef.h | 177 +++++++ libstdc++-v3/include/bits/stdexcept_throwfwd.h | 125 +++++ libstdc++-v3/include/bits/stl_algobase.h | 1 - libstdc++-v3/include/bits/stl_map.h | 2 +- libstdc++-v3/include/bits/stl_vector.h | 2 +- libstdc++-v3/include/bits/version.def | 4 +- libstdc++-v3/include/bits/version.h | 3 +- libstdc++-v3/include/experimental/optional | 2 +- libstdc++-v3/include/ext/bitmap_allocator.h | 2 +- libstdc++-v3/include/ext/concurrence.h | 2 +- libstdc++-v3/include/ext/debug_allocator.h | 2 +- libstdc++-v3/include/ext/malloc_allocator.h | 2 +- libstdc++-v3/include/ext/mt_allocator.h | 2 +- libstdc++-v3/include/ext/pool_allocator.h | 2 +- libstdc++-v3/include/ext/ropeimpl.h | 2 +- libstdc++-v3/include/ext/string_conversions.h | 2 +- libstdc++-v3/include/ext/throw_allocator.h | 3 +- libstdc++-v3/include/ext/vstring_util.h | 2 +- libstdc++-v3/include/std/array | 2 +- libstdc++-v3/include/std/bitset | 4 +- libstdc++-v3/include/std/deque | 1 + libstdc++-v3/include/std/expected | 26 +- libstdc++-v3/include/std/flat_map | 2 +- libstdc++-v3/include/std/flat_set | 1 - libstdc++-v3/include/std/format | 15 +- libstdc++-v3/include/std/future | 1 + libstdc++-v3/include/std/inplace_vector | 1 + libstdc++-v3/include/std/optional | 12 +- libstdc++-v3/include/std/shared_mutex | 1 + libstdc++-v3/include/std/stdexcept | 248 +-------- libstdc++-v3/include/std/string | 10 + libstdc++-v3/include/std/string_view | 15 +- libstdc++-v3/include/std/syncstream | 1 - libstdc++-v3/include/std/variant | 19 +- libstdc++-v3/include/tr1/array | 1 + libstdc++-v3/include/tr1/cmath | 1 + libstdc++-v3/include/tr1/memory | 1 - libstdc++-v3/include/tr2/dynamic_bitset | 2 +- libstdc++-v3/libsupc++/new | 58 +-- libstdc++-v3/src/c++11/cow-stdexcept.cc | 10 + libstdc++-v3/src/c++11/functexcept.cc | 1 - libstdc++-v3/src/c++11/regex.cc | 1 - libstdc++-v3/src/c++11/snprintf_lite.cc | 2 +- libstdc++-v3/src/c++11/thread.cc | 1 + libstdc++-v3/src/c++17/floating_from_chars.cc | 1 - .../testsuite/18_support/exception/version.cc | 7 +- .../19_diagnostics/headers/stdexcept/version.cc | 10 + .../19_diagnostics/logic_error/constexpr.cc | 75 +++ .../19_diagnostics/runtime_error/constexpr.cc | 73 +++ libstdc++-v3/testsuite/20_util/allocator/105975.cc | 5 +- .../testsuite/20_util/expected/observers.cc | 11 +- libstdc++-v3/testsuite/20_util/expected/version.cc | 17 + .../20_util/optional/constexpr/observers/3.cc | 33 ++ libstdc++-v3/testsuite/20_util/optional/version.cc | 13 + .../testsuite/20_util/variant/constexpr.cc | 36 ++ libstdc++-v3/testsuite/20_util/variant/version.cc | 17 + .../inplace_vector/access/capacity.cc | 5 +- .../23_containers/inplace_vector/access/elem.cc | 10 +- .../23_containers/inplace_vector/cons/1.cc | 21 +- .../inplace_vector/cons/from_range.cc | 10 +- .../inplace_vector/modifiers/assign.cc | 10 +- .../inplace_vector/modifiers/multi_insert.cc | 35 +- .../inplace_vector/modifiers/single_insert.cc | 5 +- .../testsuite/util/io/verified_cmd_line_input.cc | 2 +- libstdc++-v3/testsuite/util/testsuite_hooks.h | 2 +- 86 files changed, 1611 insertions(+), 475 deletions(-) diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr109442.C b/gcc/testsuite/g++.dg/tree-ssa/pr109442.C index ea5800aa1340..dc335d136567 100644 --- a/gcc/testsuite/g++.dg/tree-ssa/pr109442.C +++ b/gcc/testsuite/g++.dg/tree-ssa/pr109442.C @@ -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 } } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr110819.C b/gcc/testsuite/g++.dg/tree-ssa/pr110819.C index c0e8495ca545..8305589a19d0 100644 --- a/gcc/testsuite/g++.dg/tree-ssa/pr110819.C +++ b/gcc/testsuite/g++.dg/tree-ssa/pr110819.C @@ -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 } } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr116868.C b/gcc/testsuite/g++.dg/tree-ssa/pr116868.C index 1794818f1f01..8580661d35ce 100644 --- a/gcc/testsuite/g++.dg/tree-ssa/pr116868.C +++ b/gcc/testsuite/g++.dg/tree-ssa/pr116868.C @@ -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 } } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr58483.C b/gcc/testsuite/g++.dg/tree-ssa/pr58483.C index c0e8495ca545..8305589a19d0 100644 --- a/gcc/testsuite/g++.dg/tree-ssa/pr58483.C +++ b/gcc/testsuite/g++.dg/tree-ssa/pr58483.C @@ -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 } } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr96945.C b/gcc/testsuite/g++.dg/tree-ssa/pr96945.C index 9fb2cbc2dcce..07c141340c0b 100644 --- a/gcc/testsuite/g++.dg/tree-ssa/pr96945.C +++ b/gcc/testsuite/g++.dg/tree-ssa/pr96945.C @@ -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 } } } diff --git a/libgomp/omp.h.in b/libgomp/omp.h.in index 329d8dc35e07..4e1b95b3475f 100644 --- a/libgomp/omp.h.in +++ b/libgomp/omp.h.in @@ -442,7 +442,7 @@ extern const char *omp_get_uid_from_device (int) __GOMP_NOTHROW; #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 { diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver index 4713ff2208d1..44e487682d45 100644 --- a/libstdc++-v3/config/abi/pre/gnu.ver +++ b/libstdc++-v3/config/abi/pre/gnu.ver @@ -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. diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 847fc13151f5..80f0b8bebd89 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -137,6 +137,8 @@ bits_freestanding = \ ${bits_srcdir}/intcmp.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 \ @@ -155,6 +157,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 \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 1d6171bac9d1..d108eb0155b0 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -495,6 +495,8 @@ bits_freestanding = \ ${bits_srcdir}/intcmp.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 \ @@ -513,6 +515,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 \ diff --git a/libstdc++-v3/include/bits/basic_ios.h b/libstdc++-v3/include/bits/basic_ios.h index ecb3b5619322..f616ccf45266 100644 --- a/libstdc++-v3/include/bits/basic_ios.h +++ b/libstdc++-v3/include/bits/basic_ios.h @@ -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> diff --git a/libstdc++-v3/include/bits/formatfwd.h b/libstdc++-v3/include/bits/formatfwd.h index 883b772752a7..d2dfb17492d1 100644 --- a/libstdc++-v3/include/bits/formatfwd.h +++ b/libstdc++-v3/include/bits/formatfwd.h @@ -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 diff --git a/libstdc++-v3/include/bits/functexcept.h b/libstdc++-v3/include/bits/functexcept.h index b1bf43a586a1..437ba48a6a72 100644 --- a/libstdc++-v3/include/bits/functexcept.h +++ b/libstdc++-v3/include/bits/functexcept.h @@ -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__)); @@ -63,37 +55,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __throw_bad_typeid(void) __attribute__((__noreturn__,__cold__)); // 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 diff --git a/libstdc++-v3/include/bits/hashtable_policy.h b/libstdc++-v3/include/bits/hashtable_policy.h index 048855d5405b..2af314a634d6 100644 --- a/libstdc++-v3/include/bits/hashtable_policy.h +++ b/libstdc++-v3/include/bits/hashtable_policy.h @@ -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 diff --git a/libstdc++-v3/include/bits/locale_classes.h b/libstdc++-v3/include/bits/locale_classes.h index a759b7d91807..c49a12fdc4c2 100644 --- a/libstdc++-v3/include/bits/locale_classes.h +++ b/libstdc++-v3/include/bits/locale_classes.h @@ -38,6 +38,7 @@ #pragma GCC system_header #endif +#include <bits/functexcept.h> #include <bits/localefwd.h> #include <string> #include <ext/atomicity.h> diff --git a/libstdc++-v3/include/bits/memory_resource.h b/libstdc++-v3/include/bits/memory_resource.h index d4ed06c89ff5..5be7fd37832b 100644 --- a/libstdc++-v3/include/bits/memory_resource.h +++ b/libstdc++-v3/include/bits/memory_resource.h @@ -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 diff --git a/libstdc++-v3/include/bits/new_allocator.h b/libstdc++-v3/include/bits/new_allocator.h index 8f1bc57d4058..0948876f0a94 100644 --- a/libstdc++-v3/include/bits/new_allocator.h +++ b/libstdc++-v3/include/bits/new_allocator.h @@ -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> diff --git a/libstdc++-v3/include/bits/new_except.h b/libstdc++-v3/include/bits/new_except.h new file mode 100644 index 000000000000..41cefbf8a5f5 --- /dev/null +++ b/libstdc++-v3/include/bits/new_except.h @@ -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 diff --git a/libstdc++-v3/include/bits/new_throw.h b/libstdc++-v3/include/bits/new_throw.h new file mode 100644 index 000000000000..94afd9ecde6d --- /dev/null +++ b/libstdc++-v3/include/bits/new_throw.h @@ -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 diff --git a/libstdc++-v3/include/bits/specfun.h b/libstdc++-v3/include/bits/specfun.h index 39e26986c9b6..ae649e274016 100644 --- a/libstdc++-v3/include/bits/specfun.h +++ b/libstdc++-v3/include/bits/specfun.h @@ -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> diff --git a/libstdc++-v3/include/bits/stdexcept_except.h b/libstdc++-v3/include/bits/stdexcept_except.h new file mode 100644 index 000000000000..4a6a3b2d7c6b --- /dev/null +++ b/libstdc++-v3/include/bits/stdexcept_except.h @@ -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 */ diff --git a/libstdc++-v3/include/bits/stdexcept_throw.h b/libstdc++-v3/include/bits/stdexcept_throw.h new file mode 100644 index 000000000000..800bdcca35b6 --- /dev/null +++ b/libstdc++-v3/include/bits/stdexcept_throw.h @@ -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 diff --git a/libstdc++-v3/include/bits/stdexcept_throwdef.h b/libstdc++-v3/include/bits/stdexcept_throwdef.h new file mode 100644 index 000000000000..8c319181d094 --- /dev/null +++ b/libstdc++-v3/include/bits/stdexcept_throwdef.h @@ -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 diff --git a/libstdc++-v3/include/bits/stdexcept_throwfwd.h b/libstdc++-v3/include/bits/stdexcept_throwfwd.h new file mode 100644 index 000000000000..57bf899c35e4 --- /dev/null +++ b/libstdc++-v3/include/bits/stdexcept_throwfwd.h @@ -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 diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h index 443cbef76dee..61d050f57dec 100644 --- a/libstdc++-v3/include/bits/stl_algobase.h +++ b/libstdc++-v3/include/bits/stl_algobase.h @@ -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> diff --git a/libstdc++-v3/include/bits/stl_map.h b/libstdc++-v3/include/bits/stl_map.h index 62d66cef6b2e..46cbfbb002d8 100644 --- a/libstdc++-v3/include/bits/stl_map.h +++ b/libstdc++-v3/include/bits/stl_map.h @@ -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> diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index 7625333c9ad8..f914e77097ba 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -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> diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def index ed47cc8bef80..5b95db19ac66 100644 --- a/libstdc++-v3/include/bits/version.def +++ b/libstdc++-v3/include/bits/version.def @@ -2220,10 +2220,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"; }; diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h index a3125b65b358..eee9890a72b0 100644 --- a/libstdc++-v3/include/bits/version.h +++ b/libstdc++-v3/include/bits/version.h @@ -2488,8 +2488,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) */ diff --git a/libstdc++-v3/include/experimental/optional b/libstdc++-v3/include/experimental/optional index 0cee44204d16..5ae576e132e0 100644 --- a/libstdc++-v3/include/experimental/optional +++ b/libstdc++-v3/include/experimental/optional @@ -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> diff --git a/libstdc++-v3/include/ext/bitmap_allocator.h b/libstdc++-v3/include/ext/bitmap_allocator.h index 35c1649f67c3..6e73e193c9d6 100644 --- a/libstdc++-v3/include/ext/bitmap_allocator.h +++ b/libstdc++-v3/include/ext/bitmap_allocator.h @@ -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 diff --git a/libstdc++-v3/include/ext/concurrence.h b/libstdc++-v3/include/ext/concurrence.h index 2c3a893a2f15..2afbc175cc6b 100644 --- a/libstdc++-v3/include/ext/concurrence.h +++ b/libstdc++-v3/include/ext/concurrence.h @@ -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> diff --git a/libstdc++-v3/include/ext/debug_allocator.h b/libstdc++-v3/include/ext/debug_allocator.h index f0c730a2c6df..d0d85c4304ec 100644 --- a/libstdc++-v3/include/ext/debug_allocator.h +++ b/libstdc++-v3/include/ext/debug_allocator.h @@ -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) diff --git a/libstdc++-v3/include/ext/malloc_allocator.h b/libstdc++-v3/include/ext/malloc_allocator.h index 9fef725fff8e..8f36ac2976eb 100644 --- a/libstdc++-v3/include/ext/malloc_allocator.h +++ b/libstdc++-v3/include/ext/malloc_allocator.h @@ -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> diff --git a/libstdc++-v3/include/ext/mt_allocator.h b/libstdc++-v3/include/ext/mt_allocator.h index 6a75349f898a..7b86c1ba5b87 100644 --- a/libstdc++-v3/include/ext/mt_allocator.h +++ b/libstdc++-v3/include/ext/mt_allocator.h @@ -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 diff --git a/libstdc++-v3/include/ext/pool_allocator.h b/libstdc++-v3/include/ext/pool_allocator.h index c40c785d4bfe..ab9319775bd5 100644 --- a/libstdc++-v3/include/ext/pool_allocator.h +++ b/libstdc++-v3/include/ext/pool_allocator.h @@ -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> diff --git a/libstdc++-v3/include/ext/ropeimpl.h b/libstdc++-v3/include/ext/ropeimpl.h index 00b334cb4f4e..f3d199b5a2da 100644 --- a/libstdc++-v3/include/ext/ropeimpl.h +++ b/libstdc++-v3/include/ext/ropeimpl.h @@ -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 diff --git a/libstdc++-v3/include/ext/string_conversions.h b/libstdc++-v3/include/ext/string_conversions.h index a9e478b42760..f44f0dee7284 100644 --- a/libstdc++-v3/include/ext/string_conversions.h +++ b/libstdc++-v3/include/ext/string_conversions.h @@ -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> diff --git a/libstdc++-v3/include/ext/throw_allocator.h b/libstdc++-v3/include/ext/throw_allocator.h index e4c1753f8804..5d5fc3f2aed1 100644 --- a/libstdc++-v3/include/ext/throw_allocator.h +++ b/libstdc++-v3/include/ext/throw_allocator.h @@ -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> diff --git a/libstdc++-v3/include/ext/vstring_util.h b/libstdc++-v3/include/ext/vstring_util.h index c6c7c8f4bba8..a68d1f086ce3 100644 --- a/libstdc++-v3/include/ext/vstring_util.h +++ b/libstdc++-v3/include/ext/vstring_util.h @@ -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> diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array index 12f010921db1..5cc5a9b13e4f 100644 --- a/libstdc++-v3/include/std/array +++ b/libstdc++-v3/include/std/array @@ -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 diff --git a/libstdc++-v3/include/std/bitset b/libstdc++-v3/include/std/bitset index ece359369094..0cf97c907a79 100644 --- a/libstdc++-v3/include/std/bitset +++ b/libstdc++-v3/include/std/bitset @@ -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 diff --git a/libstdc++-v3/include/std/deque b/libstdc++-v3/include/std/deque index 600f607ac7d3..5cd953217f45 100644 --- a/libstdc++-v3/include/std/deque +++ b/libstdc++-v3/include/std/deque @@ -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> diff --git a/libstdc++-v3/include/std/expected b/libstdc++-v3/include/std/expected index a03a7d3f722f..948c2cbe6085 100644 --- a/libstdc++-v3/include/std/expected +++ b/libstdc++-v3/include/std/expected @@ -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); } diff --git a/libstdc++-v3/include/std/flat_map b/libstdc++-v3/include/std/flat_map index e48c3eae07fd..637c3b7fe0d0 100644 --- a/libstdc++-v3/include/std/flat_map +++ b/libstdc++-v3/include/std/flat_map @@ -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> diff --git a/libstdc++-v3/include/std/flat_set b/libstdc++-v3/include/std/flat_set index 3a1f5ba10dad..286290896ae0 100644 --- a/libstdc++-v3/include/std/flat_set +++ b/libstdc++-v3/include/std/flat_set @@ -47,7 +47,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> diff --git a/libstdc++-v3/include/std/format b/libstdc++-v3/include/std/format index f64f35a202e0..2e4463c65969 100644 --- a/libstdc++-v3/include/std/format +++ b/libstdc++-v3/include/std/format @@ -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? diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index 080690064a91..a4dc925dac4f 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -34,6 +34,7 @@ #endif #include <bits/requires_hosted.h> // concurrency +#include <bits/functexcept.h> #if __cplusplus < 201103L # include <bits/c++0x_warning.h> diff --git a/libstdc++-v3/include/std/inplace_vector b/libstdc++-v3/include/std/inplace_vector index 0f7716cb64de..df95c1e5c021 100644 --- a/libstdc++-v3/include/std/inplace_vector +++ b/libstdc++-v3/include/std/inplace_vector @@ -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 diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional index 8b9fa9244213..1703dc9c228a 100644 --- a/libstdc++-v3/include/std/optional +++ b/libstdc++-v3/include/std/optional @@ -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()); } diff --git a/libstdc++-v3/include/std/shared_mutex b/libstdc++-v3/include/std/shared_mutex index 92f6227dafb7..1e2e7b63b62b 100644 --- a/libstdc++-v3/include/std/shared_mutex +++ b/libstdc++-v3/include/std/shared_mutex @@ -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 diff --git a/libstdc++-v3/include/std/stdexcept b/libstdc++-v3/include/std/stdexcept index ea19569df634..522653edb693 100644 --- a/libstdc++-v3/include/std/stdexcept +++ b/libstdc++-v3/include/std/stdexcept @@ -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 diff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string index 918b4158b475..671bad199f58 100644 --- a/libstdc++-v3/include/std/string +++ b/libstdc++-v3/include/std/string @@ -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 diff --git a/libstdc++-v3/include/std/string_view b/libstdc++-v3/include/std/string_view index b226544fa6f2..da9085b039d7 100644 --- a/libstdc++-v3/include/std/string_view +++ b/libstdc++-v3/include/std/string_view @@ -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 diff --git a/libstdc++-v3/include/std/syncstream b/libstdc++-v3/include/std/syncstream index 1e1759714c69..22a8298ef011 100644 --- a/libstdc++-v3/include/std/syncstream +++ b/libstdc++-v3/include/std/syncstream @@ -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) diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant index f2f55837461b..51d21daf46c3 100644 --- a/libstdc++-v3/include/std/variant +++ b/libstdc++-v3/include/std/variant @@ -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 @@ -1410,24 +1411,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", @@ -1437,6 +1447,7 @@ namespace __detail::__variant }; _GLIBCXX_THROW_OR_ABORT(bad_variant_access(__reasons[__n % 4u])); } +#undef _GLIBCXX_CONSTEXPR_BAD_VARIANT_ACCESS }; template<typename... _Types> diff --git a/libstdc++-v3/include/tr1/array b/libstdc++-v3/include/tr1/array index 118442bd98dc..1622c77b3853 100644 --- a/libstdc++-v3/include/tr1/array +++ b/libstdc++-v3/include/tr1/array @@ -34,6 +34,7 @@ #endif #include <bits/requires_hosted.h> // TR1 +#include <bits/stdexcept_throw.h> #include <bits/stl_algobase.h> diff --git a/libstdc++-v3/include/tr1/cmath b/libstdc++-v3/include/tr1/cmath index e97e03ca3ed5..8339ea14c4b9 100644 --- a/libstdc++-v3/include/tr1/cmath +++ b/libstdc++-v3/include/tr1/cmath @@ -34,6 +34,7 @@ #endif #include <bits/requires_hosted.h> // TR1 +#include <bits/stdexcept_throw.h> #include <cmath> diff --git a/libstdc++-v3/include/tr1/memory b/libstdc++-v3/include/tr1/memory index 760d7d1212a6..9b0d1866a0d4 100644 --- a/libstdc++-v3/include/tr1/memory +++ b/libstdc++-v3/include/tr1/memory @@ -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> diff --git a/libstdc++-v3/include/tr2/dynamic_bitset b/libstdc++-v3/include/tr2/dynamic_bitset index b308e7283c2b..a07818125ecb 100644 --- a/libstdc++-v3/include/tr2/dynamic_bitset +++ b/libstdc++-v3/include/tr2/dynamic_bitset @@ -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> diff --git a/libstdc++-v3/libsupc++/new b/libstdc++-v3/libsupc++/new index 018adc0c4ede..1db8e84d5e1b 100644 --- a/libstdc++-v3/libsupc++/new +++ b/libstdc++-v3/libsupc++/new @@ -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 diff --git a/libstdc++-v3/src/c++11/cow-stdexcept.cc b/libstdc++-v3/src/c++11/cow-stdexcept.cc index 0afa3580fd31..163ab5fc5978 100644 --- a/libstdc++-v3/src/c++11/cow-stdexcept.cc +++ b/libstdc++-v3/src/c++11/cow-stdexcept.cc @@ -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), diff --git a/libstdc++-v3/src/c++11/functexcept.cc b/libstdc++-v3/src/c++11/functexcept.cc index 6f876584e7ca..aafa9ef9c351 100644 --- a/libstdc++-v3/src/c++11/functexcept.cc +++ b/libstdc++-v3/src/c++11/functexcept.cc @@ -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> diff --git a/libstdc++-v3/src/c++11/regex.cc b/libstdc++-v3/src/c++11/regex.cc index ae181d6e7423..007abf52d80b 100644 --- a/libstdc++-v3/src/c++11/regex.cc +++ b/libstdc++-v3/src/c++11/regex.cc @@ -24,7 +24,6 @@ #include <stdexcept> #include <bits/regex_error.h> -#include <bits/functexcept.h> namespace std _GLIBCXX_VISIBILITY(default) { diff --git a/libstdc++-v3/src/c++11/snprintf_lite.cc b/libstdc++-v3/src/c++11/snprintf_lite.cc index 8b72fdb4844e..955691c3ceb7 100644 --- a/libstdc++-v3/src/c++11/snprintf_lite.cc +++ b/libstdc++-v3/src/c++11/snprintf_lite.cc @@ -25,7 +25,7 @@ #include <stdarg.h> #include <stddef.h> -#include <bits/functexcept.h> +#include <bits/stdexcept_throw.h> namespace __gnu_cxx { diff --git a/libstdc++-v3/src/c++11/thread.cc b/libstdc++-v3/src/c++11/thread.cc index 5cfe56453af6..64ffd8fc0b41 100644 --- a/libstdc++-v3/src/c++11/thread.cc +++ b/libstdc++-v3/src/c++11/thread.cc @@ -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 diff --git a/libstdc++-v3/src/c++17/floating_from_chars.cc b/libstdc++-v3/src/c++17/floating_from_chars.cc index 9bad12c7f69e..d759df7d61e9 100644 --- a/libstdc++-v3/src/c++17/floating_from_chars.cc +++ b/libstdc++-v3/src/c++17/floating_from_chars.cc @@ -45,7 +45,6 @@ #include <cstdlib> #include <cstring> #include <locale.h> -#include <bits/functexcept.h> #if _GLIBCXX_HAVE_XLOCALE_H # include <xlocale.h> #endif diff --git a/libstdc++-v3/testsuite/18_support/exception/version.cc b/libstdc++-v3/testsuite/18_support/exception/version.cc index 5707abd732f5..a1cf532cd3f6 100644 --- a/libstdc++-v3/testsuite/18_support/exception/version.cc +++ b/libstdc++-v3/testsuite/18_support/exception/version.cc @@ -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 - diff --git a/libstdc++-v3/testsuite/19_diagnostics/headers/stdexcept/version.cc b/libstdc++-v3/testsuite/19_diagnostics/headers/stdexcept/version.cc new file mode 100644 index 000000000000..ab2b9a5e9ea4 --- /dev/null +++ b/libstdc++-v3/testsuite/19_diagnostics/headers/stdexcept/version.cc @@ -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 diff --git a/libstdc++-v3/testsuite/19_diagnostics/logic_error/constexpr.cc b/libstdc++-v3/testsuite/19_diagnostics/logic_error/constexpr.cc new file mode 100644 index 000000000000..ae37b82ab8df --- /dev/null +++ b/libstdc++-v3/testsuite/19_diagnostics/logic_error/constexpr.cc @@ -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>(); +} diff --git a/libstdc++-v3/testsuite/19_diagnostics/runtime_error/constexpr.cc b/libstdc++-v3/testsuite/19_diagnostics/runtime_error/constexpr.cc new file mode 100644 index 000000000000..a7d96eb73a3c --- /dev/null +++ b/libstdc++-v3/testsuite/19_diagnostics/runtime_error/constexpr.cc @@ -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>(); +} diff --git a/libstdc++-v3/testsuite/20_util/allocator/105975.cc b/libstdc++-v3/testsuite/20_util/allocator/105975.cc index 86e855423428..ccbcfe3cb35c 100644 --- a/libstdc++-v3/testsuite/20_util/allocator/105975.cc +++ b/libstdc++-v3/testsuite/20_util/allocator/105975.cc @@ -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 } diff --git a/libstdc++-v3/testsuite/20_util/expected/observers.cc b/libstdc++-v3/testsuite/20_util/expected/observers.cc index 35cc3d8f5a3f..31aaca352ae8 100644 --- a/libstdc++-v3/testsuite/20_util/expected/observers.cc +++ b/libstdc++-v3/testsuite/20_util/expected/observers.cc @@ -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(); diff --git a/libstdc++-v3/testsuite/20_util/expected/version.cc b/libstdc++-v3/testsuite/20_util/expected/version.cc index 682835ca355f..aacd61b7f0a9 100644 --- a/libstdc++-v3/testsuite/20_util/expected/version.cc +++ b/libstdc++-v3/testsuite/20_util/expected/version.cc @@ -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 diff --git a/libstdc++-v3/testsuite/20_util/optional/constexpr/observers/3.cc b/libstdc++-v3/testsuite/20_util/optional/constexpr/observers/3.cc index afdac8da63e9..6c9f494c1f7d 100644 --- a/libstdc++-v3/testsuite/20_util/optional/constexpr/observers/3.cc +++ b/libstdc++-v3/testsuite/20_util/optional/constexpr/observers/3.cc @@ -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 } }; diff --git a/libstdc++-v3/testsuite/20_util/optional/version.cc b/libstdc++-v3/testsuite/20_util/optional/version.cc index ae9339a01af8..f59cb9966fb7 100644 --- a/libstdc++-v3/testsuite/20_util/optional/version.cc +++ b/libstdc++-v3/testsuite/20_util/optional/version.cc @@ -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 diff --git a/libstdc++-v3/testsuite/20_util/variant/constexpr.cc b/libstdc++-v3/testsuite/20_util/variant/constexpr.cc index 886fd2dab5cd..95ca60b521f8 100644 --- a/libstdc++-v3/testsuite/20_util/variant/constexpr.cc +++ b/libstdc++-v3/testsuite/20_util/variant/constexpr.cc @@ -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() { diff --git a/libstdc++-v3/testsuite/20_util/variant/version.cc b/libstdc++-v3/testsuite/20_util/variant/version.cc index f7985322cc5c..8c4f08a2e59a 100644 --- a/libstdc++-v3/testsuite/20_util/variant/version.cc +++ b/libstdc++-v3/testsuite/20_util/variant/version.cc @@ -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 diff --git a/libstdc++-v3/testsuite/23_containers/inplace_vector/access/capacity.cc b/libstdc++-v3/testsuite/23_containers/inplace_vector/access/capacity.cc index 2797e205971d..ef3e28cb6162 100644 --- a/libstdc++-v3/testsuite/23_containers/inplace_vector/access/capacity.cc +++ b/libstdc++-v3/testsuite/23_containers/inplace_vector/access/capacity.cc @@ -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 { diff --git a/libstdc++-v3/testsuite/23_containers/inplace_vector/access/elem.cc b/libstdc++-v3/testsuite/23_containers/inplace_vector/access/elem.cc index bc06aa094251..5b3f4b7c1592 100644 --- a/libstdc++-v3/testsuite/23_containers/inplace_vector/access/elem.cc +++ b/libstdc++-v3/testsuite/23_containers/inplace_vector/access/elem.cc @@ -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 { diff --git a/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/1.cc b/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/1.cc index 45685c2beccf..2982af277858 100644 --- a/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/1.cc +++ b/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/1.cc @@ -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 diff --git a/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/from_range.cc b/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/from_range.cc index 4a2f193e4a58..b79434dd1119 100644 --- a/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/from_range.cc +++ b/libstdc++-v3/testsuite/23_containers/inplace_vector/cons/from_range.cc @@ -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 { diff --git a/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/assign.cc b/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/assign.cc index 65b505e7f371..c1d867ee1d41 100644 --- a/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/assign.cc +++ b/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/assign.cc @@ -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); diff --git a/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/multi_insert.cc b/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/multi_insert.cc index 6a5b62f0aff3..454163892add 100644 --- a/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/multi_insert.cc +++ b/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/multi_insert.cc @@ -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 { diff --git a/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/single_insert.cc b/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/single_insert.cc index d5e893cc7f38..92bd765982e2 100644 --- a/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/single_insert.cc +++ b/libstdc++-v3/testsuite/23_containers/inplace_vector/modifiers/single_insert.cc @@ -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 { diff --git a/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc b/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc index 580b8ae8041a..f7d984e9ffa4 100644 --- a/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc +++ b/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc @@ -38,7 +38,7 @@ #include <limits.h> #include <utility> #include <stdlib.h> -#include <bits/functexcept.h> +#include <bits/exception_defines.h> namespace __gnu_pbds { diff --git a/libstdc++-v3/testsuite/util/testsuite_hooks.h b/libstdc++-v3/testsuite/util/testsuite_hooks.h index bf34fd121c1b..974450610311 100644 --- a/libstdc++-v3/testsuite/util/testsuite_hooks.h +++ b/libstdc++-v3/testsuite/util/testsuite_hooks.h @@ -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>
