On Fri, 4 Nov 2005, Diego Novillo wrote:
> On Friday 04 November 2005 10:07, Richard Kenner wrote:
> > #if defined ENABLE_CHECKING
> > gcc_assert (handled_component_p (ref))
> > #endif
> >
> > If the comment says it has to be an ARRAY_REF, why not just check for
> > that?
>
> The comment is out of sync with the code. It's used in code that may be
> sending an arbitrary aggregate.
>
> Given that Dan asked to remove the call from tree-ssa-structalias.c, then
> we can take advantage and tighten the two predicates more.
>
> In ref_contains_indirect_ref:
> Rename to array_ref_contains_indirect_ref
> Add gcc_assert (TREE_CODE (ref) == ARRAY_REF) at the start.
>
> In ref_contains_array_ref:
> Leave the gcc_assert I proposed. That predicate is used for more than
> COMPONENT_REFs.
> The comment needs to be updated.
I bootstrapped and regtested the following on x86_64-unknown-linux-gnu.
Ok for mainline?
Thanks,
Richard.
2005-11-04 Richard Guenther <[EMAIL PROTECTED]>
* tree-flow.h (ref_contains_indirect_ref): Rename to
array_ref_contains_indirect_ref.
* tree-flow-inline.h (ref_contains_indirect_ref): Likewise.
(array_ref_contains_indirect_ref): Make comment match the code
and vice-versa.
(ref_contains_array_ref): Likewise.
* tree-ssa-structalias.c (find_func_aliases): Remove call to
ref_contains_indirect_ref.
* tree-ssa-loop-niter.c (infer_loop_bounds_from_undefined):
Rename calls to ref_contains_indirect_ref.
Index: tree-flow-inline.h
===================================================================
--- tree-flow-inline.h (revision 106485)
+++ tree-flow-inline.h (working copy)
@@ -1407,32 +1407,34 @@
return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
}
-/* Return true if REF, an ARRAY_REF, has an INDIRECT_REF somewhere in
- it. */
+/* Return true if REF, an ARRAY_REF, has an INDIRECT_REF somewhere in it. */
static inline bool
-ref_contains_indirect_ref (tree ref)
+array_ref_contains_indirect_ref (tree ref)
{
- while (handled_component_p (ref))
- {
- if (TREE_CODE (ref) == INDIRECT_REF)
- return true;
- ref = TREE_OPERAND (ref, 0);
- }
- return false;
+ gcc_assert (TREE_CODE (ref) == ARRAY_REF);
+
+ do {
+ ref = TREE_OPERAND (ref, 0);
+ } while (handled_component_p (ref));
+
+ return TREE_CODE (ref) == INDIRECT_REF;
}
-/* Return true if REF, a COMPONENT_REF, has an ARRAY_REF somewhere in it. */
+/* Return true if REF, a handled component reference, has an ARRAY_REF
+ somewhere in it. */
static inline bool
ref_contains_array_ref (tree ref)
{
- while (handled_component_p (ref))
- {
- if (TREE_CODE (ref) == ARRAY_REF)
- return true;
- ref = TREE_OPERAND (ref, 0);
- }
+ gcc_assert (handled_component_p (ref));
+
+ do {
+ if (TREE_CODE (ref) == ARRAY_REF)
+ return true;
+ ref = TREE_OPERAND (ref, 0);
+ } while (handled_component_p (ref));
+
return false;
}
Index: tree-flow.h
===================================================================
--- tree-flow.h (revision 106485)
+++ tree-flow.h (working copy)
@@ -614,7 +614,7 @@
static inline subvar_t get_subvars_for_var (tree);
static inline tree get_subvar_at (tree, unsigned HOST_WIDE_INT);
static inline bool ref_contains_array_ref (tree);
-static inline bool ref_contains_indirect_ref (tree);
+static inline bool array_ref_contains_indirect_ref (tree);
extern tree okay_component_ref_for_subvars (tree, unsigned HOST_WIDE_INT *,
unsigned HOST_WIDE_INT *);
static inline bool var_can_have_subvars (tree);
Index: tree-ssa-structalias.c
===================================================================
--- tree-ssa-structalias.c (revision 106485)
+++ tree-ssa-structalias.c (working copy)
@@ -2865,7 +2865,6 @@
containing pointers, dereferences, and call expressions. */
if (POINTER_TYPE_P (TREE_TYPE (lhsop))
|| AGGREGATE_TYPE_P (TREE_TYPE (lhsop))
- || ref_contains_indirect_ref (lhsop)
|| TREE_CODE (rhsop) == CALL_EXPR)
{
lhs = get_constraint_for (lhsop, NULL);
Index: tree-ssa-loop-niter.c
===================================================================
--- tree-ssa-loop-niter.c (revision 106485)
+++ tree-ssa-loop-niter.c (working copy)
@@ -1438,11 +1438,11 @@
/* For each array access, analyze its access function
and record a bound on the loop iteration domain. */
if (TREE_CODE (op1) == ARRAY_REF
- && !ref_contains_indirect_ref (op1))
+ && !array_ref_contains_indirect_ref (op1))
estimate_iters_using_array (stmt, op1);
if (TREE_CODE (op0) == ARRAY_REF
- && !ref_contains_indirect_ref (op0))
+ && !array_ref_contains_indirect_ref (op0))
estimate_iters_using_array (stmt, op0);
/* For each signed type variable in LOOP, analyze its
@@ -1494,7 +1494,7 @@
for (args = TREE_OPERAND (stmt, 1); args;
args = TREE_CHAIN (args))
if (TREE_CODE (TREE_VALUE (args)) == ARRAY_REF
- && !ref_contains_indirect_ref (TREE_VALUE (args)))
+ && !array_ref_contains_indirect_ref (TREE_VALUE (args)))
estimate_iters_using_array (stmt, TREE_VALUE (args));
break;
