testsuite: Add new target check for no_alignment_constraints

  A few testcases were marked for avr target, which has no alignment
requirements.  But those tests in fact should filter for any
target having __BIGGEST_ALIGNMENT__=1.

A new effective target check is introduced: no_alignment_constraints.
It checks whether __BIGGEST_ALIGNMENT__ is declared as 1.

Alternative names I considered for the new macro are:
  - !natural_alignment_16
  - biggest_alignment_1

This change fixes the testsuite cases for PRU target.  I don't have
environment to test mm32c and cris targets, which also declare
__BIGGEST_ALIGNMENT__=1.

It was regression-tested on x86_64-pc-linux-gnu.

The following two existing macros were considered, but they check for
subtly different target behaviour:
 1. non_strict_align
    If true, non-aligned access is permitted. But it also allows
    variables to be naturally aligned, which is not true for
    no_alignment_constraints.

 2. default_packed
    Whether structures are packed by default is not necessarily
    the same as lacking constraints for any variable alignment.
    For example, BIGGEST_FIELD_ALIGNMENT or ADJUST_FIELD_ALIGN
    could be defined for a target.

Ok for trunk?

Signed-off-by: Dimitar Dimitrov <dimitar@dinux.eu>
---
 gcc/testsuite/c-c++-common/Wcast-align.c |  4 ++--
 gcc/testsuite/gcc.dg/c11-align-4.c       |  2 +-
 gcc/testsuite/gcc.dg/strlenopt-10.c      |  6 +++---
 gcc/testsuite/gcc.dg/strlenopt-11.c      | 14 +++++++-------
 gcc/testsuite/gcc.dg/strlenopt-13.c      | 16 ++++++++--------
 gcc/testsuite/lib/target-supports.exp    | 13 +++++++++++++
 6 files changed, 34 insertions(+), 21 deletions(-)
  

On Thu, Jun 23, 2022 at 2:24 PM Dimitar Dimitrov <dimitar@dinux.eu> wrote:
>
> A few testcases were marked for avr target, which has no alignment
> requirements.  But those tests in fact should filter for any
> target having __BIGGEST_ALIGNMENT__=1.
>
> A new effective target check is introduced: no_alignment_constraints.
> It checks whether __BIGGEST_ALIGNMENT__ is declared as 1.
>
> Alternative names I considered for the new macro are:
>   - !natural_alignment_16
>   - biggest_alignment_1
>
> This change fixes the testsuite cases for PRU target.  I don't have
> environment to test mm32c and cris targets, which also declare
> __BIGGEST_ALIGNMENT__=1.
>
> It was regression-tested on x86_64-pc-linux-gnu.
>
> The following two existing macros were considered, but they check for
> subtly different target behaviour:
>  1. non_strict_align
>     If true, non-aligned access is permitted. But it also allows
>     variables to be naturally aligned, which is not true for
>     no_alignment_constraints.
>
>  2. default_packed
>     Whether structures are packed by default is not necessarily
>     the same as lacking constraints for any variable alignment.
>     For example, BIGGEST_FIELD_ALIGNMENT or ADJUST_FIELD_ALIGN
>     could be defined for a target.
>
> Ok for trunk?

How is no_alignment_constraints different from default_packed? I
suspect they have the same effect really.

Thanks,
Andrew

