From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2140) id 0D6E13858284; Mon, 11 Dec 2023 22:08:05 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0D6E13858284 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1702332485; bh=1l0LzUxtqce5fa6tNWIjhkBa8mmahxb29qTofOxXF+M=; h=From:To:Subject:Date:From; b=qaeliYQRYFa+Wrzz2IcpYgQgL/ADtLiFpMeUcTyZVEVyO/rqPvO+MtMtoxvCIbzkK bHLLACINtjjFhSF3AU2k6iKwroCuVRfYyZejM9fteeg6gRVXSmSsV6+PcD2TB4VDsl CpRfELxH1L/Jl0ufP0+eRRxXDm+Zg93naiox3Ma0= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Alexandre Oliva To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/aoliva/heads/testme)] strub: handle volatile promoted args in internal strub X-Act-Checkin: gcc X-Git-Author: Alexandre Oliva X-Git-Refname: refs/users/aoliva/heads/testme X-Git-Oldrev: c35ca3596754ceb1d9229c71c173c8ac7cb74ad9 X-Git-Newrev: 27c64b7546f1651f6c1e1e99f49161551491a33b Message-Id: <20231211220805.0D6E13858284@sourceware.org> Date: Mon, 11 Dec 2023 22:08:05 +0000 (GMT) List-Id: https://gcc.gnu.org/g:27c64b7546f1651f6c1e1e99f49161551491a33b commit 27c64b7546f1651f6c1e1e99f49161551491a33b Author: Alexandre Oliva Date: Mon Dec 11 15:17:03 2023 -0300 strub: handle volatile promoted args in internal strub When generating code for an internal strub wrapper, don't clear the DECL_NOT_GIMPLE_REG_P flag of volatile args, and gimplify them both before and after any conversion. While at that, move variable TMP into narrower scopes so that it's more trivial to track where ARG lives. for gcc/ChangeLog * ipa-strub.cc (pass_ipa_strub::execute): Handle promoted volatile args in internal strub. Simplify. for gcc/testsuite/ChangeLog * c-c++-common/strub-internal-volatile.c: New. Diff: --- gcc/ipa-strub.cc | 29 ++++++++++++++++------ .../c-c++-common/strub-internal-volatile.c | 10 ++++++++ 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/gcc/ipa-strub.cc b/gcc/ipa-strub.cc index 8ec6824e8a8..45294b0b46b 100644 --- a/gcc/ipa-strub.cc +++ b/gcc/ipa-strub.cc @@ -3203,7 +3203,6 @@ pass_ipa_strub::execute (function *) i++, arg = DECL_CHAIN (arg), nparm = DECL_CHAIN (nparm)) { tree save_arg = arg; - tree tmp = arg; /* Arrange to pass indirectly the parms, if we decided to do so, and revert its type in the wrapper. */ @@ -3211,10 +3210,9 @@ pass_ipa_strub::execute (function *) { tree ref_type = TREE_TYPE (nparm); TREE_ADDRESSABLE (arg) = true; - tree addr = build1 (ADDR_EXPR, ref_type, arg); - tmp = arg = addr; + arg = build1 (ADDR_EXPR, ref_type, arg); } - else + else if (!TREE_THIS_VOLATILE (arg)) DECL_NOT_GIMPLE_REG_P (arg) = 0; /* Convert the argument back to the type used by the calling @@ -3223,16 +3221,31 @@ pass_ipa_strub::execute (function *) double to be passed on unchanged to the wrapped function. */ if (TREE_TYPE (nparm) != DECL_ARG_TYPE (nparm)) - arg = fold_convert (DECL_ARG_TYPE (nparm), arg); + { + tree tmp = arg; + /* If ARG is e.g. volatile, we must copy and + convert in separate statements. ??? Should + we drop volatile from the wrapper + instead? */ + if (!is_gimple_val (arg)) + { + tmp = create_tmp_reg (TYPE_MAIN_VARIANT + (TREE_TYPE (arg)), "arg"); + gimple *stmt = gimple_build_assign (tmp, arg); + gsi_insert_after (&bsi, stmt, GSI_NEW_STMT); + } + arg = fold_convert (DECL_ARG_TYPE (nparm), tmp); + } if (!is_gimple_val (arg)) { - tmp = create_tmp_reg (TYPE_MAIN_VARIANT - (TREE_TYPE (arg)), "arg"); + tree tmp = create_tmp_reg (TYPE_MAIN_VARIANT + (TREE_TYPE (arg)), "arg"); gimple *stmt = gimple_build_assign (tmp, arg); gsi_insert_after (&bsi, stmt, GSI_NEW_STMT); + arg = tmp; } - vargs.quick_push (tmp); + vargs.quick_push (arg); arg = save_arg; } /* These strub arguments are adjusted later. */ diff --git a/gcc/testsuite/c-c++-common/strub-internal-volatile.c b/gcc/testsuite/c-c++-common/strub-internal-volatile.c new file mode 100644 index 00000000000..cdfca67616b --- /dev/null +++ b/gcc/testsuite/c-c++-common/strub-internal-volatile.c @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target strub } */ + +void __attribute__ ((strub("internal"))) +f(volatile short) { +} + +void g(void) { + f(0); +}