[1/2] Change the name of array_at_struct_end_p to array_ref_flexible_size_p

Message ID 20221108145113.955321-2-qing.zhao@oracle.com
State Accepted
Headers
Series Add a new warning option -Wstrict-flex-array |

Checks

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

Commit Message

Qing Zhao Nov. 8, 2022, 2:51 p.m. UTC
  The name of the utility routine "array_at_struct_end_p" is misleading
and should be changed to a new name that more accurately reflects its
real meaning.

The routine "array_at_struct_end_p" is used to check whether an array
reference is to an array whose actual size might be larger than its
upper bound implies, which includes 3 different cases:

   A. a ref to a flexible array member at the end of a structure;
   B. a ref to an array with a different type against the original decl;
   C. a ref to an array that was passed as a parameter;

The old name only reflects the above case A, therefore very confusing
when reading the corresponding gcc source code.

In this patch, A new name "array_ref_flexible_size_p" is used to replace
the old name.

All the references to the routine "array_at_struct_end_p" was replaced
with this new name, and the corresponding comments were updated to make
them clean and consistent.

gcc/ChangeLog:

	* gimple-array-bounds.cc (trailing_array): Replace
	array_at_struct_end_p with new name and update comments.
	* gimple-fold.cc (get_range_strlen_tree): Likewise.
	* gimple-ssa-warn-restrict.cc (builtin_memref::builtin_memref):
	Likewise.
	* graphite-sese-to-poly.cc (bounds_are_valid): Likewise.
	* tree-if-conv.cc (idx_within_array_bound): Likewise.
	* tree-object-size.cc (addr_object_size): Likewise.
	* tree-ssa-alias.cc (component_ref_to_zero_sized_trailing_array_p):
	Likewise.
	(stmt_kills_ref_p): Likewise.
	* tree-ssa-loop-niter.cc (idx_infer_loop_bounds): Likewise.
	* tree-ssa-strlen.cc (maybe_set_strlen_range): Likewise.
	* tree.cc (array_at_struct_end_p): Rename to ...
	(array_ref_flexible_size_p): ... this.
	(component_ref_size): Replace array_at_struct_end_p with new name.
	* tree.h (array_at_struct_end_p): Rename to ...
	(array_ref_flexible_size_p): ... this.
---
 gcc/gimple-array-bounds.cc      |  4 ++--
 gcc/gimple-fold.cc              |  6 ++----
 gcc/gimple-ssa-warn-restrict.cc |  5 +++--
 gcc/graphite-sese-to-poly.cc    |  4 ++--
 gcc/tree-if-conv.cc             |  7 +++----
 gcc/tree-object-size.cc         |  2 +-
 gcc/tree-ssa-alias.cc           |  8 ++++----
 gcc/tree-ssa-loop-niter.cc      | 15 +++++++--------
 gcc/tree-ssa-strlen.cc          |  2 +-
 gcc/tree.cc                     | 11 ++++++-----
 gcc/tree.h                      |  8 ++++----
 11 files changed, 35 insertions(+), 37 deletions(-)
  

Comments

Richard Biener Nov. 9, 2022, 7:57 a.m. UTC | #1
On Tue, 8 Nov 2022, Qing Zhao wrote:

> The name of the utility routine "array_at_struct_end_p" is misleading
> and should be changed to a new name that more accurately reflects its
> real meaning.
> 
> The routine "array_at_struct_end_p" is used to check whether an array
> reference is to an array whose actual size might be larger than its
> upper bound implies, which includes 3 different cases:
> 
>    A. a ref to a flexible array member at the end of a structure;
>    B. a ref to an array with a different type against the original decl;
>    C. a ref to an array that was passed as a parameter;
> 
> The old name only reflects the above case A, therefore very confusing
> when reading the corresponding gcc source code.
> 
> In this patch, A new name "array_ref_flexible_size_p" is used to replace
> the old name.
> 
> All the references to the routine "array_at_struct_end_p" was replaced
> with this new name, and the corresponding comments were updated to make
> them clean and consistent.

Since you seem to feel strongly about this - OK.

Thanks,
Richard.

