From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2028) id 96F183858D1E; Wed, 9 Nov 2022 15:48:46 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 96F183858D1E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1668008926; bh=8dzpXrRVfVJLTeRl7eft54xdg7oYDI/xliWtHA1Hbyc=; h=From:To:Subject:Date:From; b=ouqnKTo8/KS5VkX/jXC8txLRn5zGVtiA+8MNRFXjcfZrpTyyNG6b5CvUMEqA2DGY9 1LnXk7GG8wuYPU46v7m8Hv4erLdvU2Se4wGOzvJCeVMqwgW9Q0kcR4XGCvvm/0uNJ0 f3+VPCGZSkE2+CuxlFTXcM5dkMc9YmHJjT78jxUw= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Qing Zhao To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-3858] Change the name of array_at_struct_end_p to array_ref_flexible_size_p X-Act-Checkin: gcc X-Git-Author: Qing Zhao X-Git-Refname: refs/heads/master X-Git-Oldrev: 0b3d926d796050468b8a844e5fb8c20bda741c26 X-Git-Newrev: ace0ae09332bbc6b95e084c2c2b17c466339ff76 Message-Id: <20221109154846.96F183858D1E@sourceware.org> Date: Wed, 9 Nov 2022 15:48:46 +0000 (GMT) List-Id: https://gcc.gnu.org/g:ace0ae09332bbc6b95e084c2c2b17c466339ff76 commit r13-3858-gace0ae09332bbc6b95e084c2c2b17c466339ff76 Author: Qing Zhao Date: Wed Nov 9 15:48:04 2022 +0000 Change the name of array_at_struct_end_p to array_ref_flexible_size_p 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. Diff: --- 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 410544c17bb..8d4079870be 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 172098787dd..574bd2e65d9 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -12727,8 +12727,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; @@ -12743,10 +12743,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; @@ -12879,6 +12879,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. */ @@ -12974,7 +12975,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 d6a5fdf6d81..a863d2e50e5 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -5554,10 +5554,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. */