re PR middle-end/34668 (ICE in find_compatible_field with -combine)

2008-01-16  Jakub Jelinek  <jakub@redhat.com>
	Richard Guenther  <rguenther@suse.de>

	PR c/34668
	* gimplify.c (fold_indirect_ref_rhs): Rename to ...
	(gimple_fold_indirect_ref_rhs): ... this.
	(gimple_fold_indirect_ref): New function with foldings
	that preserve lvalueness.
	(gimplify_modify_expr_rhs): Call gimple_fold_indirect_ref_rhs.
	* tree-flow.h (gimple_fold_indirect_ref): Declare.
	* tree-inline.c (copy_body_r): Use gimple_fold_indirect_ref
	to fold an INDIRECT_REF, fall back to the old use of
	fold_indirect_ref_1.

	* gcc.dg/pr34668-1.c: New test.
	* gcc.dg/pr34668-2.c: Likewise.

Co-Authored-By: Richard Guenther <rguenther@suse.de>

From-SVN: r131572

gcc/ChangeLog

+2008-01-16  Jakub Jelinek  <jakub@redhat.com>
+	Richard Guenther  <rguenther@suse.de>
+
+	PR c/34668
+	* gimplify.c (fold_indirect_ref_rhs): Rename to ...
+	(gimple_fold_indirect_ref_rhs): ... this.
+	(gimple_fold_indirect_ref): New function with foldings
+	that preserve lvalueness.
+	(gimplify_modify_expr_rhs): Call gimple_fold_indirect_ref_rhs.
+	* tree-flow.h (gimple_fold_indirect_ref): Declare.
+	* tree-inline.c (copy_body_r): Use gimple_fold_indirect_ref
+	to fold an INDIRECT_REF, fall back to the old use of
+	fold_indirect_ref_1.
+
 2008-01-16  Sebastian Pop  <sebastian.pop@amd.com>
 
 	* tree-data-ref.c (subscript_dependence_tester_1): Call 

gcc/gimplify.c

 /* Tree lowering pass.  This pass converts the GENERIC functions-as-trees
    tree representation into the GIMPLE form.
-   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
+   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
    Free Software Foundation, Inc.
    Major work done by Sebastian Pop <s.pop@laposte.net>,
    Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
@@ -3449,13 +3449,12 @@ gimplify_init_constructor (tree *expr_p, tree *pre_p,
 
 /* Given a pointer value OP0, return a simplified version of an
    indirection through OP0, or NULL_TREE if no simplification is
-   possible.  This may only be applied to a rhs of an expression.
-   Note that the resulting type may be different from the type pointed
-   to in the sense that it is still compatible from the langhooks
-   point of view. */
+   possible.  Note that the resulting type may be different from
+   the type pointed to in the sense that it is still compatible
+   from the langhooks point of view. */
 
-static tree
-fold_indirect_ref_rhs (tree t)
+tree
+gimple_fold_indirect_ref (tree t)
 {
   tree type = TREE_TYPE (TREE_TYPE (t));
   tree sub = t;
@@ -3473,9 +3472,10 @@ fold_indirect_ref_rhs (tree t)
       /* *&p => p */
       if (useless_type_conversion_p (type, optype))
         return op;
+
       /* *(foo *)&fooarray => fooarray[0] */
-      else if (TREE_CODE (optype) == ARRAY_TYPE
-	       && useless_type_conversion_p (type, TREE_TYPE (optype)))
+      if (TREE_CODE (optype) == ARRAY_TYPE
+	  && useless_type_conversion_p (type, TREE_TYPE (optype)))
        {
          tree type_domain = TYPE_DOMAIN (optype);
          tree min_val = size_zero_node;
@@ -3492,7 +3492,7 @@ fold_indirect_ref_rhs (tree t)
       tree type_domain;
       tree min_val = size_zero_node;
       tree osub = sub;
-      sub = fold_indirect_ref_rhs (sub);
+      sub = gimple_fold_indirect_ref (sub);
       if (! sub)
 	sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
@@ -3504,6 +3504,19 @@ fold_indirect_ref_rhs (tree t)
   return NULL_TREE;
 }
 
+/* Given a pointer value OP0, return a simplified version of an
+   indirection through OP0, or NULL_TREE if no simplification is
+   possible.  This may only be applied to a rhs of an expression.
+   Note that the resulting type may be different from the type pointed
+   to in the sense that it is still compatible from the langhooks
+   point of view. */
+
+static tree
+gimple_fold_indirect_ref_rhs (tree t)
+{
+  return gimple_fold_indirect_ref (t);
+}
+
 /* Subroutine of gimplify_modify_expr to do simplifications of
    MODIFY_EXPRs based on the code of the RHS.  We loop for as long as
    something changes.  */
@@ -3557,7 +3570,7 @@ gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
 	     This kind of code arises in C++ when an object is bound
 	     to a const reference, and if "x" is a TARGET_EXPR we want
 	     to take advantage of the optimization below.  */
-	  tree t = fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
+	  tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
 	  if (t)
 	    {
 	      *from_p = t;

gcc/testsuite/ChangeLog

+2008-01-16  Jakub Jelinek  <jakub@redhat.com>
+	Richard Guenther  <rguenther@suse.de>
+
+	PR c/34668
+	* gcc.dg/pr34668-1.c: New test.
+	* gcc.dg/pr34668-2.c: Likewise.
+
 2008-01-16  Richard Guenther  <rguenther@suse.de>
 
 	PR c++/33819

gcc/testsuite/gcc.dg/pr34668-1.c

+/* PR c/34668 */
+/* { dg-do compile } */
+/* { dg-options "--combine -O2" } */
+/* { dg-additional-sources "pr34668-2.c" } */
+
+struct optab { unsigned code; };
+extern struct optab optab_table[1];
+
+void
+init_optab (struct optab *op)
+{
+  op->code = 0xdead;
+}
+
+void
+set_conv_libfunc (void)
+{
+  init_optab (&optab_table[0]);
+}

gcc/testsuite/gcc.dg/pr34668-2.c

+/* PR c/34668 */
+/* { dg-do compile } */
+
+struct optab { unsigned code; };
+extern struct optab optab_table[1];

gcc/tree-flow.h

@@ -1125,6 +1125,7 @@ extern void register_jump_thread (edge, edge);
 tree force_gimple_operand (tree, tree *, bool, tree);
 tree force_gimple_operand_bsi (block_stmt_iterator *, tree, bool, tree,
 			       bool, enum bsi_iterator_update);
+tree gimple_fold_indirect_ref (tree);
 
 /* In tree-ssa-structalias.c */
 bool find_what_p_points_to (tree);

gcc/tree-inline.c

@@ -696,11 +696,18 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
 	      tree type = TREE_TYPE (TREE_TYPE (*n));
 	      new = unshare_expr (*n);
 	      old = *tp;
-	      *tp = fold_indirect_ref_1 (type, new);
+	      *tp = gimple_fold_indirect_ref (new);
 	      if (! *tp)
 	        {
 		  if (TREE_CODE (new) == ADDR_EXPR)
-		    *tp = TREE_OPERAND (new, 0);
+		    {
+		      *tp = fold_indirect_ref_1 (type, new);
+		      /* ???  We should either assert here or build
+			 a VIEW_CONVERT_EXPR instead of blindly leaking
+			 incompatible types to our IL.  */
+		      if (! *tp)
+			*tp = TREE_OPERAND (new, 0);
+		    }
 	          else
 		    {
 	              *tp = build1 (INDIRECT_REF, type, new);