diff mbox series

Mark asm goto with outputs as volatile

Message ID 20230627032449.37404-1-apinski@marvell.com
State Accepted
Headers
Series Mark asm goto with outputs as volatile |

Checks

Context Check Description
snail/gcc-patch-check success Github commit url

Commit Message

Andrew Pinski June 27, 2023, 3:24 a.m. UTC 
  The manual references asm goto as being implicitly volatile already
and that was done when asm goto could not have outputs. When outputs
were added to `asm goto`, only asm goto without outputs were still being
marked as volatile. Now some parts of GCC decide, removing the `asm goto`
is ok if the output is not used, though not updating the CFG (this happens
on both the RTL level and the gimple level). Since the biggest user of `asm goto`
is the Linux kernel and they expect them to be volatile (they use them to
copy to/from userspace), we should just mark the inline-asm as volatile.

OK? Bootstrapped and tested on x86_64-linux-gnu.

	PR middle-end/110420
	PR middle-end/103979
	PR middle-end/98619

gcc/ChangeLog:

	* gimplify.cc (gimplify_asm_expr): Mark asm with labels as volatile.

gcc/testsuite/ChangeLog:

	* gcc.c-torture/compile/asmgoto-6.c: New test.
---
 gcc/gimplify.cc                               |  7 ++++-
 .../gcc.c-torture/compile/asmgoto-6.c         | 26 +++++++++++++++++++
 2 files changed, 32 insertions(+), 1 deletion(-)
 create mode 100644 gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c

Comments

Richard Biener June 27, 2023, 7:13 a.m. UTC | #1 
On Tue, Jun 27, 2023 at 5:26 AM Andrew Pinski via Gcc-patches
<gcc-patches@gcc.gnu.org> wrote:
>
> The manual references asm goto as being implicitly volatile already
> and that was done when asm goto could not have outputs. When outputs
> were added to `asm goto`, only asm goto without outputs were still being
> marked as volatile. Now some parts of GCC decide, removing the `asm goto`
> is ok if the output is not used, though not updating the CFG (this happens
> on both the RTL level and the gimple level). Since the biggest user of `asm goto`
> is the Linux kernel and they expect them to be volatile (they use them to
> copy to/from userspace), we should just mark the inline-asm as volatile.
>
> OK? Bootstrapped and tested on x86_64-linux-gnu.

OK.

>         PR middle-end/110420
>         PR middle-end/103979
>         PR middle-end/98619
>
> gcc/ChangeLog:
>
>         * gimplify.cc (gimplify_asm_expr): Mark asm with labels as volatile.
>
> gcc/testsuite/ChangeLog:
>
>         * gcc.c-torture/compile/asmgoto-6.c: New test.
> ---
>  gcc/gimplify.cc                               |  7 ++++-
>  .../gcc.c-torture/compile/asmgoto-6.c         | 26 +++++++++++++++++++
>  2 files changed, 32 insertions(+), 1 deletion(-)
>  create mode 100644 gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
>
> diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
> index 0e24b915b8f..dc6a00e8bd9 100644
> --- a/gcc/gimplify.cc
> +++ b/gcc/gimplify.cc
> @@ -6935,7 +6935,12 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
>        stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
>                                    inputs, outputs, clobbers, labels);
>
> -      gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
> +      /* asm is volatile if it was marked by the user as volatile or
> +        there is no outputs or this is an asm goto.  */
> +      gimple_asm_set_volatile (stmt,
> +                              ASM_VOLATILE_P (expr)
> +                              || noutputs == 0
> +                              || labels);
>        gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
>        gimple_asm_set_inline (stmt, ASM_INLINE_P (expr));
>
> diff --git a/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c b/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
> new file mode 100644
> index 00000000000..0652bd4e4e1
> --- /dev/null
> +++ b/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
> @@ -0,0 +1,26 @@
> +
> +/* { dg-do compile } */
> +/* PR middle-end/110420 */
> +/* PR middle-end/103979 */
> +/* PR middle-end/98619 */
> +/* Test that the middle-end does not remove the asm goto
> +   with an output. */
> +
> +static int t;
> +void g(void);
> +
> +void f(void)
> +{
> +  int  __gu_val;
> +  asm goto("#my asm "
> +     : "=&r"(__gu_val)
> +     :
> +     :
> +     : Efault);
> +  t = __gu_val;
> +  g();
> +Efault:
> +}
> +
> +/* Make sure "my asm " is still in the assembly. */
> +/* { dg-final { scan-assembler "my asm " } } */
> --
> 2.31.1
>
Andreas Schwab June 27, 2023, 7:36 a.m. UTC | #2 
On Jun 26 2023, Andrew Pinski via Gcc-patches wrote:

> diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
> index 0e24b915b8f..dc6a00e8bd9 100644
> --- a/gcc/gimplify.cc
> +++ b/gcc/gimplify.cc
> @@ -6935,7 +6935,12 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
>        stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
>  				   inputs, outputs, clobbers, labels);
>  
> -      gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
> +      /* asm is volatile if it was marked by the user as volatile or
> +	 there is no outputs or this is an asm goto.  */
               are
Andrew Pinski June 27, 2023, 5:23 p.m. UTC | #3 
On Tue, Jun 27, 2023 at 12:14 AM Richard Biener via Gcc-patches
<gcc-patches@gcc.gnu.org> wrote:
>
> On Tue, Jun 27, 2023 at 5:26 AM Andrew Pinski via Gcc-patches
> <gcc-patches@gcc.gnu.org> wrote:
> >
> > The manual references asm goto as being implicitly volatile already
> > and that was done when asm goto could not have outputs. When outputs
> > were added to `asm goto`, only asm goto without outputs were still being
> > marked as volatile. Now some parts of GCC decide, removing the `asm goto`
> > is ok if the output is not used, though not updating the CFG (this happens
> > on both the RTL level and the gimple level). Since the biggest user of `asm goto`
> > is the Linux kernel and they expect them to be volatile (they use them to
> > copy to/from userspace), we should just mark the inline-asm as volatile.
> >
> > OK? Bootstrapped and tested on x86_64-linux-gnu.
>
> OK.

