Re: [PATCH 2/2] Add a new warning option -Wstrict-flex-arrays.

[Richard Biener <rguenther@suse.de>]

On Tue, 8 Nov 2022, Qing Zhao wrote:

> '-Wstrict-flex-arrays'
>      Warn about inproper usages of flexible array members according to
>      the LEVEL of the 'strict_flex_array (LEVEL)' attribute attached to
>      the trailing array field of a structure if it's available,
>      otherwise according to the LEVEL of the option
>      '-fstrict-flex-arrays=LEVEL'.
> 
>      This option is effective only when LEVEL is bigger than 0.
>      Otherwise, it will be ignored with a warning.
> 
>      when LEVEL=1, warnings will be issued for a trailing array
>      reference of a structure that have 2 or more elements if the
>      trailing array is referenced as a flexible array member.
> 
>      when LEVEL=2, in addition to LEVEL=1, additional warnings will be
>      issued for a trailing one-element array reference of a structure if
>      the array is referenced as a flexible array member.
> 
>      when LEVEL=3, in addition to LEVEL=2, additional warnings will be
>      issued for a trailing zero-length array reference of a structure if
>      the array is referenced as a flexible array member.
> 
> At the same time, keep -Warray-bounds=[1|2] warnings unchanged from
>  -fstrict-flex-arrays.

Looking at this, is this a way to avoid interpreting -Warray-bounds=N
together with -fstrict-flex-arrays=M?  Won't this be just confusing to
users?  Especially since -Wall includes -Warray-bounds and thus we'll
diagnose

+  if (opts->x_warn_array_bounds)
+    if (opts->x_flag_strict_flex_arrays)
+      {
+       warning_at (UNKNOWN_LOCATION, 0,
+                   "%<-Warray-bounds%> is not impacted by "
+                   "%<-fstrict-flex-arrays%>");
+      }

and do that even when -Wstrict-flex-arrays is given?

Would it be better/possible to add a note: to existing -Warray-bounds
diagnostics on how the behavior is altered by -fstrict-flex-arrays?

I guess this will inevitably re-iterate the -fstrict-flex-arrays=N
vs. -Warray-bounds=M discussion ...

I think it would be better to stick with -Warray-bounds and flex
its =2 mode to work according to -fstrict-flex-arrays=N instead of
"out of bounds accesses to trailing struct members of one-element array 
types" (thus, not add [1] but instead the cases that are not flex 
arrays according to -fstrict-flex-arrays).

Richard.