>
> Signed-off-by: Dimitar Dimitrov <dimitar@dinux.eu>
> ---
>  gcc/testsuite/c-c++-common/Wcast-align.c |  4 ++--
>  gcc/testsuite/gcc.dg/c11-align-4.c       |  2 +-
>  gcc/testsuite/gcc.dg/strlenopt-10.c      |  6 +++---
>  gcc/testsuite/gcc.dg/strlenopt-11.c      | 14 +++++++-------
>  gcc/testsuite/gcc.dg/strlenopt-13.c      | 16 ++++++++--------
>  gcc/testsuite/lib/target-supports.exp    | 13 +++++++++++++
>  6 files changed, 34 insertions(+), 21 deletions(-)
>
> diff --git a/gcc/testsuite/c-c++-common/Wcast-align.c b/gcc/testsuite/c-c++-common/Wcast-align.c
> index c296c7fd249..1087b10fd99 100644
> --- a/gcc/testsuite/c-c++-common/Wcast-align.c
> +++ b/gcc/testsuite/c-c++-common/Wcast-align.c
> @@ -16,8 +16,8 @@ struct t { double x; } *q;
>  void
>  foo (void)
>  {
> -  y = (c *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" } */
> -  z = (d *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" } */
> +  y = (c *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" "" { target { ! no_alignment_constraints } } } */
> +  z = (d *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" "" { target { ! no_alignment_constraints } } } */
>    (long long *) p;  /* { dg-bogus "alignment" } */
>    (double *) q;     /* { dg-bogus "alignment" } */
>  }
> diff --git a/gcc/testsuite/gcc.dg/c11-align-4.c b/gcc/testsuite/gcc.dg/c11-align-4.c
> index 57f93ff05fc..eb9071b9149 100644
> --- a/gcc/testsuite/gcc.dg/c11-align-4.c
> +++ b/gcc/testsuite/gcc.dg/c11-align-4.c
> @@ -2,7 +2,7 @@
>     are at least some alignment constraints).  */
>  /* { dg-do compile } */
>  /* { dg-options "-std=c11 -pedantic-errors" } */
> -/* { dg-skip-if "no alignment constraints" { "avr-*-*" } } */
> +/* { dg-skip-if "no alignment constraints" { no_alignment_constraints } } */
>
>  #include <stddef.h>
>
> diff --git a/gcc/testsuite/gcc.dg/strlenopt-10.c b/gcc/testsuite/gcc.dg/strlenopt-10.c
> index ce959c34a80..6e2c2597b27 100644
> --- a/gcc/testsuite/gcc.dg/strlenopt-10.c
> +++ b/gcc/testsuite/gcc.dg/strlenopt-10.c
> @@ -70,10 +70,10 @@ main ()
>  }
>
>  /* { dg-final { scan-tree-dump-times "strlen \\(" 2 "strlen1" } } */
> -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
>     to expand the memcpy call at the end of fn2.  */
> -/* { dg-final { scan-tree-dump-times "memcpy \\(" 8 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { avr-*-* } } } } */
> +/* { dg-final { scan-tree-dump-times "memcpy \\(" 8 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { no_alignment_constraints} } } } */
>  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
> diff --git a/gcc/testsuite/gcc.dg/strlenopt-11.c b/gcc/testsuite/gcc.dg/strlenopt-11.c
> index abd9faebed6..952de0730f1 100644
> --- a/gcc/testsuite/gcc.dg/strlenopt-11.c
> +++ b/gcc/testsuite/gcc.dg/strlenopt-11.c
> @@ -59,17 +59,17 @@ main ()
>  }
>
>  /* { dg-final { scan-tree-dump-times "strlen \\(" 3 "strlen1" } } */
> -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
>     to expand the memcpy call at the end of fn1.  */
> -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { avr-*-* } } } } */
> +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { no_alignment_constraints } } } } */
>  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "stpcpy \\(" 0 "strlen1" } } */
>  /* Where the memcpy is expanded, the assignemts to elements of l are
>     propagated.  */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.9. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 3 "strlen1" { target { avr-*-* } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.9. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 3 "strlen1" { target { no_alignment_constraints } } } } */
> diff --git a/gcc/testsuite/gcc.dg/strlenopt-13.c b/gcc/testsuite/gcc.dg/strlenopt-13.c
> index 27ecc79c2d9..4c6d5266780 100644
> --- a/gcc/testsuite/gcc.dg/strlenopt-13.c
> +++ b/gcc/testsuite/gcc.dg/strlenopt-13.c
> @@ -56,18 +56,18 @@ main ()
>  }
>
>  /* { dg-final { scan-tree-dump-times "strlen \\(" 4 "strlen1" } } */
> -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
>     to expand the memcpy call at the end of fn1.  */
> -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { avr-*-* } } } } */
> +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { no_alignment_constraints } } } } */
>  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
>  /* { dg-final { scan-tree-dump-times "stpcpy \\(" 0 "strlen1" } } */
>  /* Where the memcpy is expanded, the assignemts to elements of l are
>     propagated.  */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.1. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.5. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 4 "strlen1" { target { avr-*-* } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.1. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.5. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 4 "strlen1" { target { no_alignment_constraints } } } } */
> diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
> index d1f4eb7641f..a86b151bb9e 100644
> --- a/gcc/testsuite/lib/target-supports.exp
> +++ b/gcc/testsuite/lib/target-supports.exp
> @@ -7541,6 +7541,19 @@ proc check_effective_target_vect_aligned_arrays { } {
>      return $et_vect_aligned_arrays
>  }
>
> +# Return 1 if the biggest alignment required by target is 1 * BITS_PER_UNIT.
> +# In such case the target does not impose any alignment constraints.
> +
> +proc check_effective_target_no_alignment_constraints { } {
> +    return [check_runtime_nocache no_alignment_constraints {
> +        int
> +        main (void)
> +        {
> +          return __BIGGEST_ALIGNMENT__ == 1 ? 0 : 1;
> +        }
> +    }]
> +}
> +
>  # Return 1 if types of size 32 bit or less are naturally aligned
>  # (aligned to their type-size), 0 otherwise.
>  #
> --
> 2.36.1
>
  