> gcc/ChangeLog:
> 
> 	* gimple-array-bounds.cc (trailing_array): Replace
> 	array_at_struct_end_p with new name and update comments.
> 	* gimple-fold.cc (get_range_strlen_tree): Likewise.
> 	* gimple-ssa-warn-restrict.cc (builtin_memref::builtin_memref):
> 	Likewise.
> 	* graphite-sese-to-poly.cc (bounds_are_valid): Likewise.
> 	* tree-if-conv.cc (idx_within_array_bound): Likewise.
> 	* tree-object-size.cc (addr_object_size): Likewise.
> 	* tree-ssa-alias.cc (component_ref_to_zero_sized_trailing_array_p):
> 	Likewise.
> 	(stmt_kills_ref_p): Likewise.
> 	* tree-ssa-loop-niter.cc (idx_infer_loop_bounds): Likewise.
> 	* tree-ssa-strlen.cc (maybe_set_strlen_range): Likewise.
> 	* tree.cc (array_at_struct_end_p): Rename to ...
> 	(array_ref_flexible_size_p): ... this.
> 	(component_ref_size): Replace array_at_struct_end_p with new name.
> 	* tree.h (array_at_struct_end_p): Rename to ...
> 	(array_ref_flexible_size_p): ... this.
> ---
>  gcc/gimple-array-bounds.cc      |  4 ++--
>  gcc/gimple-fold.cc              |  6 ++----
>  gcc/gimple-ssa-warn-restrict.cc |  5 +++--
>  gcc/graphite-sese-to-poly.cc    |  4 ++--
>  gcc/tree-if-conv.cc             |  7 +++----
>  gcc/tree-object-size.cc         |  2 +-
>  gcc/tree-ssa-alias.cc           |  8 ++++----
>  gcc/tree-ssa-loop-niter.cc      | 15 +++++++--------
>  gcc/tree-ssa-strlen.cc          |  2 +-
>  gcc/tree.cc                     | 11 ++++++-----
>  gcc/tree.h                      |  8 ++++----
>  11 files changed, 35 insertions(+), 37 deletions(-)
> 
> diff --git a/gcc/gimple-array-bounds.cc b/gcc/gimple-array-bounds.cc
> index e190b93aa85..fbf448e045d 100644
> --- a/gcc/gimple-array-bounds.cc
> +++ b/gcc/gimple-array-bounds.cc
> @@ -129,7 +129,7 @@ get_ref_size (tree arg, tree *pref)
>  }
>  
>  /* Return true if REF is (likely) an ARRAY_REF to a trailing array member
> -   of a struct.  It refines array_at_struct_end_p by detecting a pointer
> +   of a struct.  It refines array_ref_flexible_size_p by detecting a pointer
>     to an array and an array parameter declared using the [N] syntax (as
>     opposed to a pointer) and returning false.  Set *PREF to the decl or
>     expression REF refers to.  */
> @@ -167,7 +167,7 @@ trailing_array (tree arg, tree *pref)
>  	return false;
>      }
>  
> -  return array_at_struct_end_p (arg);
> +  return array_ref_flexible_size_p (arg);
>  }
>  
>  /* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible
> diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
> index 9055cd8982d..cafd331ca98 100644
> --- a/gcc/gimple-fold.cc
> +++ b/gcc/gimple-fold.cc
> @@ -1690,13 +1690,11 @@ get_range_strlen_tree (tree arg, bitmap visited, strlen_range_kind rkind,
>  	  /* Handle a MEM_REF into a DECL accessing an array of integers,
>  	     being conservative about references to extern structures with
>  	     flexible array members that can be initialized to arbitrary
> -	     numbers of elements as an extension (static structs are okay).
> -	     FIXME: Make this less conservative -- see
> -	     component_ref_size in tree.cc.  */
> +	     numbers of elements as an extension (static structs are okay).  */
>  	  tree ref = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
>  	  if ((TREE_CODE (ref) == PARM_DECL || VAR_P (ref))
>  	      && (decl_binds_to_current_def_p (ref)
> -		  || !array_at_struct_end_p (arg)))
> +		  || !array_ref_flexible_size_p (arg)))
>  	    {
>  	      /* Fail if the offset is out of bounds.  Such accesses
>  		 should be diagnosed at some point.  */
> diff --git a/gcc/gimple-ssa-warn-restrict.cc b/gcc/gimple-ssa-warn-restrict.cc
> index b7ed15c8902..832456ba6fc 100644
> --- a/gcc/gimple-ssa-warn-restrict.cc
> +++ b/gcc/gimple-ssa-warn-restrict.cc
> @@ -296,8 +296,9 @@ builtin_memref::builtin_memref (pointer_query &ptrqry, gimple *stmt, tree expr,
>    tree basetype = TREE_TYPE (base);
>    if (TREE_CODE (basetype) == ARRAY_TYPE)
>      {
> -      if (ref && array_at_struct_end_p (ref))
> -	;   /* Use the maximum possible offset for last member arrays.  */
> +      if (ref && array_ref_flexible_size_p (ref))
> +	;   /* Use the maximum possible offset for an array that might
> +	       have flexible size.  */
>        else if (tree basesize = TYPE_SIZE_UNIT (basetype))
>  	if (TREE_CODE (basesize) == INTEGER_CST)
>  	  /* Size could be non-constant for a variable-length type such
> diff --git a/gcc/graphite-sese-to-poly.cc b/gcc/graphite-sese-to-poly.cc
> index 51ba3af204f..7eb24c1c991 100644
> --- a/gcc/graphite-sese-to-poly.cc
> +++ b/gcc/graphite-sese-to-poly.cc
> @@ -536,9 +536,9 @@ bounds_are_valid (tree ref, tree low, tree high)
>        || !tree_fits_shwi_p (high))
>      return false;
>  
> -  /* 1-element arrays at end of structures may extend over
> +  /* An array that has flexible size may extend over
>       their declared size.  */
> -  if (array_at_struct_end_p (ref)
> +  if (array_ref_flexible_size_p (ref)
>        && operand_equal_p (low, high, 0))
>      return false;
>  
> diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc
> index a83b013d2ad..34bb507ff3b 100644
> --- a/gcc/tree-if-conv.cc
> +++ b/gcc/tree-if-conv.cc
> @@ -763,10 +763,9 @@ idx_within_array_bound (tree ref, tree *idx, void *dta)
>    if (TREE_CODE (ref) != ARRAY_REF)
>      return false;
>  
> -  /* For arrays at the end of the structure, we are not guaranteed that they
> -     do not really extend over their declared size.  However, for arrays of
> -     size greater than one, this is unlikely to be intended.  */
> -  if (array_at_struct_end_p (ref))
> +  /* For arrays that might have flexible sizes, it is not guaranteed that they
> +     do not extend over their declared size.  */
> +  if (array_ref_flexible_size_p (ref))
>      return false;
>  
>    ev = analyze_scalar_evolution (loop, *idx);
> diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc
> index 1f04cb80fd0..2e5d267d8ce 100644
> --- a/gcc/tree-object-size.cc
> +++ b/gcc/tree-object-size.cc
> @@ -633,7 +633,7 @@ addr_object_size (struct object_size_info *osi, const_tree ptr,
>  			v = NULL_TREE;
>  			break;
>  		      }
> -		    is_flexible_array_mem_ref = array_at_struct_end_p (v);
> +		    is_flexible_array_mem_ref = array_ref_flexible_size_p (v);
>  		    while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
>  		      if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
>  			  != UNION_TYPE
> diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
> index b4c65da5718..d3a91b1f238 100644
> --- a/gcc/tree-ssa-alias.cc
> +++ b/gcc/tree-ssa-alias.cc
> @@ -1073,7 +1073,7 @@ component_ref_to_zero_sized_trailing_array_p (tree ref)
>  	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 1))) == ARRAY_TYPE
>  	  && (!TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)))
>  	      || integer_zerop (TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)))))
> -	  && array_at_struct_end_p (ref));
> +	  && array_ref_flexible_size_p (ref));
>  }
>  
>  /* Worker for aliasing_component_refs_p. Most parameters match parameters of
> @@ -3433,10 +3433,10 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
>  	    }
>  	  /* Finally check if the lhs has the same address and size as the
>  	     base candidate of the access.  Watch out if we have dropped
> -	     an array-ref that was at struct end, this means ref->ref may
> -	     be outside of the TYPE_SIZE of its base.  */
> +	     an array-ref that might have flexible size, this means ref->ref
> +	     may be outside of the TYPE_SIZE of its base.  */
>  	  if ((! innermost_dropped_array_ref
> -	       || ! array_at_struct_end_p (innermost_dropped_array_ref))
> +	       || ! array_ref_flexible_size_p (innermost_dropped_array_ref))
>  	      && (lhs == base
>  		  || (((TYPE_SIZE (TREE_TYPE (lhs))
>  			== TYPE_SIZE (TREE_TYPE (base)))
> diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc
> index 4ffcef4f4ff..3fbbf4367ed 100644
> --- a/gcc/tree-ssa-loop-niter.cc
> +++ b/gcc/tree-ssa-loop-niter.cc
> @@ -3716,18 +3716,17 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
>    struct ilb_data *data = (struct ilb_data *) dta;
>    tree ev, init, step;
>    tree low, high, type, next;
> -  bool sign, upper = true, at_end = false;
> +  bool sign, upper = true, has_flexible_size = false;
>    class loop *loop = data->loop;
>  
>    if (TREE_CODE (base) != ARRAY_REF)
>      return true;
>  
> -  /* For arrays at the end of the structure, we are not guaranteed that they
> -     do not really extend over their declared size.  However, for arrays of
> -     size greater than one, this is unlikely to be intended.  */
> -  if (array_at_struct_end_p (base))
> +  /* For arrays that might have flexible sizes, it is not guaranteed that they
> +     do not really extend over their declared size.  */ 
> +  if (array_ref_flexible_size_p (base))
>      {
> -      at_end = true;
> +      has_flexible_size = true;
>        upper = false;
>      }
>  
> @@ -3760,9 +3759,9 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
>    sign = tree_int_cst_sign_bit (step);
>    type = TREE_TYPE (step);
>  
> -  /* The array of length 1 at the end of a structure most likely extends
> +  /* The array that might have flexible size most likely extends
>       beyond its bounds.  */
> -  if (at_end
> +  if (has_flexible_size
>        && operand_equal_p (low, high, 0))
>      return true;
>  
> diff --git a/gcc/tree-ssa-strlen.cc b/gcc/tree-ssa-strlen.cc
> index 5afbae1b72e..b87c7c7ce1f 100644
> --- a/gcc/tree-ssa-strlen.cc
> +++ b/gcc/tree-ssa-strlen.cc
> @@ -1987,7 +1987,7 @@ maybe_set_strlen_range (tree lhs, tree src, tree bound)
>  	 suggests if it's treated as a poor-man's flexible array member.  */
>        src = TREE_OPERAND (src, 0);
>        if (TREE_CODE (src) != MEM_REF
> -	  && !array_at_struct_end_p (src))
> +	  && !array_ref_flexible_size_p (src))
>  	{
>  	  tree type = TREE_TYPE (src);
>  	  tree size = TYPE_SIZE_UNIT (type);
> diff --git a/gcc/tree.cc b/gcc/tree.cc
> index 04603c8c902..d2b0b34a725 100644
> --- a/gcc/tree.cc
> +++ b/gcc/tree.cc
> @@ -12710,8 +12710,8 @@ array_ref_up_bound (tree exp)
>    return NULL_TREE;
>  }
>  
> -/* Returns true if REF is an array reference, component reference,
> -   or memory reference to an array whose actual size might be larger
> +/* 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, there are multiple cases:
>     A. a ref to a flexible array member at the end of a structure;
>     B. a ref to an array with a different type against the original decl;
> @@ -12726,10 +12726,10 @@ 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] = ...;
> +*/
>  
> -   FIXME, the name of this routine need to be changed to be more accurate.  */
>  bool
> -array_at_struct_end_p (tree ref)
> +array_ref_flexible_size_p (tree ref)
>  {
>    /* the TYPE for this array referece.  */
>    tree atype = NULL_TREE;
> @@ -12862,6 +12862,7 @@ array_at_struct_end_p (tree ref)
>    return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
>  }
>  
> +
>  /* 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.  */
>  
> @@ -12957,7 +12958,7 @@ 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_at_struct_end_p (ref);
> +      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
> diff --git a/gcc/tree.h b/gcc/tree.h
> index a50f7b2be9d..0fcdd6b06d0 100644
> --- a/gcc/tree.h
> +++ b/gcc/tree.h
> @@ -5548,10 +5548,10 @@ extern tree array_ref_up_bound (tree);
>     EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
>  extern tree array_ref_low_bound (tree);
>  
> -/* Returns true if REF is an array reference or a component reference
> -   to an array at the end of a structure.  If this is the case, the array
> -   may be allocated larger than its upper bound implies.  */
> -extern bool array_at_struct_end_p (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);
>  
>  /* 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.  */
>
  
Qing Zhao Nov. 9, 2022, 3:50 p.m. UTC | #2
Thanks.

Committed as:  https://gcc.gnu.org/pipermail/gcc-cvs/2022-November/373830.html

Qing
> On Nov 9, 2022, at 2:57 AM, Richard Biener <rguenther@suse.de> wrote:
> 
> On Tue, 8 Nov 2022, Qing Zhao wrote:
> 
>> The name of the utility routine "array_at_struct_end_p" is misleading
>> and should be changed to a new name that more accurately reflects its
>> real meaning.
>> 
>> The routine "array_at_struct_end_p" is used to check whether an array
>> reference is to an array whose actual size might be larger than its
>> upper bound implies, which includes 3 different cases:
>> 
>>   A. a ref to a flexible array member at the end of a structure;
>>   B. a ref to an array with a different type against the original decl;
>>   C. a ref to an array that was passed as a parameter;
>> 
>> The old name only reflects the above case A, therefore very confusing
>> when reading the corresponding gcc source code.
>> 
>> In this patch, A new name "array_ref_flexible_size_p" is used to replace
>> the old name.
>> 
>> All the references to the routine "array_at_struct_end_p" was replaced
>> with this new name, and the corresponding comments were updated to make
>> them clean and consistent.
> 
> Since you seem to feel strongly about this - OK.
> 
> Thanks,
> Richard.
> 
>> gcc/ChangeLog:
>> 
>> 	* gimple-array-bounds.cc (trailing_array): Replace
>> 	array_at_struct_end_p with new name and update comments.
>> 	* gimple-fold.cc (get_range_strlen_tree): Likewise.
>> 	* gimple-ssa-warn-restrict.cc (builtin_memref::builtin_memref):
>> 	Likewise.
>> 	* graphite-sese-to-poly.cc (bounds_are_valid): Likewise.
>> 	* tree-if-conv.cc (idx_within_array_bound): Likewise.
>> 	* tree-object-size.cc (addr_object_size): Likewise.
>> 	* tree-ssa-alias.cc (component_ref_to_zero_sized_trailing_array_p):
>> 	Likewise.
>> 	(stmt_kills_ref_p): Likewise.
>> 	* tree-ssa-loop-niter.cc (idx_infer_loop_bounds): Likewise.
>> 	* tree-ssa-strlen.cc (maybe_set_strlen_range): Likewise.
>> 	* tree.cc (array_at_struct_end_p): Rename to ...
>> 	(array_ref_flexible_size_p): ... this.
>> 	(component_ref_size): Replace array_at_struct_end_p with new name.
>> 	* tree.h (array_at_struct_end_p): Rename to ...
>> 	(array_ref_flexible_size_p): ... this.
>> ---
>> gcc/gimple-array-bounds.cc      |  4 ++--
>> gcc/gimple-fold.cc              |  6 ++----
>> gcc/gimple-ssa-warn-restrict.cc |  5 +++--
>> gcc/graphite-sese-to-poly.cc    |  4 ++--
>> gcc/tree-if-conv.cc             |  7 +++----
>> gcc/tree-object-size.cc         |  2 +-
>> gcc/tree-ssa-alias.cc           |  8 ++++----
>> gcc/tree-ssa-loop-niter.cc      | 15 +++++++--------
>> gcc/tree-ssa-strlen.cc          |  2 +-
>> gcc/tree.cc                     | 11 ++++++-----
>> gcc/tree.h                      |  8 ++++----
>> 11 files changed, 35 insertions(+), 37 deletions(-)
>> 
>> diff --git a/gcc/gimple-array-bounds.cc b/gcc/gimple-array-bounds.cc
>> index e190b93aa85..fbf448e045d 100644
>> --- a/gcc/gimple-array-bounds.cc
>> +++ b/gcc/gimple-array-bounds.cc
>> @@ -129,7 +129,7 @@ get_ref_size (tree arg, tree *pref)
>> }
>> 
>> /* Return true if REF is (likely) an ARRAY_REF to a trailing array member
>> -   of a struct.  It refines array_at_struct_end_p by detecting a pointer
>> +   of a struct.  It refines array_ref_flexible_size_p by detecting a pointer
>>    to an array and an array parameter declared using the [N] syntax (as
>>    opposed to a pointer) and returning false.  Set *PREF to the decl or
>>    expression REF refers to.  */
>> @@ -167,7 +167,7 @@ trailing_array (tree arg, tree *pref)
>> 	return false;
>>     }
>> 
>> -  return array_at_struct_end_p (arg);
>> +  return array_ref_flexible_size_p (arg);
>> }
>> 
>> /* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible
>> diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
>> index 9055cd8982d..cafd331ca98 100644
>> --- a/gcc/gimple-fold.cc
>> +++ b/gcc/gimple-fold.cc
>> @@ -1690,13 +1690,11 @@ get_range_strlen_tree (tree arg, bitmap visited, strlen_range_kind rkind,
>> 	  /* Handle a MEM_REF into a DECL accessing an array of integers,
>> 	     being conservative about references to extern structures with
>> 	     flexible array members that can be initialized to arbitrary
>> -	     numbers of elements as an extension (static structs are okay).
>> -	     FIXME: Make this less conservative -- see
>> -	     component_ref_size in tree.cc.  */
>> +	     numbers of elements as an extension (static structs are okay).  */
>> 	  tree ref = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
>> 	  if ((TREE_CODE (ref) == PARM_DECL || VAR_P (ref))
>> 	      && (decl_binds_to_current_def_p (ref)
>> -		  || !array_at_struct_end_p (arg)))
>> +		  || !array_ref_flexible_size_p (arg)))
>> 	    {
>> 	      /* Fail if the offset is out of bounds.  Such accesses
>> 		 should be diagnosed at some point.  */
>> diff --git a/gcc/gimple-ssa-warn-restrict.cc b/gcc/gimple-ssa-warn-restrict.cc
>> index b7ed15c8902..832456ba6fc 100644
>> --- a/gcc/gimple-ssa-warn-restrict.cc
>> +++ b/gcc/gimple-ssa-warn-restrict.cc
>> @@ -296,8 +296,9 @@ builtin_memref::builtin_memref (pointer_query &ptrqry, gimple *stmt, tree expr,
>>   tree basetype = TREE_TYPE (base);
>>   if (TREE_CODE (basetype) == ARRAY_TYPE)
>>     {
>> -      if (ref && array_at_struct_end_p (ref))
>> -	;   /* Use the maximum possible offset for last member arrays.  */
>> +      if (ref && array_ref_flexible_size_p (ref))
>> +	;   /* Use the maximum possible offset for an array that might
>> +	       have flexible size.  */
>>       else if (tree basesize = TYPE_SIZE_UNIT (basetype))
>> 	if (TREE_CODE (basesize) == INTEGER_CST)
>> 	  /* Size could be non-constant for a variable-length type such
>> diff --git a/gcc/graphite-sese-to-poly.cc b/gcc/graphite-sese-to-poly.cc
>> index 51ba3af204f..7eb24c1c991 100644
>> --- a/gcc/graphite-sese-to-poly.cc
>> +++ b/gcc/graphite-sese-to-poly.cc
>> @@ -536,9 +536,9 @@ bounds_are_valid (tree ref, tree low, tree high)
>>       || !tree_fits_shwi_p (high))
>>     return false;
>> 
>> -  /* 1-element arrays at end of structures may extend over
>> +  /* An array that has flexible size may extend over
>>      their declared size.  */
>> -  if (array_at_struct_end_p (ref)
>> +  if (array_ref_flexible_size_p (ref)
>>       && operand_equal_p (low, high, 0))
>>     return false;
>> 
>> diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc
>> index a83b013d2ad..34bb507ff3b 100644
>> --- a/gcc/tree-if-conv.cc
>> +++ b/gcc/tree-if-conv.cc
>> @@ -763,10 +763,9 @@ idx_within_array_bound (tree ref, tree *idx, void *dta)
>>   if (TREE_CODE (ref) != ARRAY_REF)
>>     return false;
>> 
>> -  /* For arrays at the end of the structure, we are not guaranteed that they
>> -     do not really extend over their declared size.  However, for arrays of
>> -     size greater than one, this is unlikely to be intended.  */
>> -  if (array_at_struct_end_p (ref))
>> +  /* For arrays that might have flexible sizes, it is not guaranteed that they
>> +     do not extend over their declared size.  */
>> +  if (array_ref_flexible_size_p (ref))
>>     return false;
>> 
>>   ev = analyze_scalar_evolution (loop, *idx);
>> diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc
>> index 1f04cb80fd0..2e5d267d8ce 100644
>> --- a/gcc/tree-object-size.cc
>> +++ b/gcc/tree-object-size.cc
>> @@ -633,7 +633,7 @@ addr_object_size (struct object_size_info *osi, const_tree ptr,
>> 			v = NULL_TREE;
>> 			break;
>> 		      }
>> -		    is_flexible_array_mem_ref = array_at_struct_end_p (v);
>> +		    is_flexible_array_mem_ref = array_ref_flexible_size_p (v);
>> 		    while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
>> 		      if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
>> 			  != UNION_TYPE
>> diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
>> index b4c65da5718..d3a91b1f238 100644
>> --- a/gcc/tree-ssa-alias.cc
>> +++ b/gcc/tree-ssa-alias.cc
>> @@ -1073,7 +1073,7 @@ component_ref_to_zero_sized_trailing_array_p (tree ref)
>> 	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 1))) == ARRAY_TYPE
>> 	  && (!TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)))
>> 	      || integer_zerop (TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)))))
>> -	  && array_at_struct_end_p (ref));
>> +	  && array_ref_flexible_size_p (ref));
>> }
>> 
>> /* Worker for aliasing_component_refs_p. Most parameters match parameters of
>> @@ -3433,10 +3433,10 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
>> 	    }
>> 	  /* Finally check if the lhs has the same address and size as the
>> 	     base candidate of the access.  Watch out if we have dropped
>> -	     an array-ref that was at struct end, this means ref->ref may
>> -	     be outside of the TYPE_SIZE of its base.  */
>> +	     an array-ref that might have flexible size, this means ref->ref
>> +	     may be outside of the TYPE_SIZE of its base.  */
>> 	  if ((! innermost_dropped_array_ref
>> -	       || ! array_at_struct_end_p (innermost_dropped_array_ref))
>> +	       || ! array_ref_flexible_size_p (innermost_dropped_array_ref))
>> 	      && (lhs == base
>> 		  || (((TYPE_SIZE (TREE_TYPE (lhs))
>> 			== TYPE_SIZE (TREE_TYPE (base)))
>> diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc
>> index 4ffcef4f4ff..3fbbf4367ed 100644
>> --- a/gcc/tree-ssa-loop-niter.cc
>> +++ b/gcc/tree-ssa-loop-niter.cc
>> @@ -3716,18 +3716,17 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
>>   struct ilb_data *data = (struct ilb_data *) dta;
>>   tree ev, init, step;
>>   tree low, high, type, next;
>> -  bool sign, upper = true, at_end = false;
>> +  bool sign, upper = true, has_flexible_size = false;
>>   class loop *loop = data->loop;
>> 
>>   if (TREE_CODE (base) != ARRAY_REF)
>>     return true;
>> 
>> -  /* For arrays at the end of the structure, we are not guaranteed that they
>> -     do not really extend over their declared size.  However, for arrays of
>> -     size greater than one, this is unlikely to be intended.  */
>> -  if (array_at_struct_end_p (base))
>> +  /* For arrays that might have flexible sizes, it is not guaranteed that they
>> +     do not really extend over their declared size.  */ 
>> +  if (array_ref_flexible_size_p (base))
>>     {
>> -      at_end = true;
>> +      has_flexible_size = true;
>>       upper = false;
>>     }
>> 
>> @@ -3760,9 +3759,9 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
>>   sign = tree_int_cst_sign_bit (step);
>>   type = TREE_TYPE (step);
>> 
>> -  /* The array of length 1 at the end of a structure most likely extends
>> +  /* The array that might have flexible size most likely extends
>>      beyond its bounds.  */
>> -  if (at_end
>> +  if (has_flexible_size
>>       && operand_equal_p (low, high, 0))
>>     return true;
>> 
>> diff --git a/gcc/tree-ssa-strlen.cc b/gcc/tree-ssa-strlen.cc
>> index 5afbae1b72e..b87c7c7ce1f 100644
>> --- a/gcc/tree-ssa-strlen.cc
>> +++ b/gcc/tree-ssa-strlen.cc
>> @@ -1987,7 +1987,7 @@ maybe_set_strlen_range (tree lhs, tree src, tree bound)
>> 	 suggests if it's treated as a poor-man's flexible array member.  */
>>       src = TREE_OPERAND (src, 0);
>>       if (TREE_CODE (src) != MEM_REF
>> -	  && !array_at_struct_end_p (src))
>> +	  && !array_ref_flexible_size_p (src))
>> 	{
>> 	  tree type = TREE_TYPE (src);
>> 	  tree size = TYPE_SIZE_UNIT (type);
>> diff --git a/gcc/tree.cc b/gcc/tree.cc
>> index 04603c8c902..d2b0b34a725 100644
>> --- a/gcc/tree.cc
>> +++ b/gcc/tree.cc
>> @@ -12710,8 +12710,8 @@ array_ref_up_bound (tree exp)
>>   return NULL_TREE;
>> }
>> 
>> -/* Returns true if REF is an array reference, component reference,
>> -   or memory reference to an array whose actual size might be larger
>> +/* 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, there are multiple cases:
>>    A. a ref to a flexible array member at the end of a structure;
>>    B. a ref to an array with a different type against the original decl;
>> @@ -12726,10 +12726,10 @@ 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] = ...;
>> +*/
>> 
>> -   FIXME, the name of this routine need to be changed to be more accurate.  */
>> bool
>> -array_at_struct_end_p (tree ref)
>> +array_ref_flexible_size_p (tree ref)
>> {
>>   /* the TYPE for this array referece.  */
>>   tree atype = NULL_TREE;
>> @@ -12862,6 +12862,7 @@ array_at_struct_end_p (tree ref)
>>   return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
>> }
>> 
>> +
>> /* 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.  */
>> 
>> @@ -12957,7 +12958,7 @@ 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_at_struct_end_p (ref);
>> +      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
>> diff --git a/gcc/tree.h b/gcc/tree.h
>> index a50f7b2be9d..0fcdd6b06d0 100644
>> --- a/gcc/tree.h
>> +++ b/gcc/tree.h
>> @@ -5548,10 +5548,10 @@ extern tree array_ref_up_bound (tree);
>>    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
>> extern tree array_ref_low_bound (tree);
>> 
>> -/* Returns true if REF is an array reference or a component reference
>> -   to an array at the end of a structure.  If this is the case, the array
>> -   may be allocated larger than its upper bound implies.  */
>> -extern bool array_at_struct_end_p (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);
>> 
>> /* 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.  */
>> 
> 
> -- 
> 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)
  

Patch

diff --git a/gcc/gimple-array-bounds.cc b/gcc/gimple-array-bounds.cc
index e190b93aa85..fbf448e045d 100644
--- a/gcc/gimple-array-bounds.cc
+++ b/gcc/gimple-array-bounds.cc
@@ -129,7 +129,7 @@  get_ref_size (tree arg, tree *pref)
 }
 
 /* Return true if REF is (likely) an ARRAY_REF to a trailing array member
-   of a struct.  It refines array_at_struct_end_p by detecting a pointer
+   of a struct.  It refines array_ref_flexible_size_p by detecting a pointer
    to an array and an array parameter declared using the [N] syntax (as
    opposed to a pointer) and returning false.  Set *PREF to the decl or
    expression REF refers to.  */
@@ -167,7 +167,7 @@  trailing_array (tree arg, tree *pref)
 	return false;
     }
 
