From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2181) id E7F853850235; Fri, 14 Oct 2022 14:36:38 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org E7F853850235 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1665758198; bh=VrV+Ck5jiWygh95ewwGyAfmG4yPHMHPn9iaonSg4xFU=; h=From:To:Subject:Date:From; b=J2/Lj2/lHtQqhA8fMa7X2qigxpdYK3yeJbzYNXLW4euuFlQCbLbTie2fK5rnzRWVi 4W9UwCAAuNDSZ8AHHCryp7ecmOx3whRTAySs5QWeNP5hxzOEWUL6AiuEknD2F9o+df kzRgjhrbhOzfV2MzZEOYQmbijVDAAXOmEwHTQK2I= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jonathan Wakely To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc r13-3304] libstdc++: Disable all emergency EH pool code if obj-count == 0 X-Act-Checkin: gcc X-Git-Author: Jonathan Wakely X-Git-Refname: refs/heads/master X-Git-Oldrev: cf0b7e9787c3686c47219a725f2cbcaa19faaaca X-Git-Newrev: 0dd9dd1fdfca1219bbe3ac460b50c6776b427119 Message-Id: <20221014143638.E7F853850235@sourceware.org> Date: Fri, 14 Oct 2022 14:36:38 +0000 (GMT) List-Id: https://gcc.gnu.org/g:0dd9dd1fdfca1219bbe3ac460b50c6776b427119 commit r13-3304-g0dd9dd1fdfca1219bbe3ac460b50c6776b427119 Author: Jonathan Wakely Date: Wed Oct 12 23:04:53 2022 +0100 libstdc++: Disable all emergency EH pool code if obj-count == 0 For a zero-sized static pool we can completely elide all code for the EH pool. We no longer need to adjust the static buffer size to ensure at least one free_entry can be created in it, because we no longer use a static buffer at all if obj_count == 0. If the buffer exists, obj_count >= 1 and the buffer will be much larger than sizeof(free_entry). libstdc++-v3/ChangeLog: * libsupc++/eh_alloc.cc [USE_POOL]: New macro. [!USE_POOL] (__gnu_cxx::__freeres, pool): Do not define. [_GLIBCXX_EH_POOL_STATIC] (pool::arena): Do not use std::max. (__cxxabiv1::__cxa_allocate_exception) [!USE_POOL]: Do not use pool. (__cxxabiv1::__cxa_free_exception) [!USE_POOL]: Likewise. (__cxxabiv1::__cxa_allocate_dependent_exception) [!USE_POOL]: Likewise. (__cxxabiv1::__cxa_free_dependent_exception) [!USE_POOL]: Likewise. Diff: --- libstdc++-v3/libsupc++/eh_alloc.cc | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/libstdc++-v3/libsupc++/eh_alloc.cc b/libstdc++-v3/libsupc++/eh_alloc.cc index 81b8a1548c6..e93f14c887b 100644 --- a/libstdc++-v3/libsupc++/eh_alloc.cc +++ b/libstdc++-v3/libsupc++/eh_alloc.cc @@ -101,12 +101,21 @@ using namespace __cxxabiv1; #ifdef _GLIBCXX_EH_POOL_NOBJS # if _GLIBCXX_EH_POOL_NOBJS > MAX_OBJ_COUNT # warning "_GLIBCXX_EH_POOL_NOBJS value is too large; ignoring it" +# elif _GLIBCXX_EH_POOL_NOBJS < 0 +# warning "_GLIBCXX_EH_POOL_NOBJS value is negative; ignoring it" # else # undef EMERGENCY_OBJ_COUNT # define EMERGENCY_OBJ_COUNT _GLIBCXX_EH_POOL_NOBJS # endif #endif +#if defined _GLIBCXX_EH_POOL_STATIC && EMERGENCY_OBJ_COUNT == 0 +# define USE_POOL 0 +#else +# define USE_POOL 1 +#endif + +#if USE_POOL namespace __gnu_cxx { void __freeres() noexcept; @@ -161,7 +170,7 @@ namespace #ifdef _GLIBCXX_EH_POOL_STATIC static constexpr std::size_t arena_size = buffer_size_in_bytes(EMERGENCY_OBJ_COUNT, EMERGENCY_OBJ_SIZE); - alignas(void*) char arena[std::max(arena_size, sizeof(free_entry))]; + alignas(void*) char arena[arena_size]; #else char *arena = nullptr; std::size_t arena_size = 0; @@ -374,6 +383,7 @@ namespace __gnu_cxx #endif } } +#endif // USE_POOL extern "C" void * __cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size) noexcept @@ -382,8 +392,10 @@ __cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size) noexcept void *ret = malloc (thrown_size); +#if USE_POOL if (!ret) ret = emergency_pool.allocate (thrown_size); +#endif if (!ret) std::terminate (); @@ -398,9 +410,11 @@ extern "C" void __cxxabiv1::__cxa_free_exception(void *vptr) noexcept { char *ptr = (char *) vptr - sizeof (__cxa_refcounted_exception); +#if USE_POOL if (emergency_pool.in_pool (ptr)) [[__unlikely__]] emergency_pool.free (ptr); else +#endif free (ptr); } @@ -410,8 +424,10 @@ __cxxabiv1::__cxa_allocate_dependent_exception() noexcept { void *ret = malloc (sizeof (__cxa_dependent_exception)); +#if USE_POOL if (!ret) ret = emergency_pool.allocate (sizeof (__cxa_dependent_exception)); +#endif if (!ret) std::terminate (); @@ -426,8 +442,10 @@ extern "C" void __cxxabiv1::__cxa_free_dependent_exception (__cxa_dependent_exception *vptr) noexcept { +#if USE_POOL if (emergency_pool.in_pool (vptr)) [[__unlikely__]] emergency_pool.free (vptr); else +#endif free (vptr); }