[PATCH]: Cleanup tests for the three types of INDIRECT_REFs
Daniel Berlin
dberlin@dberlin.org
Thu Sep 23 19:31:00 GMT 2004
This patch introduces INDIRECT_REF_P, so that we aren't directly checking
for three different tree codes everywhere we just want to know if we've
got an INDIRECT_REF or MISALIGNED_INDIRECT_REF or ALIGN_INDIRECT_REF.
It is a purely mechanical change.
Bootstrapped and regtested on i686-pc-linux-gnu.
Okay for mainline?
2004-09-23 Daniel Berlin <dberlin@dberlin.org>
* tree.h (INDIRECT_REF_P): New macro.
* alias.c (get_alias_set): Use it
(nonoverlapping_memrefs_p): Ditto.
* emit-rtl.c (mem_expr_equal_p): Ditto.
(set_mem_attributes_minus_bitpos): Ditto.
(is_gimple_addressable): Ditto.
(get_base_address): Ditto.
* tree-ssa-alias.c (find_ptr_derefernece): Ditto.
* tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Ditto.
* tree-ssa-dom.c (record_equivalences_from_stmt): Ditto.
* tree-ssa-loop-im.c (is_call_clobbered_ref): Ditto.
* tree-ssa-loop-ivopts.c (find_interesting_uses_address): Ditto.
(add_address_candidates): Ditto.
(rewrite_address_base): Ditto.
Index: tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.h,v
retrieving revision 1.629
diff -u -p -r1.629 tree.h
--- tree.h 23 Sep 2004 14:34:20 -0000 1.629
+++ tree.h 23 Sep 2004 18:51:02 -0000
@@ -96,6 +96,12 @@ extern const enum tree_code_class tree_c
#define DECL_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration)
+/* Nonzero if CODE represents a INDIRECT_REF. */
+#define INDIRECT_REF_P(CODE)\
+ (TREE_CODE (CODE) == INDIRECT_REF \
+ || TREE_CODE (CODE) == MISALIGNED_INDIRECT_REF \
+ || TREE_CODE (CODE) == ALIGN_INDIRECT_REF)
+
/* Nonzero if CODE represents a reference. */
#define REFERENCE_CLASS_P(CODE)\
Index: alias.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/alias.c,v
retrieving revision 1.243
diff -u -p -r1.243 alias.c
--- alias.c 23 Sep 2004 14:34:14 -0000 1.243
+++ alias.c 23 Sep 2004 18:51:00 -0000
@@ -450,9 +450,7 @@ get_alias_set (tree t)
}
/* Check for accesses through restrict-qualified pointers. */
- if (TREE_CODE (inner) == INDIRECT_REF
- || TREE_CODE (inner) == ALIGN_INDIRECT_REF
- || TREE_CODE (inner) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (inner))
{
tree decl = find_base_decl (TREE_OPERAND (inner, 0));
@@ -2008,9 +2006,7 @@ nonoverlapping_memrefs_p (rtx x, rtx y)
moffsetx = adjust_offset_for_component_ref (exprx, moffsetx);
exprx = t;
}
- else if (TREE_CODE (exprx) == INDIRECT_REF
- || TREE_CODE (exprx) == ALIGN_INDIRECT_REF
- || TREE_CODE (exprx) == MISALIGNED_INDIRECT_REF)
+ else if (INDIRECT_REF_P (exprx))
{
exprx = TREE_OPERAND (exprx, 0);
if (flag_argument_noalias < 2
@@ -2027,9 +2023,7 @@ nonoverlapping_memrefs_p (rtx x, rtx y)
moffsety = adjust_offset_for_component_ref (expry, moffsety);
expry = t;
}
- else if (TREE_CODE (expry) == INDIRECT_REF
- || TREE_CODE (expry) == ALIGN_INDIRECT_REF
- || TREE_CODE (expry) == MISALIGNED_INDIRECT_REF)
+ else if (INDIRECT_REF_P (expry))
{
expry = TREE_OPERAND (expry, 0);
if (flag_argument_noalias < 2
Index: emit-rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/emit-rtl.c,v
retrieving revision 1.416
diff -u -p -r1.416 emit-rtl.c
--- emit-rtl.c 23 Sep 2004 14:34:15 -0000 1.416
+++ emit-rtl.c 23 Sep 2004 18:51:01 -0000
@@ -1485,9 +1485,7 @@ mem_expr_equal_p (tree expr1, tree expr2
&& mem_expr_equal_p (TREE_OPERAND (expr1, 1), /* field decl */
TREE_OPERAND (expr2, 1));
- if (TREE_CODE (expr1) == INDIRECT_REF
- || TREE_CODE (expr1) == ALIGN_INDIRECT_REF
- || TREE_CODE (expr1) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (expr1))
return mem_expr_equal_p (TREE_OPERAND (expr1, 0),
TREE_OPERAND (expr2, 0));
@@ -1685,9 +1683,7 @@ set_mem_attributes_minus_bitpos (rtx ref
the size we got from the type? */
}
else if (flag_argument_noalias > 1
- && (TREE_CODE (t2) == INDIRECT_REF
- || TREE_CODE (t2) == ALIGN_INDIRECT_REF
- || TREE_CODE (t2) == MISALIGNED_INDIRECT_REF)
+ && (INDIRECT_REF_P (t2))
&& TREE_CODE (TREE_OPERAND (t2, 0)) == PARM_DECL)
{
expr = t2;
@@ -1698,9 +1694,7 @@ set_mem_attributes_minus_bitpos (rtx ref
/* If this is a Fortran indirect argument reference, record the
parameter decl. */
else if (flag_argument_noalias > 1
- && (TREE_CODE (t) == INDIRECT_REF
- || TREE_CODE (t) == ALIGN_INDIRECT_REF
- || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
+ && (INDIRECT_REF_P (t))
&& TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
{
expr = t;
Index: tree-gimple.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-gimple.c,v
retrieving revision 2.25
diff -u -p -r2.25 tree-gimple.c
--- tree-gimple.c 23 Sep 2004 14:34:19 -0000 2.25
+++ tree-gimple.c 23 Sep 2004 18:51:01 -0000
@@ -323,9 +323,8 @@ is_gimple_addressable (tree t)
return (is_gimple_id (t) || handled_component_p (t)
|| TREE_CODE (t) == REALPART_EXPR
|| TREE_CODE (t) == IMAGPART_EXPR
- || TREE_CODE (t) == INDIRECT_REF
- || TREE_CODE (t) == ALIGN_INDIRECT_REF
- || TREE_CODE (t) == MISALIGNED_INDIRECT_REF);
+ || INDIRECT_REF_P (t));
+
}
/* Return true if T is function invariant. Or rather a restricted
@@ -565,9 +564,7 @@ get_base_address (tree t)
if (SSA_VAR_P (t)
|| TREE_CODE (t) == STRING_CST
|| TREE_CODE (t) == CONSTRUCTOR
- || TREE_CODE (t) == MISALIGNED_INDIRECT_REF
- || TREE_CODE (t) == ALIGN_INDIRECT_REF
- || TREE_CODE (t) == INDIRECT_REF)
+ || INDIRECT_REF_P (t))
return t;
else
return NULL_TREE;
Index: tree-ssa-alias.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-alias.c,v
retrieving revision 2.43
diff -u -p -r2.43 tree-ssa-alias.c
--- tree-ssa-alias.c 23 Sep 2004 14:34:19 -0000 2.43
+++ tree-ssa-alias.c 23 Sep 2004 18:51:01 -0000
@@ -502,9 +502,7 @@ find_ptr_dereference (tree *tp, int *wal
{
tree ptr = (tree) data;
- if ((TREE_CODE (*tp) == INDIRECT_REF
- || TREE_CODE (*tp) == ALIGN_INDIRECT_REF
- || TREE_CODE (*tp) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (*tp)
&& TREE_OPERAND (*tp, 0) == ptr)
return *tp;
Index: tree-ssa-dce.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-dce.c,v
retrieving revision 2.19
diff -u -p -r2.19 tree-ssa-dce.c
--- tree-ssa-dce.c 23 Sep 2004 14:34:19 -0000 2.19
+++ tree-ssa-dce.c 23 Sep 2004 18:51:01 -0000
@@ -418,9 +418,7 @@ mark_stmt_if_obviously_necessary (tree s
if (is_global_var (lhs))
mark_stmt_necessary (stmt, true);
}
- else if (TREE_CODE (lhs) == INDIRECT_REF
- || TREE_CODE (lhs) == ALIGN_INDIRECT_REF
- || TREE_CODE (lhs) == MISALIGNED_INDIRECT_REF)
+ else if (INDIRECT_REF_P (lhs))
{
tree ptr = TREE_OPERAND (lhs, 0);
struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
Index: tree-ssa-dom.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-dom.c,v
retrieving revision 2.51
diff -u -p -r2.51 tree-ssa-dom.c
--- tree-ssa-dom.c 23 Sep 2004 14:34:19 -0000 2.51
+++ tree-ssa-dom.c 23 Sep 2004 18:51:01 -0000
@@ -2414,9 +2414,7 @@ record_equivalences_from_stmt (tree stmt
t = TREE_OPERAND (t, 0);
/* Now see if this is a pointer dereference. */
- if (TREE_CODE (t) == INDIRECT_REF
- || TREE_CODE (t) == ALIGN_INDIRECT_REF
- || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (t))
{
tree op = TREE_OPERAND (t, 0);
Index: tree-ssa-loop-im.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-loop-im.c,v
retrieving revision 2.14
diff -u -p -r2.14 tree-ssa-loop-im.c
--- tree-ssa-loop-im.c 23 Sep 2004 14:34:19 -0000 2.14
+++ tree-ssa-loop-im.c 23 Sep 2004 18:51:01 -0000
@@ -1103,9 +1103,7 @@ is_call_clobbered_ref (tree ref)
if (DECL_P (base))
return is_call_clobbered (base);
- if (TREE_CODE (base) == INDIRECT_REF
- || TREE_CODE (base) == ALIGN_INDIRECT_REF
- || TREE_CODE (base) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (base))
{
/* Check whether the alias tags associated with the pointer
are call clobbered. */
Index: tree-ssa-loop-ivopts.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-loop-ivopts.c,v
retrieving revision 2.12
diff -u -p -r2.12 tree-ssa-loop-ivopts.c
--- tree-ssa-loop-ivopts.c 23 Sep 2004 14:34:19 -0000 2.12
+++ tree-ssa-loop-ivopts.c 23 Sep 2004 18:51:01 -0000
@@ -1269,9 +1269,7 @@ find_interesting_uses_address (struct iv
|| zero_p (step))
goto fail;
- if (TREE_CODE (base) == INDIRECT_REF
- || TREE_CODE (base) == ALIGN_INDIRECT_REF
- || TREE_CODE (base) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (base))
base = TREE_OPERAND (base, 0);
else
base = build_addr (base);
@@ -1701,9 +1699,7 @@ add_address_candidates (struct ivopts_da
if (base != TREE_OPERAND (iv->base, 0))
{
- if (TREE_CODE (base) == INDIRECT_REF
- || TREE_CODE (base) == ALIGN_INDIRECT_REF
- || TREE_CODE (base) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (base))
base = TREE_OPERAND (base, 0);
else
base = build_addr (base);
@@ -3837,9 +3833,7 @@ rewrite_address_base (block_stmt_iterato
if (!var || TREE_CODE (with) != SSA_NAME)
goto do_rewrite;
- if (TREE_CODE (var) == INDIRECT_REF
- || TREE_CODE (var) == ALIGN_INDIRECT_REF
- || TREE_CODE (var) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (var))
var = TREE_OPERAND (var, 0);
if (TREE_CODE (var) == SSA_NAME)
{
@@ -3876,9 +3870,7 @@ rewrite_address_base (block_stmt_iterato
do_rewrite:
orig = NULL_TREE;
- if (TREE_CODE (*op) == INDIRECT_REF
- || TREE_CODE (*op) == ALIGN_INDIRECT_REF
- || TREE_CODE (*op) == MISALIGNED_INDIRECT_REF)
+ if (INDIRECT_REF_P (*op))
orig = REF_ORIGINAL (*op);
if (!orig)
orig = unshare_and_remove_ssa_names (*op);
More information about the Gcc-patches
mailing list