-  return array_at_struct_end_p (arg);
+  return array_ref_flexible_size_p (arg);
 }
 
 /* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible
diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
index 9055cd8982d..cafd331ca98 100644
--- a/gcc/gimple-fold.cc
+++ b/gcc/gimple-fold.cc
@@ -1690,13 +1690,11 @@  get_range_strlen_tree (tree arg, bitmap visited, strlen_range_kind rkind,
 	  /* Handle a MEM_REF into a DECL accessing an array of integers,
 	     being conservative about references to extern structures with
 	     flexible array members that can be initialized to arbitrary
-	     numbers of elements as an extension (static structs are okay).
-	     FIXME: Make this less conservative -- see
-	     component_ref_size in tree.cc.  */
+	     numbers of elements as an extension (static structs are okay).  */
 	  tree ref = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
 	  if ((TREE_CODE (ref) == PARM_DECL || VAR_P (ref))
 	      && (decl_binds_to_current_def_p (ref)
-		  || !array_at_struct_end_p (arg)))
+		  || !array_ref_flexible_size_p (arg)))
 	    {
 	      /* Fail if the offset is out of bounds.  Such accesses
 		 should be diagnosed at some point.  */
diff --git a/gcc/gimple-ssa-warn-restrict.cc b/gcc/gimple-ssa-warn-restrict.cc
index b7ed15c8902..832456ba6fc 100644
--- a/gcc/gimple-ssa-warn-restrict.cc
+++ b/gcc/gimple-ssa-warn-restrict.cc
@@ -296,8 +296,9 @@  builtin_memref::builtin_memref (pointer_query &ptrqry, gimple *stmt, tree expr,
   tree basetype = TREE_TYPE (base);
   if (TREE_CODE (basetype) == ARRAY_TYPE)
     {
-      if (ref && array_at_struct_end_p (ref))
-	;   /* Use the maximum possible offset for last member arrays.  */
+      if (ref && array_ref_flexible_size_p (ref))
+	;   /* Use the maximum possible offset for an array that might
+	       have flexible size.  */
       else if (tree basesize = TYPE_SIZE_UNIT (basetype))
 	if (TREE_CODE (basesize) == INTEGER_CST)
 	  /* Size could be non-constant for a variable-length type such
diff --git a/gcc/graphite-sese-to-poly.cc b/gcc/graphite-sese-to-poly.cc
index 51ba3af204f..7eb24c1c991 100644
--- a/gcc/graphite-sese-to-poly.cc
+++ b/gcc/graphite-sese-to-poly.cc
@@ -536,9 +536,9 @@  bounds_are_valid (tree ref, tree low, tree high)
       || !tree_fits_shwi_p (high))
     return false;
 
-  /* 1-element arrays at end of structures may extend over
+  /* An array that has flexible size may extend over
      their declared size.  */
-  if (array_at_struct_end_p (ref)
+  if (array_ref_flexible_size_p (ref)
       && operand_equal_p (low, high, 0))
     return false;
 
diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc
index a83b013d2ad..34bb507ff3b 100644
--- a/gcc/tree-if-conv.cc
+++ b/gcc/tree-if-conv.cc
@@ -763,10 +763,9 @@  idx_within_array_bound (tree ref, tree *idx, void *dta)
   if (TREE_CODE (ref) != ARRAY_REF)
     return false;
 
-  /* For arrays at the end of the structure, we are not guaranteed that they
-     do not really extend over their declared size.  However, for arrays of
-     size greater than one, this is unlikely to be intended.  */
-  if (array_at_struct_end_p (ref))
+  /* For arrays that might have flexible sizes, it is not guaranteed that they
+     do not extend over their declared size.  */
+  if (array_ref_flexible_size_p (ref))
     return false;
 
   ev = analyze_scalar_evolution (loop, *idx);
diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc
index 1f04cb80fd0..2e5d267d8ce 100644
--- a/gcc/tree-object-size.cc
+++ b/gcc/tree-object-size.cc
@@ -633,7 +633,7 @@  addr_object_size (struct object_size_info *osi, const_tree ptr,
 			v = NULL_TREE;
 			break;
 		      }
-		    is_flexible_array_mem_ref = array_at_struct_end_p (v);
+		    is_flexible_array_mem_ref = array_ref_flexible_size_p (v);
 		    while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
 		      if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
 			  != UNION_TYPE
diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
index b4c65da5718..d3a91b1f238 100644
--- a/gcc/tree-ssa-alias.cc
+++ b/gcc/tree-ssa-alias.cc
@@ -1073,7 +1073,7 @@  component_ref_to_zero_sized_trailing_array_p (tree ref)
 	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 1))) == ARRAY_TYPE
 	  && (!TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)))
 	      || integer_zerop (TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)))))
