2004-12-02  Alexandre Oliva  <aoliva@redhat.com>

	* decl.c (copy_tree_replacing_r, struct replace_node): New.
	(grok_reference_init): Use them to replace uses of a reference
	being initialized with a NULL dereference.

2005-01-03  Jakub Jelinek  <jakub@redhat.com>

	* g++.dg/other/ref1.C: New test.

--- gcc/cp/decl.c.jj	2003-03-28 22:03:02.000000000 +0100
+++ gcc/cp/decl.c	2005-01-03 11:45:24.669972609 +0100
@@ -1,6 +1,6 @@
 /* Process declarations and variables for C compiler.
    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002, 2003  Free Software Foundation, Inc.
+   2001, 2002, 2003, 2004  Free Software Foundation, Inc.
    Contributed by Michael Tiemann (tiemann@cygnus.com)
 
 This file is part of GNU CC.
@@ -7535,6 +7535,30 @@ start_decl_1 (decl)
     DECL_INITIAL (decl) = NULL_TREE;
 }
 
+static tree copy_tree_replacing_r PARAMS ((tree *, int *, void *));
+
+struct replace_node
+{
+  tree from, to;
+};
+
+static tree
+copy_tree_replacing_r (tp, walk_subtrees, data)
+     tree *tp;
+     int *walk_subtrees;
+     void *data;
+{
+  struct replace_node *rn = data;
+
+  if (*tp != rn->from)
+    return copy_tree_r (tp, walk_subtrees, NULL);
+
+  *tp = rn->to;
+  *walk_subtrees = 0;
+
+  return NULL;
+}
+
 /* Handle initialization of references.
    These three arguments are from `cp_finish_decl', and have the
    same meaning here that they do there.
@@ -7565,6 +7589,35 @@ grok_reference_init (decl, type, init)
       return NULL_TREE;
     }
 
+  /* Replace occurrences of a reference variable in its own
+     initializer with a zero-initialized NULL reference.  If we don't
+     do this and the reference initializer ends up requiring a
+     temporary (as it almost always will in this case), we'll end up
+     with the initializer of the temporary referencing the reference
+     variable before it's in scope, which crashes because we haven't
+     expanded the reference declaration yet, so its DECL_RTL is NULL.
+     This is equivalent to zero-initializing the reference variable,
+     expanding the temporary definition with initializer, then binding
+     the reference to the temporary, without requiring all the revamp
+     in reference handling that mainline undergone for GCC 3.4.  It
+     actually changes behavior a little bit, in that a reference
+     initialized to itself will now be bound to a NULL reference
+     instead of getting an indeterminate value, but since using it
+     before initialization invokes undefined behavior, either way is
+     fine.  */
+  if (find_tree (init, decl))
+    {
+      struct replace_node rn;
+
+      rn.from = decl;
+      rn.to = build1 (NOP_EXPR, type, integer_zero_node);
+      
+      walk_tree (&init, copy_tree_replacing_r, &rn, NULL);
+
+      if (warn_uninitialized)
+	warning ("reference used in its own initializer");
+    }
+
   if (TREE_CODE (init) == TREE_LIST)
     init = build_compound_expr (init);
 
--- gcc/testsuite/g++.dg/other/ref1.C.jj	2005-01-03 11:46:43.005868429 +0100
+++ gcc/testsuite/g++.dg/other/ref1.C	2005-01-03 11:47:34.475601869 +0100
@@ -0,0 +1,19 @@
+// { dg-do compile }
+// { dg-options "-O2" }
+
+struct A
+{
+  A ();
+  ~A ();
+};
+
+extern const A &bar ();
+extern A baz ();
+extern int operator!= (const A &x, const A &y);
+
+void foo (const A &x)
+{
+  /* This has undefined behaviour, as a is used before it is initialized.
+     Still, we shouldn't ICE on it.  */
+  const A &a = a != bar () ? x : baz ();
+}