On Fri, Jun 24, 2022 at 2:34 AM Andrew Pinski via Gcc-patches
<gcc-patches@gcc.gnu.org> wrote:
>
> On Thu, Jun 23, 2022 at 2:24 PM Dimitar Dimitrov <dimitar@dinux.eu> wrote:
> >
> > A few testcases were marked for avr target, which has no alignment
> > requirements.  But those tests in fact should filter for any
> > target having __BIGGEST_ALIGNMENT__=1.
> >
> > A new effective target check is introduced: no_alignment_constraints.
> > It checks whether __BIGGEST_ALIGNMENT__ is declared as 1.
> >
> > Alternative names I considered for the new macro are:
> >   - !natural_alignment_16
> >   - biggest_alignment_1
> >
> > This change fixes the testsuite cases for PRU target.  I don't have
> > environment to test mm32c and cris targets, which also declare
> > __BIGGEST_ALIGNMENT__=1.
> >
> > It was regression-tested on x86_64-pc-linux-gnu.
> >
> > The following two existing macros were considered, but they check for
> > subtly different target behaviour:
> >  1. non_strict_align
> >     If true, non-aligned access is permitted. But it also allows
> >     variables to be naturally aligned, which is not true for
> >     no_alignment_constraints.
> >
> >  2. default_packed
> >     Whether structures are packed by default is not necessarily
> >     the same as lacking constraints for any variable alignment.
> >     For example, BIGGEST_FIELD_ALIGNMENT or ADJUST_FIELD_ALIGN
> >     could be defined for a target.
> >
> > Ok for trunk?
>
> How is no_alignment_constraints different from default_packed? I
> suspect they have the same effect really.

Different when non-aggregates are involved?  Does default_packed
also apply to scalar types?

Btw, new effective targets should be documented in sourcebuild.texi

Richard.