-	  && array_at_struct_end_p (ref));
+	  && array_ref_flexible_size_p (ref));
 }
 
 /* Worker for aliasing_component_refs_p. Most parameters match parameters of
@@ -3433,10 +3433,10 @@  stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
 	    }
 	  /* Finally check if the lhs has the same address and size as the
 	     base candidate of the access.  Watch out if we have dropped
-	     an array-ref that was at struct end, this means ref->ref may
-	     be outside of the TYPE_SIZE of its base.  */
+	     an array-ref that might have flexible size, this means ref->ref
+	     may be outside of the TYPE_SIZE of its base.  */
 	  if ((! innermost_dropped_array_ref
-	       || ! array_at_struct_end_p (innermost_dropped_array_ref))
+	       || ! array_ref_flexible_size_p (innermost_dropped_array_ref))
 	      && (lhs == base
 		  || (((TYPE_SIZE (TREE_TYPE (lhs))
 			== TYPE_SIZE (TREE_TYPE (base)))
diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc
index 4ffcef4f4ff..3fbbf4367ed 100644
--- a/gcc/tree-ssa-loop-niter.cc
+++ b/gcc/tree-ssa-loop-niter.cc
@@ -3716,18 +3716,17 @@  idx_infer_loop_bounds (tree base, tree *idx, void *dta)
   struct ilb_data *data = (struct ilb_data *) dta;
   tree ev, init, step;
   tree low, high, type, next;
-  bool sign, upper = true, at_end = false;
+  bool sign, upper = true, has_flexible_size = false;
   class loop *loop = data->loop;
 
   if (TREE_CODE (base) != ARRAY_REF)
     return true;
 
-  /* For arrays at the end of the structure, we are not guaranteed that they
-     do not really extend over their declared size.  However, for arrays of
-     size greater than one, this is unlikely to be intended.  */
-  if (array_at_struct_end_p (base))
+  /* For arrays that might have flexible sizes, it is not guaranteed that they
+     do not really extend over their declared size.  */ 
+  if (array_ref_flexible_size_p (base))
     {
-      at_end = true;
+      has_flexible_size = true;
       upper = false;
     }
 
@@ -3760,9 +3759,9 @@  idx_infer_loop_bounds (tree base, tree *idx, void *dta)
   sign = tree_int_cst_sign_bit (step);
   type = TREE_TYPE (step);
 
-  /* The array of length 1 at the end of a structure most likely extends
+  /* The array that might have flexible size most likely extends
      beyond its bounds.  */
-  if (at_end
+  if (has_flexible_size
       && operand_equal_p (low, high, 0))
     return true;
 
diff --git a/gcc/tree-ssa-strlen.cc b/gcc/tree-ssa-strlen.cc
index 5afbae1b72e..b87c7c7ce1f 100644
--- a/gcc/tree-ssa-strlen.cc
+++ b/gcc/tree-ssa-strlen.cc
@@ -1987,7 +1987,7 @@  maybe_set_strlen_range (tree lhs, tree src, tree bound)
 	 suggests if it's treated as a poor-man's flexible array member.  */
       src = TREE_OPERAND (src, 0);
       if (TREE_CODE (src) != MEM_REF
-	  && !array_at_struct_end_p (src))
+	  && !array_ref_flexible_size_p (src))
 	{
 	  tree type = TREE_TYPE (src);
 	  tree size = TYPE_SIZE_UNIT (type);
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 04603c8c902..d2b0b34a725 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -12710,8 +12710,8 @@  array_ref_up_bound (tree exp)
   return NULL_TREE;
 }
 
-/* Returns true if REF is an array reference, component reference,
-   or memory reference to an array whose actual size might be larger
+/* 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, there are multiple cases:
    A. a ref to a flexible array member at the end of a structure;
    B. a ref to an array with a different type against the original decl;
@@ -12726,10 +12726,10 @@  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] = ...;
+*/
 
-   FIXME, the name of this routine need to be changed to be more accurate.  */
 bool
-array_at_struct_end_p (tree ref)
+array_ref_flexible_size_p (tree ref)
 {
   /* the TYPE for this array referece.  */
   tree atype = NULL_TREE;
@@ -12862,6 +12862,7 @@  array_at_struct_end_p (tree ref)
   return afield_decl ? !DECL_NOT_FLEXARRAY (afield_decl) : true;
 }
 
+
 /* 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.  */
 
@@ -12957,7 +12958,7 @@  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_at_struct_end_p (ref);
+      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
diff --git a/gcc/tree.h b/gcc/tree.h
index a50f7b2be9d..0fcdd6b06d0 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -5548,10 +5548,10 @@  extern tree array_ref_up_bound (tree);
    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
 extern tree array_ref_low_bound (tree);
 
-/* Returns true if REF is an array reference or a component reference
-   to an array at the end of a structure.  If this is the case, the array
-   may be allocated larger than its upper bound implies.  */
-extern bool array_at_struct_end_p (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);
 
 /* 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.  */