reload1.c (reload): Ignore equivalences between pseudos and read only memory.

	* reload1.c (reload): Ignore equivalences between pseudos and
	read only memory.

From-SVN: r98466

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3fe9d9fa1077662d1bc55a0f764c5de8e17baf21..b0863f3a633aa8c37f866cf4f68a7b0d7dd357bf 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+2005-04-20  Jeff Law  <law@redhat.com>
+
+       * reload1.c (reload): Ignore equivalences between pseudos and
+       read only memory.
+
 2005-04-20  Joseph S. Myers  <joseph@codesourcery.com>
 
        PR c/12913

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 5e1ab1a27ccfae4c4c5f0a65e530e76917edebf5..b2200a8d3b39853f7f85b6b7fbd7dfcbcc2f190d 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -740,8 +740,20 @@ reload (rtx first, int global)
                     that is not a legitimate memory operand.  As later
                     stages of reload assume that all addresses found
                     in the reg_equiv_* arrays were originally legitimate,
-                    we ignore such REG_EQUIV notes.  */
-                 if (memory_operand (x, VOIDmode))
+
+                    It can also happen that a REG_EQUIV note contains a
+                    readonly memory location.  If the destination pseudo
+                    is set from some other value (typically a different
+                    pseudo), and the destination pseudo does not get a
+                    hard reg, then reload will replace the destination
+                    pseudo with its equivalent memory location.  This
+                    is horribly bad as it creates a store to a readonly
+                    memory location and a runtime segfault.  To avoid
+                    this problem we reject readonly memory locations
+                    for equivalences.  This is overly conservative as
+                    we could find all sets of the destination pseudo
+                    and remove them as they should be redundant.  */
+                 if (memory_operand (x, VOIDmode) && ! MEM_READONLY_P (x))
                    {
                      /* Always unshare the equivalence, so we can
                         substitute into this insn without touching the