diff mbox series

[pushed,PR111497,LRA] : Copy substituted equivalence

Message ID 1b7a2897-2aa4-b1ed-0c42-afdef403ff06@redhat.com
State New
Headers show
Series [pushed,PR111497,LRA] : Copy substituted equivalence | expand

Commit Message

Vladimir Makarov Sept. 25, 2023, 8:22 p.m. UTC 
The following patch solves

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111497

The patch was successfully tested and bootstrapped on x86-64 and aarch64.
diff mbox series

Patch

commit 3c23defed384cf17518ad6c817d94463a445d21b
Author: Vladimir N. Makarov <vmakarov@redhat.com>
Date:   Mon Sep 25 16:19:50 2023 -0400

    [PR111497][LRA]: Copy substituted equivalence
    
    When we substitute the equivalence and it becomes shared, we can fail
    to correctly update reg info used by LRA.  This can result in wrong
    code generation, e.g. because of incorrect live analysis.  It can also
    result in compiler crash as the pseudo survives RA.  This is what
    exactly happened for the PR.  This patch solves this problem by
    unsharing substituted equivalences.
    
    gcc/ChangeLog:
    
            PR middle-end/111497
            * lra-constraints.cc (lra_constraints): Copy substituted
            equivalence.
            * lra.cc (lra): Change comment for calling unshare_all_rtl_again.
    
    gcc/testsuite/ChangeLog:
    
            PR middle-end/111497
            * g++.target/i386/pr111497.C: new test.

diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc
index 3aaa4906999..76a1393ab23 100644
--- a/gcc/lra-constraints.cc
+++ b/gcc/lra-constraints.cc
@@ -5424,6 +5424,11 @@  lra_constraints (bool first_p)
 					   loc_equivalence_callback, curr_insn);
 	      if (old != *curr_id->operand_loc[0])
 		{
+		  /* If we substitute pseudo by shared equivalence, we can fail
+		     to update LRA reg info and this can result in many
+		     unexpected consequences.  So keep rtl unshared:  */
+		  *curr_id->operand_loc[0]
+		    = copy_rtx (*curr_id->operand_loc[0]);
 		  lra_update_insn_regno_info (curr_insn);
 		  changed_p = true;
 		}
diff --git a/gcc/lra.cc b/gcc/lra.cc
index 563aff10b96..361f84fdacb 100644
--- a/gcc/lra.cc
+++ b/gcc/lra.cc
@@ -2579,9 +2579,8 @@  lra (FILE *f)
   if (inserted_p)
     commit_edge_insertions ();
 
-  /* Replacing pseudos with their memory equivalents might have
-     created shared rtx.  Subsequent passes would get confused
-     by this, so unshare everything here.  */
+  /* Subsequent passes expect that rtl is unshared, so unshare everything
+     here.  */
   unshare_all_rtl_again (get_insns ());
 
   if (flag_checking)
diff --git a/gcc/testsuite/g++.target/i386/pr111497.C b/gcc/testsuite/g++.target/i386/pr111497.C
new file mode 100644
index 00000000000..a645bb95907
--- /dev/null
+++ b/gcc/testsuite/g++.target/i386/pr111497.C
@@ -0,0 +1,22 @@ 
+// { dg-do compile { target ia32 } }
+// { dg-options "-march=i686 -mtune=generic -fPIC -O2 -g" }
+
+class A;
+struct B { const char *b1; int b2; };
+struct C : B { C (const char *x, int y) { b1 = x; b2 = y; } };
+struct D : C { D (B x) : C (x.b1, x.b2) {} };
+struct E { E (A *); };
+struct F : E { D f1, f2, f3, f4, f5, f6; F (A *, const B &, const B &, const B &); };
+struct G : F { G (A *, const B &, const B &, const B &); };
+struct H { int h; };
+struct I { H i; };
+struct J { I *j; };
+struct A : J {};
+inline F::F (A *x, const B &y, const B &z, const B &w)
+  : E(x), f1(y), f2(z), f3(w), f4(y), f5(z), f6(w) {}
+G::G (A *x, const B &y, const B &z, const B &w) : F(x, y, z, w)
+{
+  H *h = &x->j->i;
+  if (h)
+    h->h++;
+}