Committed to GCC 12 and GCC 13 branches also.

Thanks,
Andrew

>
> >         PR middle-end/110420
> >         PR middle-end/103979
> >         PR middle-end/98619
> >
> > gcc/ChangeLog:
> >
> >         * gimplify.cc (gimplify_asm_expr): Mark asm with labels as volatile.
> >
> > gcc/testsuite/ChangeLog:
> >
> >         * gcc.c-torture/compile/asmgoto-6.c: New test.
> > ---
> >  gcc/gimplify.cc                               |  7 ++++-
> >  .../gcc.c-torture/compile/asmgoto-6.c         | 26 +++++++++++++++++++
> >  2 files changed, 32 insertions(+), 1 deletion(-)
> >  create mode 100644 gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
> >
> > diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
> > index 0e24b915b8f..dc6a00e8bd9 100644
> > --- a/gcc/gimplify.cc
> > +++ b/gcc/gimplify.cc
> > @@ -6935,7 +6935,12 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
> >        stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
> >                                    inputs, outputs, clobbers, labels);
> >
> > -      gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
> > +      /* asm is volatile if it was marked by the user as volatile or
> > +        there is no outputs or this is an asm goto.  */
> > +      gimple_asm_set_volatile (stmt,
> > +                              ASM_VOLATILE_P (expr)
> > +                              || noutputs == 0
> > +                              || labels);
> >        gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
> >        gimple_asm_set_inline (stmt, ASM_INLINE_P (expr));
> >
> > diff --git a/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c b/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
> > new file mode 100644
> > index 00000000000..0652bd4e4e1
> > --- /dev/null
> > +++ b/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
> > @@ -0,0 +1,26 @@
> > +
> > +/* { dg-do compile } */
> > +/* PR middle-end/110420 */
> > +/* PR middle-end/103979 */
> > +/* PR middle-end/98619 */
> > +/* Test that the middle-end does not remove the asm goto
> > +   with an output. */
> > +
> > +static int t;
> > +void g(void);
> > +
> > +void f(void)
> > +{
> > +  int  __gu_val;
> > +  asm goto("#my asm "
> > +     : "=&r"(__gu_val)
> > +     :
> > +     :
> > +     : Efault);
> > +  t = __gu_val;
> > +  g();
> > +Efault:
> > +}
> > +
> > +/* Make sure "my asm " is still in the assembly. */
> > +/* { dg-final { scan-assembler "my asm " } } */
> > --
> > 2.31.1
> >
Jeff Law June 28, 2023, 4:20 p.m. UTC | #4 
On 6/27/23 11:23, Andrew Pinski via Gcc-patches wrote:
> On Tue, Jun 27, 2023 at 12:14 AM Richard Biener via Gcc-patches
> <gcc-patches@gcc.gnu.org> wrote:
>>
>> On Tue, Jun 27, 2023 at 5:26 AM Andrew Pinski via Gcc-patches
>> <gcc-patches@gcc.gnu.org> wrote:
>>>
>>> The manual references asm goto as being implicitly volatile already
>>> and that was done when asm goto could not have outputs. When outputs
>>> were added to `asm goto`, only asm goto without outputs were still being
>>> marked as volatile. Now some parts of GCC decide, removing the `asm goto`
>>> is ok if the output is not used, though not updating the CFG (this happens
>>> on both the RTL level and the gimple level). Since the biggest user of `asm goto`
>>> is the Linux kernel and they expect them to be volatile (they use them to
>>> copy to/from userspace), we should just mark the inline-asm as volatile.
>>>
>>> OK? Bootstrapped and tested on x86_64-linux-gnu.
>>
>> OK.
> 
> Committed to GCC 12 and GCC 13 branches also.
The test should be conditional on target lra since we don't support asm 
goto on the reload targets.

It looks like gcc.dg/pr108095.c needs similar adjustment.  Consider a 
patch to make those adjustments pre-approved.

jeff
diff mbox series

Patch

diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
index 0e24b915b8f..dc6a00e8bd9 100644
--- a/gcc/gimplify.cc
+++ b/gcc/gimplify.cc
@@ -6935,7 +6935,12 @@  gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
       stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
 				   inputs, outputs, clobbers, labels);
 
-      gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
+      /* asm is volatile if it was marked by the user as volatile or
+	 there is no outputs or this is an asm goto.  */
+      gimple_asm_set_volatile (stmt,
+			       ASM_VOLATILE_P (expr)
+			       || noutputs == 0
+			       || labels);
       gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
       gimple_asm_set_inline (stmt, ASM_INLINE_P (expr));
 
diff --git a/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c b/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
new file mode 100644
index 00000000000..0652bd4e4e1
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/asmgoto-6.c
@@ -0,0 +1,26 @@ 
+
+/* { dg-do compile } */
+/* PR middle-end/110420 */
+/* PR middle-end/103979 */
+/* PR middle-end/98619 */
+/* Test that the middle-end does not remove the asm goto
+   with an output. */
+
+static int t;
+void g(void);
+
+void f(void)
+{
+  int  __gu_val;
+  asm goto("#my asm "
+     : "=&r"(__gu_val)
+     :
+     :
+     : Efault);
+  t = __gu_val;
+  g();
+Efault:
+}
+
+/* Make sure "my asm " is still in the assembly. */
+/* { dg-final { scan-assembler "my asm " } } */