> gcc/ChangeLog:
> 
> 	* attribs.cc (strict_flex_array_level_of): New function.
> 	* attribs.h (strict_flex_array_level_of): Prototype for new function.
> 	* doc/invoke.texi: Document -Wstrict-flex-arrays option. Update
> 	-fstrict-flex-arrays[=n] options.
> 	* gimple-array-bounds.cc (array_bounds_checker::check_array_ref):
> 	Issue warnings for -Wstrict-flex-arrays.
> 	(get_up_bounds_for_array_ref): New function.
> 	(check_out_of_bounds_and_warn): New function.
> 	* opts.cc (finish_options): Issue warnings for unsupported combination
> 	of -Warray-bounds and -fstrict-flex-arrays, -Wstrict_flex_arrays and
> 	-fstrict-flex-array.
> 	* tree-vrp.cc (execute_vrp): Enable the pass when
> 	warn_strict_flex_array is true.
> 	(execute_ranger_vrp): Likewise.
> 	* tree.cc (array_ref_flexible_size_p): Add one new argument.
> 	(component_ref_sam_type): New function.
> 	(component_ref_size): Add one new argument,
> 	* tree.h (array_ref_flexible_size_p): Update prototype.
> 	(enum struct special_array_member): Add two new enum values.
> 	(component_ref_sam_type): New prototype.
> 	(component_ref_size): Update prototype.
> 
> gcc/c-family/ChangeLog:
> 
> 	* c.opt (Wstrict-flex-arrays): New option.
> 
> gcc/c/ChangeLog:
> 
> 	* c-decl.cc (is_flexible_array_member_p): Call new function
> 	strict_flex_array_level_of.
> 
> gcc/testsuite/ChangeLog:
> 
> 	* c-c++-common/Wstrict-flex-arrays.c: New test.
> 	* c-c++-common/Wstrict-flex-arrays_2.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-2.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-3.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-4.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-5.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-6.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-7.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-8.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays-9.c: New test.
> 	* gcc.dg/Wstrict-flex-arrays.c: New test.
> ---
>  gcc/attribs.cc                                |  30 ++
>  gcc/attribs.h                                 |   2 +
>  gcc/c-family/c.opt                            |   5 +
>  gcc/c/c-decl.cc                               |  22 +-
>  gcc/doc/invoke.texi                           |  33 ++-
>  gcc/gimple-array-bounds.cc                    | 264 +++++++++++++-----
>  gcc/opts.cc                                   |  15 +
>  .../c-c++-common/Wstrict-flex-arrays.c        |   9 +
>  .../c-c++-common/Wstrict-flex-arrays_2.c      |   9 +
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-2.c  |  46 +++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-3.c  |  46 +++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-4.c  |  49 ++++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-5.c  |  48 ++++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-6.c  |  48 ++++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-7.c  |  50 ++++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-8.c  |  49 ++++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays-9.c  |  49 ++++
>  gcc/testsuite/gcc.dg/Wstrict-flex-arrays.c    |  46 +++
>  gcc/tree-vrp.cc                               |   6 +-
>  gcc/tree.cc                                   | 165 ++++++++---
>  gcc/tree.h                                    |  15 +-
>  21 files changed, 870 insertions(+), 136 deletions(-)
>  create mode 100644 gcc/testsuite/c-c++-common/Wstrict-flex-arrays.c
>  create mode 100644 gcc/testsuite/c-c++-common/Wstrict-flex-arrays_2.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-2.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-3.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-4.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-5.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-6.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-7.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-8.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays-9.c
>  create mode 100644 gcc/testsuite/gcc.dg/Wstrict-flex-arrays.c
> 
> diff --git a/gcc/attribs.cc b/gcc/attribs.cc
> index 27dea748561..095def4d6b0 100644
> --- a/gcc/attribs.cc
> +++ b/gcc/attribs.cc
> @@ -2456,6 +2456,36 @@ init_attr_rdwr_indices (rdwr_map *rwm, tree attrs)
>      }
>  }
>  
> +/* Get the LEVEL of the strict_flex_array for the ARRAY_FIELD based on the
> +   values of attribute strict_flex_array and the flag_strict_flex_arrays.  */
> +unsigned int
> +strict_flex_array_level_of (tree array_field)
> +{
> +  gcc_assert (TREE_CODE (array_field) == FIELD_DECL);
> +  unsigned int strict_flex_array_level = flag_strict_flex_arrays;
> +
> +  tree attr_strict_flex_array
> +    = lookup_attribute ("strict_flex_array", DECL_ATTRIBUTES (array_field));
> +  /* If there is a strict_flex_array attribute attached to the field,
> +     override the flag_strict_flex_arrays.  */
> +  if (attr_strict_flex_array)
> +    {
> +      /* Get the value of the level first from the attribute.  */
> +      unsigned HOST_WIDE_INT attr_strict_flex_array_level = 0;
> +      gcc_assert (TREE_VALUE (attr_strict_flex_array) != NULL_TREE);
> +      attr_strict_flex_array = TREE_VALUE (attr_strict_flex_array);
> +      gcc_assert (TREE_VALUE (attr_strict_flex_array) != NULL_TREE);
> +      attr_strict_flex_array = TREE_VALUE (attr_strict_flex_array);
> +      gcc_assert (tree_fits_uhwi_p (attr_strict_flex_array));
> +      attr_strict_flex_array_level = tree_to_uhwi (attr_strict_flex_array);
> +
> +      /* The attribute has higher priority than flag_struct_flex_array.  */
> +      strict_flex_array_level = attr_strict_flex_array_level;
> +    }
> +  return strict_flex_array_level;
> +}
> +
> +
>  /* Return the access specification for a function parameter PARM
>     or null if the current function has no such specification.  */
>  
> diff --git a/gcc/attribs.h b/gcc/attribs.h
> index 1dc16e4bc4e..742811e6fda 100644
> --- a/gcc/attribs.h
> +++ b/gcc/attribs.h
> @@ -398,4 +398,6 @@ extern void init_attr_rdwr_indices (rdwr_map *, tree);
>  extern attr_access *get_parm_access (rdwr_map &, tree,
>  				     tree = current_function_decl);
>  
> +extern unsigned int strict_flex_array_level_of (tree);
> +
>  #endif // GCC_ATTRIBS_H
> diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt
> index 01d480759ae..bc33710a649 100644
> --- a/gcc/c-family/c.opt
> +++ b/gcc/c-family/c.opt
> @@ -968,6 +968,11 @@ Wstringop-truncation
>  C ObjC C++ LTO ObjC++ Var(warn_stringop_truncation) Warning Init (1) LangEnabledBy(C ObjC C++ LTO ObjC++, Wall)
>  Warn about truncation in string manipulation functions like strncat and strncpy.
>  
> +Wstrict-flex-arrays
> +C C++ Var(warn_strict_flex_arrays) Warning
> +Warn about inproper usages of flexible array members
> +according to the level of -fstrict-flex-arrays.
> +
>  Wsuggest-attribute=format
>  C ObjC C++ ObjC++ Var(warn_suggest_attribute_format) Warning
>  Warn about functions which might be candidates for format attributes.
> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> index 4746e310d2d..c9cb46daacc 100644
> --- a/gcc/c/c-decl.cc
> +++ b/gcc/c/c-decl.cc
> @@ -8828,7 +8828,6 @@ finish_incomplete_vars (tree incomplete_vars, bool toplevel)
>      }
>  }
>  
> -
>  /* Determine whether the FIELD_DECL X is a flexible array member according to
>     the following info:
>    A. whether the FIELD_DECL X is the last field of the DECL_CONTEXT;
> @@ -8855,26 +8854,7 @@ is_flexible_array_member_p (bool is_last_field,
>    bool is_one_element_array = one_element_array_type_p (TREE_TYPE (x));
>    bool is_flexible_array = flexible_array_member_type_p (TREE_TYPE (x));
>  
> -  unsigned int strict_flex_array_level = flag_strict_flex_arrays;
> -
> -  tree attr_strict_flex_array = lookup_attribute ("strict_flex_array",
> -						  DECL_ATTRIBUTES (x));
> -  /* If there is a strict_flex_array attribute attached to the field,
> -     override the flag_strict_flex_arrays.  */
> -  if (attr_strict_flex_array)
> -    {
> -      /* Get the value of the level first from the attribute.  */
> -      unsigned HOST_WIDE_INT attr_strict_flex_array_level = 0;
> -      gcc_assert (TREE_VALUE (attr_strict_flex_array) != NULL_TREE);
> -      attr_strict_flex_array = TREE_VALUE (attr_strict_flex_array);
> -      gcc_assert (TREE_VALUE (attr_strict_flex_array) != NULL_TREE);
> -      attr_strict_flex_array = TREE_VALUE (attr_strict_flex_array);
> -      gcc_assert (tree_fits_uhwi_p (attr_strict_flex_array));
> -      attr_strict_flex_array_level = tree_to_uhwi (attr_strict_flex_array);
> -
> -      /* The attribute has higher priority than flag_struct_flex_array.  */
> -      strict_flex_array_level = attr_strict_flex_array_level;
> -    }
> +  unsigned int strict_flex_array_level = strict_flex_array_level_of (x);
>  
>    switch (strict_flex_array_level)
>      {
> diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
> index 64f77e8367a..a35e6bf27e0 100644
> --- a/gcc/doc/invoke.texi
> +++ b/gcc/doc/invoke.texi
> @@ -397,7 +397,7 @@ Objective-C and Objective-C++ Dialects}.
>  -Wstrict-aliasing=n  -Wstrict-overflow  -Wstrict-overflow=@var{n} @gol
>  -Wstring-compare @gol
>  -Wno-stringop-overflow -Wno-stringop-overread @gol
> --Wno-stringop-truncation @gol
> +-Wno-stringop-truncation -Wstrict-flex-arrays @gol
>  -Wsuggest-attribute=@r{[}pure@r{|}const@r{|}noreturn@r{|}format@r{|}malloc@r{]} @gol
>  -Wswitch  -Wno-switch-bool  -Wswitch-default  -Wswitch-enum @gol
>  -Wno-switch-outside-range  -Wno-switch-unreachable  -Wsync-nand @gol
> @@ -2848,12 +2848,18 @@ The negative form is equivalent to @option{-fstrict-flex-arrays=0}, which is the
>  least strict.  All trailing arrays of structures are treated as flexible array
>  members.
>  
> +This option is not compatible with @option{-Warray-bounds} due to historical
> +reason.  The behavior of @option{-Warray-bounds} is not changed by this option.
> +
>  @item -fstrict-flex-arrays=@var{level}
>  @opindex fstrict-flex-arrays=@var{level}
>  Control when to treat the trailing array of a structure as a flexible array
>  member for the purpose of accessing the elements of such an array.  The value
>  of @var{level} controls the level of strictness.
>  
> +This option is not compatible with @option{-Warray-bounds} due to historical
> +reason.  The behavior of @option{-Warray-bounds} is not changed by this option.
> +
>  The possible values of @var{level} are the same as for the
>  @code{strict_flex_array} attribute (@pxref{Variable Attributes}).
>  
> @@ -7662,6 +7668,31 @@ however, are not suitable arguments to functions that expect
>  such arrays GCC issues warnings unless it can prove that the use is
>  safe.  @xref{Common Variable Attributes}.
>  
> +@item -Wstrict-flex-arrays
> +@opindex Wstrict-flex-arrays
> +@opindex Wno-strict-flex-arrays
> +Warn about inproper usages of flexible array members
> +according to the @var{level} of the @code{strict_flex_array (@var{level})}
> +attribute attached to the trailing array field of a structure if it's
> +available, otherwise according to the @var{level} of the option
> +@option{-fstrict-flex-arrays=@var{level}}.
> +
> +This option is effective only when @var{level} is bigger than 0.  Otherwise,
> +it will be ignored with a warning.
> +
> +when @var{level}=1, warnings will be issued for a trailing array reference
> +of a structure that have 2 or more elements if the trailing array is referenced
> +as a flexible array member.
> +
> +when @var{level}=2, in addition to @var{level}=1, additional warnings will be
> +issued for a trailing one-element array reference of a structure
> +if the array is referenced as a flexible array member.
> +
> +when @var{level}=3, in addition to @var{level}=2, additional warnings will be
> +issued for a trailing zero-length array reference of a structure
> +if the array is referenced as a flexible array member.
> +
> +
>  @item -Wsuggest-attribute=@r{[}pure@r{|}const@r{|}noreturn@r{|}format@r{|}cold@r{|}malloc@r{]}
>  @opindex Wsuggest-attribute=
>  @opindex Wno-suggest-attribute=
> diff --git a/gcc/gimple-array-bounds.cc b/gcc/gimple-array-bounds.cc
> index fbf448e045d..7f790c5a19a 100644
> --- a/gcc/gimple-array-bounds.cc
> +++ b/gcc/gimple-array-bounds.cc
> @@ -170,38 +170,20 @@ trailing_array (tree arg, tree *pref)
>    return array_ref_flexible_size_p (arg);
>  }
>  
> -/* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible
> -   arrays and "struct" hacks. If VRP can determine that the array
> -   subscript is a constant, check if it is outside valid range.  If
> -   the array subscript is a RANGE, warn if it is non-overlapping with
> -   valid range.  IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside
> -   a ADDR_EXPR.  Return  true if a warning has been issued or if
> -   no-warning is set.  */
> -
> -bool
> -array_bounds_checker::check_array_ref (location_t location, tree ref,
> -				       gimple *stmt, bool ignore_off_by_one)
> +/* Acquire the upper bound and upper bound plus one for the array
> +   reference REF and record them into UP_BOUND and UP_BOUND_P1.
> +   Set *DECL to the decl or expresssion REF refers to.
> +   FOR_ARRAY_BOUND is true when this is for array bound checking.  */
> +
> +static void
> +get_up_bounds_for_array_ref (tree ref, tree *decl,
> +			     tree *up_bound, tree *up_bound_p1,
> +			     bool for_array_bound)
>  {
> -  if (warning_suppressed_p (ref, OPT_Warray_bounds))
> -    /* Return true to have the caller prevent warnings for enclosing
> -       refs.  */
> -    return true;
> -
> -  tree low_sub = TREE_OPERAND (ref, 1);
> -  tree up_sub = low_sub;
> -  tree up_bound = array_ref_up_bound (ref);
> -
> -  /* Referenced decl if one can be determined.  */
> -  tree decl = NULL_TREE;
> -
> -  /* Set for accesses to interior zero-length arrays.  */
> -  special_array_member sam{ };
> -
> -  tree up_bound_p1;
> -
> -  if (!up_bound
> -      || TREE_CODE (up_bound) != INTEGER_CST
> -      || (warn_array_bounds < 2 && trailing_array (ref, &decl)))
> +  if (!(*up_bound)
> +      || TREE_CODE (*up_bound) != INTEGER_CST
> +      || ((for_array_bound ? (warn_array_bounds < 2) : warn_strict_flex_arrays)
> +	   && trailing_array (ref, decl)))
>      {
>        /* Accesses to trailing arrays via pointers may access storage
>  	 beyond the types array bounds.  For such arrays, or for flexible
> @@ -213,8 +195,8 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
>        if (TREE_CODE (eltsize) != INTEGER_CST
>  	  || integer_zerop (eltsize))
>  	{
> -	  up_bound = NULL_TREE;
> -	  up_bound_p1 = NULL_TREE;
> +	  *up_bound = NULL_TREE;
> +	  *up_bound_p1 = NULL_TREE;
>  	}
>        else
>  	{
> @@ -227,7 +209,8 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
>  	    {
>  	      /* Try to determine the size of the trailing array from
>  		 its initializer (if it has one).  */
> -	      if (tree refsize = component_ref_size (arg, &sam))
> +	      if (tree refsize
> +		    = component_ref_size (arg, NULL, for_array_bound))
>  		if (TREE_CODE (refsize) == INTEGER_CST)
>  		  maxbound = refsize;
>  	    }
> @@ -246,7 +229,7 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
>  		    {
>  		      /* Try to determine the size from a pointer to
>  			 an array if BASE is one.  */
> -		      if (tree size = get_ref_size (base, &decl))
> +		      if (tree size = get_ref_size (base, decl))
>  			maxbound = size;
>  		    }
>  		  else if (!compref && DECL_P (base))
> @@ -254,7 +237,7 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
>  		      if (TREE_CODE (basesize) == INTEGER_CST)
>  			{
>  			  maxbound = basesize;
> -			  decl = base;
> +			  *decl = base;
>  			}
>  
>  		  if (known_gt (off, 0))
> @@ -266,40 +249,47 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
>  	  else
>  	    maxbound = fold_convert (sizetype, maxbound);
>  
> -	  up_bound_p1 = int_const_binop (TRUNC_DIV_EXPR, maxbound, eltsize);
> +	  *up_bound_p1 = int_const_binop (TRUNC_DIV_EXPR, maxbound, eltsize);
>  
> -	  if (up_bound_p1 != NULL_TREE)
> -	    up_bound = int_const_binop (MINUS_EXPR, up_bound_p1,
> +	  if (*up_bound_p1 != NULL_TREE)
> +	    *up_bound = int_const_binop (MINUS_EXPR, *up_bound_p1,
>  					build_int_cst (ptrdiff_type_node, 1));
>  	  else
> -	    up_bound = NULL_TREE;
> +	    *up_bound = NULL_TREE;
>  	}
>      }
>    else
> -    up_bound_p1 = int_const_binop (PLUS_EXPR, up_bound,
> -				   build_int_cst (TREE_TYPE (up_bound), 1));
> +    *up_bound_p1 = int_const_binop (PLUS_EXPR, *up_bound,
> +				   build_int_cst (TREE_TYPE (*up_bound), 1));
> +  return;
> +}
>  
> -  tree low_bound = array_ref_low_bound (ref);
> +/* Given the LOW_SUB_ORG, LOW_SUB and UP_SUB, and the computed UP_BOUND
> +   and UP_BOUND_P1, check whether the array reference REF is out of bound.
> +   When out of bounds, issue warnings if FOR_ARRAY_BOUND is true.
> +   otherwise, return true without issue warnings.  */
>  
> +static bool
> +check_out_of_bounds_and_warn (location_t location, tree ref,
> +			      tree low_sub_org, tree low_sub, tree up_sub,
> +			      tree up_bound, tree up_bound_p1,
> +			      const value_range *vr,
> +			      bool ignore_off_by_one, bool for_array_bound)
> +{
> +  tree low_bound = array_ref_low_bound (ref);
>    tree artype = TREE_TYPE (TREE_OPERAND (ref, 0));
>  
>    bool warned = false;
>  
>    /* Empty array.  */
>    if (up_bound && tree_int_cst_equal (low_bound, up_bound_p1))
> -    warned = warning_at (location, OPT_Warray_bounds,
> -			 "array subscript %E is outside array bounds of %qT",
> -			 low_sub, artype);
> -
> -  const value_range *vr = NULL;
> -  if (TREE_CODE (low_sub) == SSA_NAME)
>      {
> -      vr = get_value_range (low_sub, stmt);
> -      if (!vr->undefined_p () && !vr->varying_p ())
> -	{
> -	  low_sub = vr->kind () == VR_RANGE ? vr->max () : vr->min ();
> -	  up_sub = vr->kind () == VR_RANGE ? vr->min () : vr->max ();
> -	}
> +      if (for_array_bound)
> +	warned = warning_at (location, OPT_Warray_bounds,
> +			     "array subscript %E is outside array"
> +			     " bounds of %qT", low_sub_org, artype);
> +      else
> +	warned = true;
>      }
>  
>    if (warned)
> @@ -313,24 +303,127 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
>  	      : tree_int_cst_le (up_bound, up_sub))
>  	  && TREE_CODE (low_sub) == INTEGER_CST
>  	  && tree_int_cst_le (low_sub, low_bound))
> -	warned = warning_at (location, OPT_Warray_bounds,
> -			     "array subscript [%E, %E] is outside "
> -			     "array bounds of %qT",
> -			     low_sub, up_sub, artype);
> +	{
> +	  if (for_array_bound)
> +	    warned = warning_at (location, OPT_Warray_bounds,
> +				 "array subscript [%E, %E] is outside "
> +				 "array bounds of %qT",
> +				 low_sub, up_sub, artype);
> +	  else
> +	    warned = true;
> +	}
>      }
>    else if (up_bound
>  	   && TREE_CODE (up_sub) == INTEGER_CST
>  	   && (ignore_off_by_one
>  	       ? !tree_int_cst_le (up_sub, up_bound_p1)
>  	       : !tree_int_cst_le (up_sub, up_bound)))
> -    warned = warning_at (location, OPT_Warray_bounds,
> -			 "array subscript %E is above array bounds of %qT",
> -			 up_sub, artype);
> +    {
> +      if (for_array_bound)
> +	warned = warning_at (location, OPT_Warray_bounds,
> +			     "array subscript %E is above array bounds of %qT",
> +			     up_sub, artype);
> +      else
> +	warned = true;
> +    }
>    else if (TREE_CODE (low_sub) == INTEGER_CST
>  	   && tree_int_cst_lt (low_sub, low_bound))
> -    warned = warning_at (location, OPT_Warray_bounds,
> -			 "array subscript %E is below array bounds of %qT",
> -			 low_sub, artype);
> +    {
> +      if (for_array_bound)
> +	warned = warning_at (location, OPT_Warray_bounds,
> +			     "array subscript %E is below array bounds of %qT",
> +			     low_sub, artype);
> +      else
> +	warned = true;
> +    }
> +  return warned;
> +}
> +
> +/* Checks one ARRAY_REF in REF, located at LOCUS.  Ignores flexible
> +   arrays and "struct" hacks.  If VRP can determine that the array
> +   subscript is a constant, check if it is outside valid range.  If
> +   the array subscript is a RANGE, warn if it is non-overlapping with
> +   valid range.  IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside
> +   a ADDR_EXPR.  Return  true if a warning has been issued or if
> +   no-warning is set.  */
> +
> +bool
> +array_bounds_checker::check_array_ref (location_t location, tree ref,
> +				       gimple *stmt, bool ignore_off_by_one)
> +{
> +  if (warning_suppressed_p (ref, OPT_Warray_bounds))
> +    /* Return true to have the caller prevent warnings for enclosing
> +       refs.  */
> +    return true;
> +
> +  /* Upper bound and Upper bound plus one for -Warray-bounds.  */
> +  tree up_bound = array_ref_up_bound (ref);
> +  tree up_bound_p1 = NULL_TREE;
> +
> +  /* Upper bound and upper bound plus one for -Wstrict-flex-array.  */
> +  tree up_bound_strict = up_bound;
> +  tree up_bound_p1_strict = NULL_TREE;
> +
> +  /* Referenced decl if one can be determined.  */
> +  tree decl = NULL_TREE;
> +
> +  /* Set to the type of the special array member for a COMPONENT_REF.  */
> +  special_array_member sam{ };
> +
> +  tree arg = TREE_OPERAND (ref, 0);
> +  const bool compref = TREE_CODE (arg) == COMPONENT_REF;
> +
> +  unsigned int strict_flex_array_level = flag_strict_flex_arrays;
> +
> +  if (compref)
> +    {
> +      /* Try to determine special array member type for this COMPONENT_REF.  */
> +      sam = component_ref_sam_type (arg);
> +      /* Get the level of strict_flex_array for this array field.  */
> +      tree afield_decl = TREE_OPERAND (arg, 1);
> +      strict_flex_array_level = strict_flex_array_level_of (afield_decl);
> +    }
> +
> +  if (warn_array_bounds)
> +    get_up_bounds_for_array_ref (ref, &decl, &up_bound, &up_bound_p1,
> +				 true);
> +  if (warn_strict_flex_arrays)
> +    get_up_bounds_for_array_ref (ref, &decl, &up_bound_strict,
> +				 &up_bound_p1_strict, false);
> +
> +
> +
> +  bool warned = false;
> +  bool out_of_bound = false;
> +
> +  tree artype = TREE_TYPE (TREE_OPERAND (ref, 0));
> +  tree low_sub_org = TREE_OPERAND (ref, 1);
> +  tree up_sub = low_sub_org;
> +  tree low_sub = low_sub_org;
> +
> +  const value_range *vr = NULL;
> +  if (TREE_CODE (low_sub_org) == SSA_NAME)
> +    {
> +      vr = get_value_range (low_sub_org, stmt);
> +      if (!vr->undefined_p () && !vr->varying_p ())
> +	{
> +	  low_sub = vr->kind () == VR_RANGE ? vr->max () : vr->min ();
> +	  up_sub = vr->kind () == VR_RANGE ? vr->min () : vr->max ();
> +	}
> +    }
> +
> +  if (warn_array_bounds)
> +    warned = check_out_of_bounds_and_warn (location, ref,
> +					   low_sub_org, low_sub, up_sub,
> +					   up_bound, up_bound_p1, vr,
> +					   ignore_off_by_one, true);
> +
> +  if (warn_strict_flex_arrays)
> +    out_of_bound = check_out_of_bounds_and_warn (location, ref,
> +						 low_sub_org, low_sub, up_sub,
> +						 up_bound_strict,
> +						 up_bound_p1_strict, vr,
> +						 ignore_off_by_one, false);
>  
>    if (!warned && sam == special_array_member::int_0)
>      warned = warning_at (location, OPT_Wzero_length_bounds,
> @@ -341,19 +434,56 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
>  			       "of an interior zero-length array %qT")),
>  			 low_sub, artype);
>  
> -  if (warned)
> +  if (warned || out_of_bound)
>      {
> -      if (dump_file && (dump_flags & TDF_DETAILS))
> +      if (warned && dump_file && (dump_flags & TDF_DETAILS))
>  	{
>  	  fprintf (dump_file, "Array bound warning for ");
>  	  dump_generic_expr (MSG_NOTE, TDF_SLIM, ref);
>  	  fprintf (dump_file, "\n");
>  	}
>  
> +      /* issue warnings for -Wstrict-flex-arrays according to the level of
> +	 flag_strict_flex_arrays.  */
> +      if (out_of_bound && warn_strict_flex_arrays)
> +	switch (strict_flex_array_level)
> +	  {
> +	    case 3:
> +	      /* Issue additional warnings for trailing arrays [0].  */
> +	      if (sam == special_array_member::trail_0)
> +		warned = warning_at (location, OPT_Wstrict_flex_arrays,
> +				     "trailing array %qT should not be used as "
> +				     "a flexible array member for level 3",
> +				     artype);
> +	      /* FALLTHROUGH.  */
> +	    case 2:
> +	      /* Issue additional warnings for trailing arrays [1].  */
> +	      if (sam == special_array_member::trail_1)
> +		warned = warning_at (location, OPT_Wstrict_flex_arrays,
> +				     "trailing array %qT should not be used as "
> +				     "a flexible array member for level 2 and "
> +				     "above", artype);
> +	      /* FALLTHROUGH.  */
> +	    case 1:
> +	      /* Issue warnings for trailing arrays [n].  */
> +	      if (sam == special_array_member::trail_n)
> +		warned = warning_at (location, OPT_Wstrict_flex_arrays,
> +				     "trailing array %qT should not be used as "
> +				     "a flexible array member for level 1 and "
> +				     "above", artype);
> +	      break;
> +	    case 0:
> +	      /* Do nothing.  */
> +	      break;
> +	    default:
> +	      gcc_unreachable ();
> +	  }
> +
>        /* Avoid more warnings when checking more significant subscripts
>  	 of the same expression.  */
>        ref = TREE_OPERAND (ref, 0);
>        suppress_warning (ref, OPT_Warray_bounds);
> +      suppress_warning (ref, OPT_Wstrict_flex_arrays);
>  
>        if (decl)
>  	ref = decl;
> diff --git a/gcc/opts.cc b/gcc/opts.cc
> index ae079fcd20e..ca162aa781c 100644
> --- a/gcc/opts.cc
> +++ b/gcc/opts.cc
> @@ -1409,6 +1409,21 @@ finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
>        opts->x_profile_flag = 0;
>      }
>  
> +  if (opts->x_warn_array_bounds)
> +    if (opts->x_flag_strict_flex_arrays)
> +      {
> +	warning_at (UNKNOWN_LOCATION, 0,
> +		    "%<-Warray-bounds%> is not impacted by "
> +		    "%<-fstrict-flex-arrays%>");
> +      }
> +  if (opts->x_warn_strict_flex_arrays)
> +    if (opts->x_flag_strict_flex_arrays == 0)
> +      {
> +	opts->x_warn_strict_flex_arrays = 0;
> +	warning_at (UNKNOWN_LOCATION, 0,
> +		    "%<-Wstrict-flex-arrays%> is ignored when"
> +		    " %<-fstrict-flex-arrays%> does not present");
> +      }
>  
>    diagnose_options (opts, opts_set, loc);
>  }
> diff --git a/gcc/testsuite/c-c++-common/Wstrict-flex-arrays.c b/gcc/testsuite/c-c++-common/Wstrict-flex-arrays.c
> new file mode 100644
> index 00000000000..72b4b7c6406
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/Wstrict-flex-arrays.c
> @@ -0,0 +1,9 @@
> +/* Test the usage of option -Wstrict-flex-arrays.  */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays" } */
> +
> +int main(int argc, char *argv[])
> +{
> +    return 0;
> +}
> +/* { dg-warning "is ignored when \'-fstrict-flex-arrays\' does not present" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/c-c++-common/Wstrict-flex-arrays_2.c b/gcc/testsuite/c-c++-common/Wstrict-flex-arrays_2.c
> new file mode 100644
> index 00000000000..af9ec922dea
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/Wstrict-flex-arrays_2.c
> @@ -0,0 +1,9 @@
> +/* Test the usage of option -Wstrict-flex-arrays.  */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -Warray-bounds -fstrict-flex-arrays" } */
> +
> +int main(int argc, char *argv[])
> +{
> +    return 0;
> +}
> +/* { dg-warning "\'-Warray-bounds\' is not impacted by \'-fstrict-flex-arrays\'" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-2.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-2.c
> new file mode 100644
> index 00000000000..59d5a5fcb23
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-2.c
> @@ -0,0 +1,46 @@
> +/* Test -Wstrict-flex-arrays.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=2" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_1->c[2] = 2; /* { dg-warning "should not be used as a flexible array member for level 2 and above" } */
> +    trailing_0->c[1] = 1; /* { dg-bogus "should not be used as a flexible array member for level 2 and above" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 2 and above" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-3.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-3.c
> new file mode 100644
> index 00000000000..2f66151e927
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-3.c
> @@ -0,0 +1,46 @@
> +/* Test -Wstrict-flex-arrays.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=3" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_1->c[2] = 2; /* { dg-warning "should not be used as a flexible array member for level 2 and above" } */
> +    trailing_0->c[1] = 1; /* { dg-warning "should not be used as a flexible array member for level 3" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 3" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-4.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-4.c
> new file mode 100644
> index 00000000000..6a4576568ac
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-4.c
> @@ -0,0 +1,49 @@
> +/* Test -Wstrict-flex-arrays + -Warray-bounds.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=1 -Warray-bounds" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +    			 /*{ dg-warning "array subscript 5 is above array bounds of" "" { target *-*-* } .-1 } */
> +    trailing_1->c[2] = 2; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_0->c[1] = 1; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> +
> +/* { dg-warning "\'-Warray-bounds\' is not impacted by \'-fstrict-flex-arrays\'" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-5.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-5.c
> new file mode 100644
> index 00000000000..e550fbd24e1
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-5.c
> @@ -0,0 +1,48 @@
> +/* Test -Wstrict-flex-arrays + -Warray-bounds.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=2 -Warray-bounds" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +    			 /*{ dg-warning "array subscript 5 is above array bounds of" "" { target *-*-* } .-1 } */
> +    trailing_1->c[2] = 2; /* { dg-warning "should not be used as a flexible array member for level 2 and above" } */
> +    trailing_0->c[1] = 1; /* { dg-bogus "should not be used as a flexible array member for level 2 and above" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 2 and above" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> +/* { dg-warning "\'-Warray-bounds\' is not impacted by \'-fstrict-flex-arrays\'" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-6.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-6.c
> new file mode 100644
> index 00000000000..d5b61136b3a
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-6.c
> @@ -0,0 +1,48 @@
> +/* Test -Wstrict-flex-arrays.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=3 -Warray-bounds" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +   			/*{ dg-warning "array subscript 5 is above array bounds of" "" { target *-*-* } .-1 } */ 
> +    trailing_1->c[2] = 2; /* { dg-warning "should not be used as a flexible array member for level 2 and above" } */
> +    trailing_0->c[1] = 1; /* { dg-warning "should not be used as a flexible array member for level 3" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 3" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> +/* { dg-warning "\'-Warray-bounds\' is not impacted by \'-fstrict-flex-arrays\'" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-7.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-7.c
> new file mode 100644
> index 00000000000..eb82a60c261
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-7.c
> @@ -0,0 +1,50 @@
> +/* Test -Wstrict-flex-arrays + -Warray-bounds=2.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=1 -Warray-bounds=2" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +    			 /*{ dg-warning "array subscript 5 is above array bounds of" "" { target *-*-* } .-1 } */
> +    trailing_1->c[2] = 2; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +    			 /*{ dg-warning "array subscript 2 is above array bounds of" "" { target *-*-* } .-1 } */
> +    trailing_0->c[1] = 1; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> +
> +/* { dg-warning "\'-Warray-bounds\' is not impacted by \'-fstrict-flex-arrays\'" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-8.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-8.c
> new file mode 100644
> index 00000000000..f48a50e04f5
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-8.c
> @@ -0,0 +1,49 @@
> +/* Test -Wstrict-flex-arrays + -Warray-bounds=2.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=2 -Warray-bounds=2" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +    			 /*{ dg-warning "array subscript 5 is above array bounds of" "" { target *-*-* } .-1 } */
> +    trailing_1->c[2] = 2; /* { dg-warning "should not be used as a flexible array member for level 2 and above" } */
> +    			  /*{ dg-warning "array subscript 2 is above array bounds of" "" { target *-*-* } .-1 } */
> +    trailing_0->c[1] = 1; /* { dg-bogus "should not be used as a flexible array member for level 2 and above" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 2 and above" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> +/* { dg-warning "\'-Warray-bounds\' is not impacted by \'-fstrict-flex-arrays\'" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-9.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-9.c
> new file mode 100644
> index 00000000000..9f2877ef4e1
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays-9.c
> @@ -0,0 +1,49 @@
> +/* Test -Wstrict-flex-arrays + -Warray-bounds=2.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=3 -Warray-bounds=2" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +   			/*{ dg-warning "array subscript 5 is above array bounds of" "" { target *-*-* } .-1 } */ 
> +    trailing_1->c[2] = 2; /* { dg-warning "should not be used as a flexible array member for level 2 and above" } */
> +    			/*{ dg-warning "array subscript 2 is above array bounds of" "" { target *-*-* } .-1 } */
> +    trailing_0->c[1] = 1; /* { dg-warning "should not be used as a flexible array member for level 3" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 3" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> +/* { dg-warning "\'-Warray-bounds\' is not impacted by \'-fstrict-flex-arrays\'" "" { target *-*-* } 0 } */
> diff --git a/gcc/testsuite/gcc.dg/Wstrict-flex-arrays.c b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays.c
> new file mode 100644
> index 00000000000..43a9098f138
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/Wstrict-flex-arrays.c
> @@ -0,0 +1,46 @@
> +/* Test -Wstrict-flex-arrays.  */
> +/* { dg-do run } */
> +/* { dg-options "-O2 -Wstrict-flex-arrays -fstrict-flex-arrays=1" } */
> +
> +struct trailing_array_1 {
> +    int a;
> +    int b;
> +    int c[4]; 
> +};
> +
> +struct trailing_array_2 {
> +    int a;
> +    int b;
> +    int c[1]; 
> +};
> +
> +struct trailing_array_3 {
> +    int a;
> +    int b;
> +    int c[0];
> +};
> +struct trailing_array_4 {
> +    int a;
> +    int b;
> +    int c[];
> +};
> +
> +void __attribute__((__noinline__)) stuff(
> +    struct trailing_array_1 *normal,
> +    struct trailing_array_2 *trailing_1,
> +    struct trailing_array_3 *trailing_0,
> +    struct trailing_array_4 *trailing_flex)
> +{
> +    normal->c[5] = 5; 	/*{ dg-warning "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_1->c[2] = 2; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_0->c[1] = 1; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +    trailing_flex->c[10] = 10; /* { dg-bogus "should not be used as a flexible array member for level 1 and above" } */
> +
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +    stuff((void *)argv[0], (void *)argv[0], (void *)argv[0], (void *)argv[0]);
> +
> +    return 0;
> +}
> diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
> index e5a292bb875..1f1b56c1a52 100644
> --- a/gcc/tree-vrp.cc
> +++ b/gcc/tree-vrp.cc
> @@ -4229,12 +4229,12 @@ execute_vrp (struct function *fun, bool warn_array_bounds_p)
>       the flag on every edge now, rather than in
>       check_array_bounds_dom_walker's ctor; vrp_folder may clear
>       it from some edges.  */
> -  if (warn_array_bounds && warn_array_bounds_p)
> +  if ((warn_array_bounds || warn_strict_flex_arrays) && warn_array_bounds_p)
>      set_all_edges_as_executable (fun);
>  
>    folder.substitute_and_fold ();
>  
> -  if (warn_array_bounds && warn_array_bounds_p)
> +  if ((warn_array_bounds || warn_strict_flex_arrays) && warn_array_bounds_p)
>      {
>        array_bounds_checker array_checker (fun, &vrp_vr_values);
>        array_checker.check ();
> @@ -4353,7 +4353,7 @@ execute_ranger_vrp (struct function *fun, bool warn_array_bounds_p)
>    if (dump_file && (dump_flags & TDF_DETAILS))
>      ranger->dump (dump_file);
>  
> -  if (warn_array_bounds && warn_array_bounds_p)
> +  if ((warn_array_bounds || warn_strict_flex_arrays) && warn_array_bounds_p)
>      {
>        // Set all edges as executable, except those ranger says aren't.
>        int non_exec_flag = ranger->non_executable_edge_flag;
> diff --git a/gcc/tree.cc b/gcc/tree.cc
> index d2b0b34a725..0f5f7151b6b 100644
> --- a/gcc/tree.cc
> +++ b/gcc/tree.cc
> @@ -12726,15 +12726,21 @@ array_ref_up_bound (tree exp)
>     int test (uint8_t *p, uint32_t t[1][1], int n) {
>     for (int i = 0; i < 4; i++, p++)
>       t[i][0] = ...;
> +
> +   If non-null, set IS_TRAILING_ARRAY to true if the ref is the above case A.
>  */
>  
>  bool
> -array_ref_flexible_size_p (tree ref)
> +array_ref_flexible_size_p (tree ref, bool *is_trailing_array /* = NULL */)
>  {
> -  /* the TYPE for this array referece.  */
> +  /* The TYPE for this array referece.  */
>    tree atype = NULL_TREE;
> -  /* the FIELD_DECL for the array field in the containing structure.  */
> +  /* The FIELD_DECL for the array field in the containing structure.  */
>    tree afield_decl = NULL_TREE;
> +  /* Whether this array is the trailing array of a structure.  */
> +  bool is_trailing_array_tmp = false;
> +  if (!is_trailing_array)
> +    is_trailing_array = &is_trailing_array_tmp;
>  
>    if (TREE_CODE (ref) == ARRAY_REF
>        || TREE_CODE (ref) == ARRAY_RANGE_REF)
> @@ -12822,7 +12828,10 @@ array_ref_flexible_size_p (tree ref)
>    if (! TYPE_SIZE (atype)
>        || ! TYPE_DOMAIN (atype)
>        || ! TYPE_MAX_VALUE (TYPE_DOMAIN (atype)))
> -    return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +    {
> +      *is_trailing_array = afield_decl && TREE_CODE (afield_decl) == FIELD_DECL;
> +      return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +    }
>  
>    /* If the reference is based on a declared entity, the size of the array
>       is constrained by its given domain.  (Do not trust commons PR/69368).  */
> @@ -12844,9 +12853,17 @@ array_ref_flexible_size_p (tree ref)
>        if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (atype))) != INTEGER_CST
>  	  || TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (atype))) != INTEGER_CST
>            || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (atype))) != INTEGER_CST)
> -	return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +	{
> +	  *is_trailing_array
> +	    = afield_decl && TREE_CODE (afield_decl) == FIELD_DECL;
> +	  return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +	}
>        if (! get_addr_base_and_unit_offset (ref_to_array, &offset))
> -	return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +	{
> +	  *is_trailing_array
> +	    = afield_decl && TREE_CODE (afield_decl) == FIELD_DECL;
> +	  return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +	}
>  
>        /* If at least one extra element fits it is a flexarray.  */
>        if (known_le ((wi::to_offset (TYPE_MAX_VALUE (TYPE_DOMAIN (atype)))
> @@ -12854,11 +12871,16 @@ array_ref_flexible_size_p (tree ref)
>  		     + 2)
>  		    * wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (atype))),
>  		    wi::to_offset (DECL_SIZE_UNIT (ref)) - offset))
> -	return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +	{
> +	  *is_trailing_array
> +	    = afield_decl && TREE_CODE (afield_decl) == FIELD_DECL;
> +	  return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
> +	}
>  
>        return false;
>      }
>  
> +  *is_trailing_array = afield_decl && TREE_CODE (afield_decl) == FIELD_DECL;
>    return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
>  }
>  
> @@ -12920,24 +12942,81 @@ get_initializer_for (tree init, tree decl)
>    return NULL_TREE;
>  }
>  
> +/* Determines the special array member type for the array reference REF.  */
> +special_array_member
> +component_ref_sam_type (tree ref)
> +{
> +  special_array_member sam_type = special_array_member::none;
> +
> +  tree member = TREE_OPERAND (ref, 1);
> +  tree memsize = DECL_SIZE_UNIT (member);
> +  if (memsize)
> +    {
> +      tree memtype = TREE_TYPE (member);
> +      if (TREE_CODE (memtype) != ARRAY_TYPE)
> +	return sam_type;
> +
> +      bool trailing = false;
> +      (void)array_ref_flexible_size_p (ref, &trailing);
> +      bool zero_length = integer_zerop (memsize);
> +      if (!trailing && !zero_length)
> +	/* MEMBER is an interior array with
> +	  more than one element.  */
> +	return special_array_member::int_n;
> +
> +      if (zero_length)
> +	{
> +	  if (trailing)
> +	    return special_array_member::trail_0;
> +	  else
> +	    return special_array_member::int_0;
> +	}
> +
> +      if (!zero_length)
> +	if (tree dom = TYPE_DOMAIN (memtype))
> +	  if (tree min = TYPE_MIN_VALUE (dom))
> +	    if (tree max = TYPE_MAX_VALUE (dom))
> +	      if (TREE_CODE (min) == INTEGER_CST
> +		  && TREE_CODE (max) == INTEGER_CST)
> +		{
> +		  offset_int minidx = wi::to_offset (min);
> +		  offset_int maxidx = wi::to_offset (max);
> +		  offset_int neltsm1 = maxidx - minidx;
> +		  if (neltsm1 > 0)
> +		    /* MEMBER is a trailing array with more than
> +		       one elements.  */
> +		    return special_array_member::trail_n;
> +
> +		  if (neltsm1 == 0)
> +		    return special_array_member::trail_1;
> +		}
> +    }
> +
> +  return sam_type;
> +}
> +
>  /* Determines the size of the member referenced by the COMPONENT_REF
>     REF, using its initializer expression if necessary in order to
>     determine the size of an initialized flexible array member.
> -   If non-null, set *ARK when REF refers to an interior zero-length
> +   If non-null, set *SAM when REF refers to an interior zero-length
>     array or a trailing one-element array.
>     Returns the size as sizetype (which might be zero for an object
>     with an uninitialized flexible array member) or null if the size
> -   cannot be determined.  */
> +   cannot be determined.
> +   when FOR_ARRAY_BOUND_CHECK is true, this routine is called for
> +   -Warray-bounds check only, due to historical reason, the LEVEL
> +   of -Warray-bounds=LEVEL is not controled by -fstrict-flex-arrays.  */
>  
>  tree
> -component_ref_size (tree ref, special_array_member *sam /* = NULL */)
> +component_ref_size (tree ref, special_array_member *sam /* = NULL */,
> +		    bool for_array_bound_check /* = FALSE */)
>  {
>    gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
>  
>    special_array_member sambuf;
>    if (!sam)
>      sam = &sambuf;
> -  *sam = special_array_member::none;
> +  *sam = component_ref_sam_type (ref);
>  
>    /* The object/argument referenced by the COMPONENT_REF and its type.  */
>    tree arg = TREE_OPERAND (ref, 0);
> @@ -12958,41 +13037,49 @@ component_ref_size (tree ref, special_array_member *sam /* = NULL */)
>  	return (tree_int_cst_equal (memsize, TYPE_SIZE_UNIT (memtype))
>  		? memsize : NULL_TREE);
>  
> -      bool trailing = array_ref_flexible_size_p (ref);
> -      bool zero_length = integer_zerop (memsize);
> -      if (!trailing && !zero_length)
> -	/* MEMBER is either an interior array or is an array with
> -	   more than one element.  */
> +      /* 2-or-more elements arrays are treated as normal arrays by default.  */
> +      if (*sam == special_array_member::int_n
> +	  || *sam == special_array_member::trail_n)
>  	return memsize;
>  
> -      if (zero_length)
> +      /* For -Warray-bounds=LEVEL check, historically we have to treat
> +	 trail_0 and trail_1 as flexible arrays by default when LEVEL=1.
> +	 for other cases, flag_strict_flex_arrays will control how to treat
> +	 the trailing arrays as flexiable array members.  */
> +
> +      tree afield_decl = TREE_OPERAND (ref, 1);
> +      unsigned int strict_flex_array_level
> +	= strict_flex_array_level_of (afield_decl);
> +
> +      if (!for_array_bound_check)
>  	{
> -	  if (trailing)
> -	    *sam = special_array_member::trail_0;
> -	  else
> +	  switch (strict_flex_array_level)
>  	    {
> -	      *sam = special_array_member::int_0;
> -	      memsize = NULL_TREE;
> +	      case 3:
> +		/* Treaing 0-length trailing arrays as normal array.  */
> +		if (*sam == special_array_member::trail_0)
> +		  return size_zero_node;
> +		/* FALLTHROUGH.  */
> +	      case 2:
> +		/* Treating 1-element trailing arrays as normal array.  */
> +		if (*sam == special_array_member::trail_1)
> +		  return memsize;
> +		/* FALLTHROUGH.  */
> +	      case 1:
> +		/* Treating 2-or-more elements trailing arrays as normal
> +		   array.  */
> +		if (*sam == special_array_member::trail_n)
> +		  return memsize;
> +		/* FALLTHROUGH.  */
> +	      case 0:
> +		break;
> +	      default:
> +		gcc_unreachable ();
>  	    }
>  	}
>  
> -      if (!zero_length)
> -	if (tree dom = TYPE_DOMAIN (memtype))
> -	  if (tree min = TYPE_MIN_VALUE (dom))
> -	    if (tree max = TYPE_MAX_VALUE (dom))
> -	      if (TREE_CODE (min) == INTEGER_CST
> -		  && TREE_CODE (max) == INTEGER_CST)
> -		{
> -		  offset_int minidx = wi::to_offset (min);
> -		  offset_int maxidx = wi::to_offset (max);
> -		  offset_int neltsm1 = maxidx - minidx;
> -		  if (neltsm1 > 0)
> -		    /* MEMBER is an array with more than one element.  */
> -		    return memsize;
> -
> -		  if (neltsm1 == 0)
> -		    *sam = special_array_member::trail_1;
> -		}
> +	if (*sam == special_array_member::int_0)
> +	  memsize = NULL_TREE;
>  
>        /* For a reference to a zero- or one-element array member of a union
>  	 use the size of the union instead of the size of the member.  */
> diff --git a/gcc/tree.h b/gcc/tree.h
> index 0fcdd6b06d0..f81a1f6efa1 100644
> --- a/gcc/tree.h
> +++ b/gcc/tree.h
> @@ -5551,28 +5551,33 @@ extern tree array_ref_low_bound (tree);
>  /* Returns true if REF is an array reference, a component reference,
>     or a memory reference to an array whose actual size might be larger
>     than its upper bound implies.  */
> -extern bool array_ref_flexible_size_p (tree);
> +extern bool array_ref_flexible_size_p (tree, bool * = NULL);
>  
>  /* Return a tree representing the offset, in bytes, of the field referenced
>     by EXP.  This does not include any offset in DECL_FIELD_BIT_OFFSET.  */
>  extern tree component_ref_field_offset (tree);
>  
> -/* Describes a "special" array member due to which component_ref_size
> -   returns null.  */
> +/* Describes a "special" array member for a COMPONENT_REF.  */
>  enum struct special_array_member
>    {
>      none,	/* Not a special array member.  */
>      int_0,	/* Interior array member with size zero.  */
>      trail_0,	/* Trailing array member with size zero.  */
> -    trail_1	/* Trailing array member with one element.  */
> +    trail_1,	/* Trailing array member with one element.  */
> +    trail_n,	/* Trailing array member with two or more elements.  */
> +    int_n	/* Interior array member with one or more elements.  */
>    };
>  
> +/* Determines the special array member type for a COMPONENT_REF.  */
> +extern special_array_member component_ref_sam_type (tree);
> +
>  /* Return the size of the member referenced by the COMPONENT_REF, using
>     its initializer expression if necessary in order to determine the size
>     of an initialized flexible array member.  The size might be zero for
>     an object with an uninitialized flexible array member or null if it
>     cannot be determined.  */
> -extern tree component_ref_size (tree, special_array_member * = NULL);
> +extern tree component_ref_size (tree, special_array_member * = NULL,
> +				bool = false);
>  
>  extern int tree_map_base_eq (const void *, const void *);
>  extern unsigned int tree_map_base_hash (const void *);
> 

-- 
Richard Biener <rguenther@suse.de>
SUSE Software Solutions Germany GmbH, Frankenstrasse 146, 90461 Nuernberg,
Germany; GF: Ivo Totev, Andrew Myers, Andrew McDonald, Boudien Moerman;
HRB 36809 (AG Nuernberg)