diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 34b0a267e43..d41b7d504b6 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2010-04-07  Richard Guenther  <rguenther@suse.de>
+
+	PR middle-end/42617
+	* emit-rtl.c (set_mem_attributes_minus_bitpos): Do not
+	discard plain indirect references.
+	* fold-const.c (operand_equal_p): Guard against NULL_TREE
+	type.
+	* tree.c (tree_nop_conversion): Likewise.
+
 2010-04-07  Dodji Seketeli  <dodji@redhat.com>
 
 	PR debug/43628
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 6e1f9490614..dda2b0f0f70 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1750,6 +1750,7 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
 	      /* ??? Any reason the field size would be different than
 		 the size we got from the type?  */
 	    }
+
 	  else if (flag_argument_noalias > 1
 		   && (INDIRECT_REF_P (t2))
 		   && TREE_CODE (TREE_OPERAND (t2, 0)) == PARM_DECL)
@@ -1757,6 +1758,15 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
 	      expr = t2;
 	      offset = NULL;
 	    }
+
+	  /* If this is an indirect reference, record it.  */
+	  else if (TREE_CODE (t) == INDIRECT_REF
+		   || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
+	    {
+	      expr = t;
+	      offset = const0_rtx;
+	      apply_bitpos = bitpos;
+	    }
 	}
 
       /* If this is a Fortran indirect argument reference, record the
@@ -1769,6 +1779,15 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
 	  offset = NULL;
 	}
 
+      /* If this is an indirect reference, record it.  */
+      else if (TREE_CODE (t) == INDIRECT_REF
+	       || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
+	{
+	  expr = t;
+	  offset = const0_rtx;
+	  apply_bitpos = bitpos;
+	}
+
       if (!align_computed && !INDIRECT_REF_P (t))
 	{
 	  unsigned int obj_align
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index e79d934243d..62c86254ea1 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -3170,6 +3170,11 @@ operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
       || TREE_TYPE (arg1) == error_mark_node)
     return 0;
 
+  /* Similar, if either does not have a type (like a released SSA name), 
+     they aren't equal.  */
+  if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
+    return 0;
+
   /* Check equality of integer constants before bailing out due to
      precision differences.  */
   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
diff --git a/gcc/tree.c b/gcc/tree.c
index 863b51eda94..b72e0578260 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -10645,6 +10645,9 @@ tree_nop_conversion (const_tree exp)
   outer_type = TREE_TYPE (exp);
   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
 
+  if (!inner_type)
+    return false;
+
   /* Use precision rather then machine mode when we can, which gives
      the correct answer even for submode (bit-field) types.  */
   if ((INTEGRAL_TYPE_P (outer_type)