> Thanks,
> Andrew
>
> >
> > Signed-off-by: Dimitar Dimitrov <dimitar@dinux.eu>
> > ---
> >  gcc/testsuite/c-c++-common/Wcast-align.c |  4 ++--
> >  gcc/testsuite/gcc.dg/c11-align-4.c       |  2 +-
> >  gcc/testsuite/gcc.dg/strlenopt-10.c      |  6 +++---
> >  gcc/testsuite/gcc.dg/strlenopt-11.c      | 14 +++++++-------
> >  gcc/testsuite/gcc.dg/strlenopt-13.c      | 16 ++++++++--------
> >  gcc/testsuite/lib/target-supports.exp    | 13 +++++++++++++
> >  6 files changed, 34 insertions(+), 21 deletions(-)
> >
> > diff --git a/gcc/testsuite/c-c++-common/Wcast-align.c b/gcc/testsuite/c-c++-common/Wcast-align.c
> > index c296c7fd249..1087b10fd99 100644
> > --- a/gcc/testsuite/c-c++-common/Wcast-align.c
> > +++ b/gcc/testsuite/c-c++-common/Wcast-align.c
> > @@ -16,8 +16,8 @@ struct t { double x; } *q;
> >  void
> >  foo (void)
> >  {
> > -  y = (c *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" } */
> > -  z = (d *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" } */
> > +  y = (c *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" "" { target { ! no_alignment_constraints } } } */
> > +  z = (d *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" "" { target { ! no_alignment_constraints } } } */
> >    (long long *) p;  /* { dg-bogus "alignment" } */
> >    (double *) q;     /* { dg-bogus "alignment" } */
> >  }
> > diff --git a/gcc/testsuite/gcc.dg/c11-align-4.c b/gcc/testsuite/gcc.dg/c11-align-4.c
> > index 57f93ff05fc..eb9071b9149 100644
> > --- a/gcc/testsuite/gcc.dg/c11-align-4.c
> > +++ b/gcc/testsuite/gcc.dg/c11-align-4.c
> > @@ -2,7 +2,7 @@
> >     are at least some alignment constraints).  */
> >  /* { dg-do compile } */
> >  /* { dg-options "-std=c11 -pedantic-errors" } */
> > -/* { dg-skip-if "no alignment constraints" { "avr-*-*" } } */
> > +/* { dg-skip-if "no alignment constraints" { no_alignment_constraints } } */
> >
> >  #include <stddef.h>
> >
> > diff --git a/gcc/testsuite/gcc.dg/strlenopt-10.c b/gcc/testsuite/gcc.dg/strlenopt-10.c
> > index ce959c34a80..6e2c2597b27 100644
> > --- a/gcc/testsuite/gcc.dg/strlenopt-10.c
> > +++ b/gcc/testsuite/gcc.dg/strlenopt-10.c
> > @@ -70,10 +70,10 @@ main ()
> >  }
> >
> >  /* { dg-final { scan-tree-dump-times "strlen \\(" 2 "strlen1" } } */
> > -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> > +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
> >     to expand the memcpy call at the end of fn2.  */
> > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 8 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { avr-*-* } } } } */
> > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 8 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { no_alignment_constraints} } } } */
> >  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
> > diff --git a/gcc/testsuite/gcc.dg/strlenopt-11.c b/gcc/testsuite/gcc.dg/strlenopt-11.c
> > index abd9faebed6..952de0730f1 100644
> > --- a/gcc/testsuite/gcc.dg/strlenopt-11.c
> > +++ b/gcc/testsuite/gcc.dg/strlenopt-11.c
> > @@ -59,17 +59,17 @@ main ()
> >  }
> >
> >  /* { dg-final { scan-tree-dump-times "strlen \\(" 3 "strlen1" } } */
> > -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> > +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
> >     to expand the memcpy call at the end of fn1.  */
> > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { avr-*-* } } } } */
> > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { no_alignment_constraints } } } } */
> >  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "stpcpy \\(" 0 "strlen1" } } */
> >  /* Where the memcpy is expanded, the assignemts to elements of l are
> >     propagated.  */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.9. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 3 "strlen1" { target { avr-*-* } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.9. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 3 "strlen1" { target { no_alignment_constraints } } } } */
> > diff --git a/gcc/testsuite/gcc.dg/strlenopt-13.c b/gcc/testsuite/gcc.dg/strlenopt-13.c
> > index 27ecc79c2d9..4c6d5266780 100644
> > --- a/gcc/testsuite/gcc.dg/strlenopt-13.c
> > +++ b/gcc/testsuite/gcc.dg/strlenopt-13.c
> > @@ -56,18 +56,18 @@ main ()
> >  }
> >
> >  /* { dg-final { scan-tree-dump-times "strlen \\(" 4 "strlen1" } } */
> > -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> > +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
> >     to expand the memcpy call at the end of fn1.  */
> > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { avr-*-* } } } } */
> > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { no_alignment_constraints } } } } */
> >  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
> >  /* { dg-final { scan-tree-dump-times "stpcpy \\(" 0 "strlen1" } } */
> >  /* Where the memcpy is expanded, the assignemts to elements of l are
> >     propagated.  */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.1. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.5. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 4 "strlen1" { target { avr-*-* } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.1. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.5. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 4 "strlen1" { target { no_alignment_constraints } } } } */
> > diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
> > index d1f4eb7641f..a86b151bb9e 100644
> > --- a/gcc/testsuite/lib/target-supports.exp
> > +++ b/gcc/testsuite/lib/target-supports.exp
> > @@ -7541,6 +7541,19 @@ proc check_effective_target_vect_aligned_arrays { } {
> >      return $et_vect_aligned_arrays
> >  }
> >
> > +# Return 1 if the biggest alignment required by target is 1 * BITS_PER_UNIT.
> > +# In such case the target does not impose any alignment constraints.
> > +
> > +proc check_effective_target_no_alignment_constraints { } {
> > +    return [check_runtime_nocache no_alignment_constraints {
> > +        int
> > +        main (void)
> > +        {
> > +          return __BIGGEST_ALIGNMENT__ == 1 ? 0 : 1;
> > +        }
> > +    }]
> > +}
> > +
> >  # Return 1 if types of size 32 bit or less are naturally aligned
> >  # (aligned to their type-size), 0 otherwise.
> >  #
> > --
> > 2.36.1
> >
  

