https://gcc.gnu.org/g:aba5bc2ace29a112f38597a3256ec8066a464ce3

commit r17-5992-gaba5bc2ace29a112f38597a3256ec8066a464ce3
Author: Richard Biener <[email protected]>
Date:   Fri Nov 6 08:58:39 2026 +0100

    tree-optimization/128463 - store-merging vs calls
    
    The following fixes up alias handling in store-merging which failed
    to disregard TBAA when disambiguating against calls.  Instead of the
    attempt to fix that up with the explicit store handling simply
    ensure stmt_may_clobber_ref_p_1 doesn't use TBAA as we're sinking
    loads or stores across stores.
    
            PR tree-optimization/128463
            * gimple-ssa-store-merging.cc
            (pass_store_merging::terminate_all_aliasing_chains): Simplify.
            Do not use TBAA when checking whether a stmt may clobber ref.
            (stmts_may_clobber_ref_p): Likewise.
    
            * gcc.dg/torture/pr128463.c: New testcase.

Diff:
---
 gcc/gimple-ssa-store-merging.cc         | 12 ++-----
 gcc/testsuite/gcc.dg/torture/pr128463.c | 64 +++++++++++++++++++++++++++++++++
 2 files changed, 66 insertions(+), 10 deletions(-)

diff --git a/gcc/gimple-ssa-store-merging.cc b/gcc/gimple-ssa-store-merging.cc
index d205757e7a50..e66a036461fe 100644
--- a/gcc/gimple-ssa-store-merging.cc
+++ b/gcc/gimple-ssa-store-merging.cc
@@ -2666,9 +2666,6 @@ pass_store_merging::terminate_all_aliasing_chains 
(imm_store_chain_info
   if (!gimple_vuse (stmt))
     return false;
 
-  tree store_lhs = gimple_store_p (stmt) ? gimple_get_lhs (stmt) : NULL_TREE;
-  ao_ref store_lhs_ref;
-  ao_ref_init (&store_lhs_ref, store_lhs);
   for (imm_store_chain_info *next = m_stores_head, *cur = next; cur; cur = 
next)
     {
       next = cur->next;
@@ -2686,9 +2683,7 @@ pass_store_merging::terminate_all_aliasing_chains 
(imm_store_chain_info
          ao_ref lhs_ref;
          ao_ref_init (&lhs_ref, lhs);
          if (ref_maybe_used_by_stmt_p (stmt, &lhs_ref)
-             || stmt_may_clobber_ref_p_1 (stmt, &lhs_ref)
-             || (store_lhs && refs_may_alias_p_1 (&store_lhs_ref,
-                                                  &lhs_ref, false)))
+             || stmt_may_clobber_ref_p_1 (stmt, &lhs_ref, false))
            {
              if (dump_file && (dump_flags & TDF_DETAILS))
                {
@@ -2740,10 +2735,7 @@ stmts_may_clobber_ref_p (gimple *first, gimple *last, 
tree ref)
   do
     {
       stmt = SSA_NAME_DEF_STMT (vop);
-      if (stmt_may_clobber_ref_p_1 (stmt, &r))
-       return true;
-      if (gimple_store_p (stmt)
-         && refs_anti_dependent_p (ref, gimple_get_lhs (stmt)))
+      if (stmt_may_clobber_ref_p_1 (stmt, &r, false))
        return true;
       /* Avoid quadratic compile time by bounding the number of checks
         we perform.  */
diff --git a/gcc/testsuite/gcc.dg/torture/pr128463.c 
b/gcc/testsuite/gcc.dg/torture/pr128463.c
new file mode 100644
index 000000000000..22fd4d30c5d9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr128463.c
@@ -0,0 +1,64 @@
+/* { dg-do run } */
+
+struct Q {
+  float x;
+  int y;
+};
+
+int sum;
+
+int set(void *p, long long v, int n)
+{
+  int r = 0;
+  for (int i = 0; i < n; i++)
+    switch (i % 8) {
+    case 0: r = r * 3 + 1; break;
+    case 1: r = r * 5 + 2; break;
+    case 2: r = r * 7 + 3; break;
+    case 3: r = r * 9 + 4; break;
+    case 4: r = r * 11 + 5; break;
+    case 5: r = r * 13 + 6; break;
+    case 6: r = r * 15 + 7; break;
+    case 7: r = r * 17 + 8; break;
+    }
+  *(long long *)p = v;
+  return r;
+}
+
+int get(struct Q *q, int n)
+{
+  int r = 0;
+  for (int i = 0; i < n; i++)
+    switch (i % 8) {
+    case 0: r = r * 3 + 1; break;
+    case 1: r = r * 5 + 2; break;
+    case 2: r = r * 7 + 3; break;
+    case 3: r = r * 9 + 4; break;
+    case 4: r = r * 11 + 5; break;
+    case 5: r = r * 13 + 6; break;
+    case 6: r = r * 15 + 7; break;
+    case 7: r = r * 17 + 8; break;
+    }
+  return r + q->x + q->y;
+}
+
+volatile int n_;
+
+int main(int argc, char **argv)
+{
+  int n = n_;
+  char *b = __builtin_malloc(32);
+  for (int k = 1; k < 4; k++) {
+    struct Q *q = (struct Q *)(b + k * 8);
+    q->x = 1;
+    q->y = 2;
+    sum += q->y;
+  }
+  sum += set(b + 16, 5, n);
+  for (int k = 0; k < 8; k++)
+    b[8 + k] = b[24 + k];
+  sum += get((struct Q *)(b + 8), n);
+  if (sum != 9 || *(long long *)(b + 16) != 5)
+    __builtin_abort ();
+  return 0;
+}

Reply via email to