+2004-04-26 Richard Guenther <rguenth@gcc.gnu.org>
+
+ PR tree-optimization/17598
+ * fold-const.c (fold_binary): Fold comparisons of addresses
+ of COMPONENT_REFs which reference the same field to
+ comparisons of the addresses of the base objects.
+
2005-04-26 Julian Brown <julian@codesourcery.com>
* config/arm/arm.c (arm_return_in_msb): New function.
return t1;
}
+ /* Fold a comparison of the address of COMPONENT_REFs with the same
+ type and component to a comparison of the address of the base
+ object. In short, &x->a OP &y->a to x OP y and
+ &x->a OP &y.a to x OP &y */
+ if (TREE_CODE (arg0) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (arg0, 0)) == COMPONENT_REF
+ && TREE_CODE (arg1) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (arg1, 0)) == COMPONENT_REF)
+ {
+ tree cref0 = TREE_OPERAND (arg0, 0);
+ tree cref1 = TREE_OPERAND (arg1, 0);
+ if (TREE_OPERAND (cref0, 1) == TREE_OPERAND (cref1, 1))
+ {
+ tree op0 = TREE_OPERAND (cref0, 0);
+ tree op1 = TREE_OPERAND (cref1, 0);
+ if (TREE_CODE (op0) == INDIRECT_REF)
+ op0 = TREE_OPERAND (op0, 0);
+ else
+ {
+ tree ptype = build_pointer_type (TREE_TYPE (op0));
+ op0 = build1 (ADDR_EXPR, ptype, op0);
+ }
+ if (TREE_CODE (op1) == INDIRECT_REF)
+ op1 = TREE_OPERAND (op1, 0);
+ else
+ {
+ tree ptype = build_pointer_type (TREE_TYPE (op1));
+ op1 = build1 (ADDR_EXPR, ptype, op1);
+ }
+ return fold_build2 (code, type, op0, op1);
+ }
+ }
+
/* If this is a comparison of complex values and either or both sides
are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
--- /dev/null
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-generic" } */
+
+struct f
+{
+ int i;
+ int j;
+};
+
+struct g
+{
+ int i;
+ struct f j;
+ struct f *k;
+};
+
+int foo(struct f *x, struct f *y)
+{
+ return &x->j == &y->j; /* x == y */
+}
+
+struct f y;
+int bar(struct f *x)
+{
+ return &x->j == &y.j; /* x == &y */
+}
+
+struct g yy;
+int foobar(struct g *x)
+{
+ return &x->j.i == &yy.j.i; /* x == &yy */
+}
+int foobar2(struct g *x)
+{
+ return &x->k->i == &yy.k->i; /* x->k == yy.k */
+}
+
+/* { dg-final { scan-tree-dump-times "x == y" 1 "generic" } } */
+/* { dg-final { scan-tree-dump-times "x == &y" 2 "generic" } } */
+/* { dg-final { scan-tree-dump "x->k" "generic" } } */
+/* { dg-final { scan-tree-dump "yy.k" "generic" } } */
+/* { dg-final { cleanup-tree-dump "generic" } } */