On Fri, Jun 24, 2022 at 08:58:49AM +0200, Richard Biener wrote:
> On Fri, Jun 24, 2022 at 2:34 AM Andrew Pinski via Gcc-patches
> <gcc-patches@gcc.gnu.org> wrote:
> >
> > On Thu, Jun 23, 2022 at 2:24 PM Dimitar Dimitrov <dimitar@dinux.eu> wrote:
> > >
> > > A few testcases were marked for avr target, which has no alignment
> > > requirements.  But those tests in fact should filter for any
> > > target having __BIGGEST_ALIGNMENT__=1.
> > >
> > > A new effective target check is introduced: no_alignment_constraints.
> > > It checks whether __BIGGEST_ALIGNMENT__ is declared as 1.
> > >
> > > Alternative names I considered for the new macro are:
> > >   - !natural_alignment_16
> > >   - biggest_alignment_1
> > >
> > > This change fixes the testsuite cases for PRU target.  I don't have
> > > environment to test mm32c and cris targets, which also declare
> > > __BIGGEST_ALIGNMENT__=1.
> > >
> > > It was regression-tested on x86_64-pc-linux-gnu.
> > >
> > > The following two existing macros were considered, but they check for
> > > subtly different target behaviour:
> > >  1. non_strict_align
> > >     If true, non-aligned access is permitted. But it also allows
> > >     variables to be naturally aligned, which is not true for
> > >     no_alignment_constraints.
> > >
> > >  2. default_packed
> > >     Whether structures are packed by default is not necessarily
> > >     the same as lacking constraints for any variable alignment.
> > >     For example, BIGGEST_FIELD_ALIGNMENT or ADJUST_FIELD_ALIGN
> > >     could be defined for a target.
> > >
> > > Ok for trunk?
> >
> > How is no_alignment_constraints different from default_packed? I
> > suspect they have the same effect really.
> 
> Different when non-aggregates are involved?  Does default_packed
> also apply to scalar types?

It is my understanding that aggregates and scalars could have
different alignment constraints.

