diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 82edafa4ba8af438c251803b54de85ccfc5da4b0..909008b3fa950d67770a831aac28fd50e1744f7b 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+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
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 52547415c0ac4bcb8ae19724d70d35ec8b8b2bba..1075d6544275c2d76f16b45d44f85a2ba52f5608 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -1,6 +1,6 @@
/* 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;
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index e2748361e74155cfba08dedd4786fdb4ffc4d863..c0e2196f027f240d4984ffa4ff02d8a45fd19212 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,10 @@
+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
diff --git a/gcc/testsuite/gcc.dg/pr34668-1.c b/gcc/testsuite/gcc.dg/pr34668-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5763bb61027ede02b9d3c825fb3b13577df7afc8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr34668-1.c
@@ -0,0 +1,19 @@
+/* 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]);
+}
diff --git a/gcc/testsuite/gcc.dg/pr34668-2.c b/gcc/testsuite/gcc.dg/pr34668-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..fab8f173fd3aff01e5660338f0992fb0efbe6ef1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr34668-2.c
@@ -0,0 +1,5 @@
+/* PR c/34668 */
+/* { dg-do compile } */
+
+struct optab { unsigned code; };
+extern struct optab optab_table[1];
diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index fae04041151af03035032c9c75a03c7807028a26..a96f8b2e0837d7448dd302a659f6c4be8d108ee8 100644
--- a/gcc/tree-flow.h
+++ b/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);
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index f825c5d88fba29ab4ffb4cb22e2dcac0de01caf5..6ac367ef0cee5da6e5a4139c4da73a1a1dd6c208 100644
--- a/gcc/tree-inline.c
+++ b/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);