From: Jason Merrill <jason@redhat.com>
To: gcc-patches@gcc.gnu.org
Cc: libstdc++@gcc.gnu.org
Subject: PING Re: [PATCH RFA (tree-eh)] c++: use __cxa_call_terminate for MUST_NOT_THROW [PR97720]
Date: Fri, 2 Jun 2023 12:56:37 -0400 [thread overview]
Message-ID: <8b75c557-6b03-8456-dc6e-48f1969c7900@redhat.com> (raw)
In-Reply-To: <20230524185559.1285583-1-jason@redhat.com>
Since Jonathan approved the library change, I'm looking for middle-end
approval for the tree-eh change, even without advice on the potential
follow-up.
On 5/24/23 14:55, Jason Merrill wrote:
> Middle-end folks: any thoughts about how best to make the change described in
> the last paragraph below?
>
> Library folks: any thoughts on the changes to __cxa_call_terminate?
>
> -- 8< --
>
> [except.handle]/7 says that when we enter std::terminate due to a throw,
> that is considered an active handler. We already implemented that properly
> for the case of not finding a handler (__cxa_throw calls __cxa_begin_catch
> before std::terminate) and the case of finding a callsite with no landing
> pad (the personality function calls __cxa_call_terminate which calls
> __cxa_begin_catch), but for the case of a throw in a try/catch in a noexcept
> function, we were emitting a cleanup that calls std::terminate directly
> without ever calling __cxa_begin_catch to handle the exception.
>
> A straightforward way to fix this seems to be calling __cxa_call_terminate
> instead. However, that requires exporting it from libstdc++, which we have
> not previously done. Despite the name, it isn't actually part of the ABI
> standard. Nor is __cxa_call_unexpected, as far as I can tell, but that one
> is also used by clang. For this case they use __clang_call_terminate; it
> seems reasonable to me for us to stick with __cxa_call_terminate.
>
> I also change __cxa_call_terminate to take void* for simplicity in the front
> end (and consistency with __cxa_call_unexpected) but that isn't necessary if
> it's undesirable for some reason.
>
> This patch does not fix the issue that representing the noexcept as a
> cleanup is wrong, and confuses the handler search; since it looks like a
> cleanup in the EH tables, the unwinder keeps looking until it finds the
> catch in main(), which it should never have gotten to. Without the
> try/catch in main, the unwinder would reach the end of the stack and say no
> handler was found. The noexcept is a handler, and should be treated as one,
> as it is when the landing pad is omitted.
>
> The best fix for that issue seems to me to be to represent an
> ERT_MUST_NOT_THROW after an ERT_TRY in an action list as though it were an
> ERT_ALLOWED_EXCEPTIONS (since indeed it is an exception-specification). The
> actual code generation shouldn't need to change (apart from the change made
> by this patch), only the action table entry.
>
> PR c++/97720
>
> gcc/cp/ChangeLog:
>
> * cp-tree.h (enum cp_tree_index): Add CPTI_CALL_TERMINATE_FN.
> (call_terminate_fn): New macro.
> * cp-gimplify.cc (gimplify_must_not_throw_expr): Use it.
> * except.cc (init_exception_processing): Set it.
> (cp_protect_cleanup_actions): Return it.
>
> gcc/ChangeLog:
>
> * tree-eh.cc (lower_resx): Pass the exception pointer to the
> failure_decl.
> * except.h: Tweak comment.
>
> libstdc++-v3/ChangeLog:
>
> * libsupc++/eh_call.cc (__cxa_call_terminate): Take void*.
> * config/abi/pre/gnu.ver: Add it.
>
> gcc/testsuite/ChangeLog:
>
> * g++.dg/eh/terminate2.C: New test.
> ---
> gcc/cp/cp-tree.h | 2 ++
> gcc/except.h | 2 +-
> gcc/cp/cp-gimplify.cc | 2 +-
> gcc/cp/except.cc | 5 ++++-
> gcc/testsuite/g++.dg/eh/terminate2.C | 30 ++++++++++++++++++++++++++++
> gcc/tree-eh.cc | 16 ++++++++++++++-
> libstdc++-v3/libsupc++/eh_call.cc | 4 +++-
> libstdc++-v3/config/abi/pre/gnu.ver | 7 +++++++
> 8 files changed, 63 insertions(+), 5 deletions(-)
> create mode 100644 gcc/testsuite/g++.dg/eh/terminate2.C
>
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index a1b882f11fe..a8465a988b5 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -217,6 +217,7 @@ enum cp_tree_index
> definitions. */
> CPTI_ALIGN_TYPE,
> CPTI_TERMINATE_FN,
> + CPTI_CALL_TERMINATE_FN,
> CPTI_CALL_UNEXPECTED_FN,
>
> /* These are lazily inited. */
> @@ -358,6 +359,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
> /* Exception handling function declarations. */
> #define terminate_fn cp_global_trees[CPTI_TERMINATE_FN]
> #define call_unexpected_fn cp_global_trees[CPTI_CALL_UNEXPECTED_FN]
> +#define call_terminate_fn cp_global_trees[CPTI_CALL_TERMINATE_FN]
> #define get_exception_ptr_fn cp_global_trees[CPTI_GET_EXCEPTION_PTR_FN]
> #define begin_catch_fn cp_global_trees[CPTI_BEGIN_CATCH_FN]
> #define end_catch_fn cp_global_trees[CPTI_END_CATCH_FN]
> diff --git a/gcc/except.h b/gcc/except.h
> index 5ecdbc0d1dc..378a9e4cb77 100644
> --- a/gcc/except.h
> +++ b/gcc/except.h
> @@ -155,7 +155,7 @@ struct GTY(()) eh_region_d
> struct eh_region_u_must_not_throw {
> /* A function decl to be invoked if this region is actually reachable
> from within the function, rather than implementable from the runtime.
> - The normal way for this to happen is for there to be a CLEANUP region
> + The normal way for this to happen is for there to be a TRY region
> contained within this MUST_NOT_THROW region. Note that if the
> runtime handles the MUST_NOT_THROW region, we have no control over
> what termination function is called; it will be decided by the
> diff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc
> index 216a6231d6f..853b1e44236 100644
> --- a/gcc/cp/cp-gimplify.cc
> +++ b/gcc/cp/cp-gimplify.cc
> @@ -343,7 +343,7 @@ gimplify_must_not_throw_expr (tree *expr_p, gimple_seq *pre_p)
> gimple *mnt;
>
> gimplify_and_add (body, &try_);
> - mnt = gimple_build_eh_must_not_throw (terminate_fn);
> + mnt = gimple_build_eh_must_not_throw (call_terminate_fn);
> gimple_seq_add_stmt_without_update (&catch_, mnt);
> mnt = gimple_build_try (try_, catch_, GIMPLE_TRY_CATCH);
>
> diff --git a/gcc/cp/except.cc b/gcc/cp/except.cc
> index 91a5e049860..b04eb00d220 100644
> --- a/gcc/cp/except.cc
> +++ b/gcc/cp/except.cc
> @@ -64,6 +64,9 @@ init_exception_processing (void)
> tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
> call_unexpected_fn
> = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
> + call_terminate_fn
> + = push_library_fn (get_identifier ("__cxa_call_terminate"), tmp, NULL_TREE,
> + ECF_NORETURN | ECF_COLD | ECF_NOTHROW);
> }
>
> /* Returns an expression to be executed if an unhandled exception is
> @@ -76,7 +79,7 @@ cp_protect_cleanup_actions (void)
>
> When the destruction of an object during stack unwinding exits
> using an exception ... void terminate(); is called. */
> - return terminate_fn;
> + return call_terminate_fn;
> }
>
> static tree
> diff --git a/gcc/testsuite/g++.dg/eh/terminate2.C b/gcc/testsuite/g++.dg/eh/terminate2.C
> new file mode 100644
> index 00000000000..1c69dab95f8
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/eh/terminate2.C
> @@ -0,0 +1,30 @@
> +// PR c++/97720
> +// { dg-do run }
> +
> +// Test that there is an active exception when we reach the terminate handler.
> +
> +#include <exception>
> +#include <cstdlib>
> +
> +void bad_guy() throw() {
> + try { throw 0; }
> + catch (float) { }
> + // Don't catch int.
> +}
> +
> +void level1() {
> + bad_guy();
> + throw "dead code";
> +}
> +
> +void my_term()
> +{
> + try { throw; }
> + catch(...) { std::exit(0); }
> +}
> +
> +int main() {
> + std::set_terminate (my_term);
> + try { level1(); }
> + catch (int) { }
> +}
> diff --git a/gcc/tree-eh.cc b/gcc/tree-eh.cc
> index 934209d205f..e8ceff36cc6 100644
> --- a/gcc/tree-eh.cc
> +++ b/gcc/tree-eh.cc
> @@ -3382,8 +3382,22 @@ lower_resx (basic_block bb, gresx *stmt,
> lab = gimple_block_label (new_bb);
> gsi2 = gsi_start_bb (new_bb);
>
> + /* Handle failure fns that expect either no arguments or the
> + exception pointer. */
> fn = dst_r->u.must_not_throw.failure_decl;
> - x = gimple_build_call (fn, 0);
> + if (TYPE_ARG_TYPES (TREE_TYPE (fn)) != void_list_node)
> + {
> + tree epfn = builtin_decl_implicit (BUILT_IN_EH_POINTER);
> + src_nr = build_int_cst (integer_type_node, src_r->index);
> + x = gimple_build_call (epfn, 1, src_nr);
> + tree var = create_tmp_var (ptr_type_node);
> + var = make_ssa_name (var, x);
> + gimple_call_set_lhs (x, var);
> + gsi_insert_after (&gsi2, x, GSI_CONTINUE_LINKING);
> + x = gimple_build_call (fn, 1, var);
> + }
> + else
> + x = gimple_build_call (fn, 0);
> gimple_set_location (x, dst_r->u.must_not_throw.failure_loc);
> gsi_insert_after (&gsi2, x, GSI_CONTINUE_LINKING);
>
> diff --git a/libstdc++-v3/libsupc++/eh_call.cc b/libstdc++-v3/libsupc++/eh_call.cc
> index 3cfc71a4ef1..2bec4e83a7d 100644
> --- a/libstdc++-v3/libsupc++/eh_call.cc
> +++ b/libstdc++-v3/libsupc++/eh_call.cc
> @@ -36,8 +36,10 @@ using namespace __cxxabiv1;
> // terminate.
>
> extern "C" void
> -__cxa_call_terminate(_Unwind_Exception* ue_header) throw ()
> +__cxa_call_terminate(void* ue_header_in) throw ()
> {
> + _Unwind_Exception* ue_header
> + = reinterpret_cast<_Unwind_Exception*>(ue_header_in);
>
> if (ue_header)
> {
> diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver
> index 768cd4a4a6c..a2e5f3b4e74 100644
> --- a/libstdc++-v3/config/abi/pre/gnu.ver
> +++ b/libstdc++-v3/config/abi/pre/gnu.ver
> @@ -2841,6 +2841,13 @@ CXXABI_1.3.14 {
>
> } CXXABI_1.3.13;
>
> +CXXABI_1.3.15 {
> +
> + global:
> + __cxa_call_terminate;
> +
> +} CXXABI_1.3.14;
> +
> # Symbols in the support library (libsupc++) supporting transactional memory.
> CXXABI_TM_1 {
>
>
> base-commit: 2738955004256c2e9753364d78a7be340323b74b
next prev parent reply other threads:[~2023-06-02 16:56 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-05-24 18:55 [PATCH RFC] " Jason Merrill
2023-05-26 9:58 ` Jonathan Wakely
2023-06-08 13:13 ` Jonathan Wakely
2023-06-08 14:03 ` Jason Merrill
2023-06-09 9:02 ` Richard Biener
2023-06-09 9:06 ` Jonathan Wakely
2023-06-09 9:09 ` Jakub Jelinek
2023-06-09 12:15 ` Jonathan Wakely
2023-06-02 16:56 ` Jason Merrill [this message]
2023-06-05 6:09 ` PING Re: [PATCH RFA (tree-eh)] " Richard Biener
2023-06-05 19:10 ` Jason Merrill
2023-06-03 14:33 ` [PATCH RFC] " Jeff Law
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=8b75c557-6b03-8456-dc6e-48f1969c7900@redhat.com \
--to=jason@redhat.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=libstdc++@gcc.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).