For example, consider the following target settings combination, which I
found in the vax backend:

#define BIGGEST_ALIGNMENT 32
#define BIGGEST_FIELD_ALIGNMENT 8

I made an experiment and hacked pru-unknonwn-elf with the above change.
This resulted in:

  default_packed=1
  no_alignment_constraints=0

> 
> Btw, new effective targets should be documented in sourcebuild.texi

I'll fix and post a new version.

Thanks,
Dimitar

> 
> Richard.
> 
> > Thanks,
> > Andrew
> >
> > >
> > > Signed-off-by: Dimitar Dimitrov <dimitar@dinux.eu>
> > > ---
> > >  gcc/testsuite/c-c++-common/Wcast-align.c |  4 ++--
> > >  gcc/testsuite/gcc.dg/c11-align-4.c       |  2 +-
> > >  gcc/testsuite/gcc.dg/strlenopt-10.c      |  6 +++---
> > >  gcc/testsuite/gcc.dg/strlenopt-11.c      | 14 +++++++-------
> > >  gcc/testsuite/gcc.dg/strlenopt-13.c      | 16 ++++++++--------
> > >  gcc/testsuite/lib/target-supports.exp    | 13 +++++++++++++
> > >  6 files changed, 34 insertions(+), 21 deletions(-)
> > >
> > > diff --git a/gcc/testsuite/c-c++-common/Wcast-align.c b/gcc/testsuite/c-c++-common/Wcast-align.c
> > > index c296c7fd249..1087b10fd99 100644
> > > --- a/gcc/testsuite/c-c++-common/Wcast-align.c
> > > +++ b/gcc/testsuite/c-c++-common/Wcast-align.c
> > > @@ -16,8 +16,8 @@ struct t { double x; } *q;
> > >  void
> > >  foo (void)
> > >  {
> > > -  y = (c *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" } */
> > > -  z = (d *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" } */
> > > +  y = (c *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" "" { target { ! no_alignment_constraints } } } */
> > > +  z = (d *) x;  /* { dg-warning "7:cast \[^\n\r]* required alignment of target type" "" { target { ! no_alignment_constraints } } } */
> > >    (long long *) p;  /* { dg-bogus "alignment" } */
> > >    (double *) q;     /* { dg-bogus "alignment" } */
> > >  }
> > > diff --git a/gcc/testsuite/gcc.dg/c11-align-4.c b/gcc/testsuite/gcc.dg/c11-align-4.c
> > > index 57f93ff05fc..eb9071b9149 100644
> > > --- a/gcc/testsuite/gcc.dg/c11-align-4.c
> > > +++ b/gcc/testsuite/gcc.dg/c11-align-4.c
> > > @@ -2,7 +2,7 @@
> > >     are at least some alignment constraints).  */
> > >  /* { dg-do compile } */
> > >  /* { dg-options "-std=c11 -pedantic-errors" } */
> > > -/* { dg-skip-if "no alignment constraints" { "avr-*-*" } } */
> > > +/* { dg-skip-if "no alignment constraints" { no_alignment_constraints } } */
> > >
> > >  #include <stddef.h>
> > >
> > > diff --git a/gcc/testsuite/gcc.dg/strlenopt-10.c b/gcc/testsuite/gcc.dg/strlenopt-10.c
> > > index ce959c34a80..6e2c2597b27 100644
> > > --- a/gcc/testsuite/gcc.dg/strlenopt-10.c
> > > +++ b/gcc/testsuite/gcc.dg/strlenopt-10.c
> > > @@ -70,10 +70,10 @@ main ()
> > >  }
> > >
> > >  /* { dg-final { scan-tree-dump-times "strlen \\(" 2 "strlen1" } } */
> > > -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> > > +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
> > >     to expand the memcpy call at the end of fn2.  */
> > > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 8 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { avr-*-* } } } } */
> > > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 8 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { no_alignment_constraints} } } } */
> > >  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
> > > diff --git a/gcc/testsuite/gcc.dg/strlenopt-11.c b/gcc/testsuite/gcc.dg/strlenopt-11.c
> > > index abd9faebed6..952de0730f1 100644
> > > --- a/gcc/testsuite/gcc.dg/strlenopt-11.c
> > > +++ b/gcc/testsuite/gcc.dg/strlenopt-11.c
> > > @@ -59,17 +59,17 @@ main ()
> > >  }
> > >
> > >  /* { dg-final { scan-tree-dump-times "strlen \\(" 3 "strlen1" } } */
> > > -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> > > +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
> > >     to expand the memcpy call at the end of fn1.  */
> > > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { avr-*-* } } } } */
> > > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { no_alignment_constraints } } } } */
> > >  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "stpcpy \\(" 0 "strlen1" } } */
> > >  /* Where the memcpy is expanded, the assignemts to elements of l are
> > >     propagated.  */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.9. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 3 "strlen1" { target { avr-*-* } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.9. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 3 "strlen1" { target { no_alignment_constraints } } } } */
> > > diff --git a/gcc/testsuite/gcc.dg/strlenopt-13.c b/gcc/testsuite/gcc.dg/strlenopt-13.c
> > > index 27ecc79c2d9..4c6d5266780 100644
> > > --- a/gcc/testsuite/gcc.dg/strlenopt-13.c
> > > +++ b/gcc/testsuite/gcc.dg/strlenopt-13.c
> > > @@ -56,18 +56,18 @@ main ()
> > >  }
> > >
> > >  /* { dg-final { scan-tree-dump-times "strlen \\(" 4 "strlen1" } } */
> > > -/* avr has BIGGEST_ALIGNMENT 8, allowing fold_builtin_memory_op
> > > +/* Some targets have BIGGEST_ALIGNMENT 8-bits, allowing fold_builtin_memory_op
> > >     to expand the memcpy call at the end of fn1.  */
> > > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { avr-*-* } } } } */
> > > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 7 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "memcpy \\(" 6 "strlen1" { target { no_alignment_constraints } } } } */
> > >  /* { dg-final { scan-tree-dump-times "strcpy \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "strcat \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "strchr \\(" 0 "strlen1" } } */
> > >  /* { dg-final { scan-tree-dump-times "stpcpy \\(" 0 "strlen1" } } */
> > >  /* Where the memcpy is expanded, the assignemts to elements of l are
> > >     propagated.  */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.1. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.5. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! avr-*-* } } } } */
> > > -/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 4 "strlen1" { target { avr-*-* } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.0. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.1. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.5. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;\[\n\r\]*  l.6. = " 1 "strlen1" { target { ! no_alignment_constraints } } } } */
> > > +/* { dg-final { scan-tree-dump-times "  _\[0-9\]* = strlen \\(\[^\n\r\]*;" 4 "strlen1" { target { no_alignment_constraints } } } } */
> > > diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
> > > index d1f4eb7641f..a86b151bb9e 100644
> > > --- a/gcc/testsuite/lib/target-supports.exp
> > > +++ b/gcc/testsuite/lib/target-supports.exp
> > > @@ -7541,6 +7541,19 @@ proc check_effective_target_vect_aligned_arrays { } {
> > >      return $et_vect_aligned_arrays
> > >  }
> > >
> > > +# Return 1 if the biggest alignment required by target is 1 * BITS_PER_UNIT.
> > > +# In such case the target does not impose any alignment constraints.
> > > +
> > > +proc check_effective_target_no_alignment_constraints { } {
> > > +    return [check_runtime_nocache no_alignment_constraints {
> > > +        int
> > > +        main (void)
> > > +        {
> > > +          return __BIGGEST_ALIGNMENT__ == 1 ? 0 : 1;
> > > +        }
> > > +    }]
> > > +}
> > > +
> > >  # Return 1 if types of size 32 bit or less are naturally aligned
> > >  # (aligned to their type-size), 0 otherwise.
> > >  #
> > > --
> > > 2.36.1
> > >