[gcc r17-2497] [PATCH] alpha: do not gate cannot_copy_insn_p on reload_completed

https://gcc.gnu.org/g:7b18a7c536e62dffdbdbeb5f7457ff22f1cc44dc

commit r17-2497-g7b18a7c536e62dffdbdbeb5f7457ff22f1cc44dc
Author: Matt Turner <[email protected]>
Date:   Fri Jul 17 07:26:12 2026 -0600

    [PATCH] alpha: do not gate cannot_copy_insn_p on reload_completed
    
    alpha_legitimize_address emits movdi_er_tlsgd and movdi_er_tlsldm together
    with their paired call_value_osf_tlsgd/tlsldm at expand time, and both halves
    already carry the sequence number that ties the pair together.  Those patterns
    are marked with the cannot_copy attribute, but alpha_cannot_copy_insn_p
    returned false whenever !reload_completed, so the hook had no effect on any
    pass running before register allocation.
    
    Unrolling a loop whose body contains such a pair therefore copies the sequence
    number along with it.  With
    
      extern __thread int tv;
      extern int cond (int);
      int f (int n)
      {
        int s = 0;
        for (int i = 0; i < n; i++)
          if (cond (i))
            s += tv;
        return s;
      }
    
    compiled with -O2 -funroll-loops -fno-move-loop-invariants -fPIC
    -ftls-model=global-dynamic, the unroller produces seven copies of !tlsgd!1 and
    the assembler rejects the result:
    
      Error: duplicate !tlsgd!1
      Error: too many lituse insns for !lituse_tlsgd!1
    
    Drop the reload_completed test.  The gpdisp pairs are only created after
    reload, so this does not change their handling; it only lets the hook protect
    the TLS pairs that already exist before register allocation.  This is
    independent of the register allocator: the failure reproduces identically with
    both reload and LRA.
    
    gcc/
            * config/alpha/alpha.cc (alpha_cannot_copy_insn_p): Do not return
            false before reload_completed.  Update comment.
    
    gcc/testsuite/
            * gcc.target/alpha/tlsgd-dup-1.c: New test.

Diff:
---
 gcc/config/alpha/alpha.cc                    | 17 +++++++++++++----
 gcc/testsuite/gcc.target/alpha/tlsgd-dup-1.c | 22 ++++++++++++++++++++++
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/gcc/config/alpha/alpha.cc b/gcc/config/alpha/alpha.cc
index 9b8433c5bb04..90e4c21dd11b 100644
--- a/gcc/config/alpha/alpha.cc
+++ b/gcc/config/alpha/alpha.cc
@@ -1242,8 +1242,8 @@ split_small_symbolic_operand (rtx x)
 }
 
 /* Indicate that INSN cannot be duplicated.  This is true for any insn
-   that we've marked with gpdisp relocs, since those have to stay in
-   1-1 correspondence with one another.
+   that we've marked with a relocation sequence number, since those have
+   to stay in 1-1 correspondence with one another.
 
    Technically we could copy them if we could set up a mapping from one
    sequence number to another, across the set of insns to be duplicated.
@@ -1253,12 +1253,21 @@ split_small_symbolic_operand (rtx x)
    Also cannot allow jsr insns to be duplicated.  If they throw exceptions,
    then they'll be in a different block from their ldgp.  Which could lead
    the bb reorder code to think that it would be ok to copy just the block
-   containing the call and branch to the block containing the ldgp.  */
+   containing the call and branch to the block containing the ldgp.
+
+   Note this must not be gated on reload_completed.  While the gpdisp pairs
+   are only created after reload, alpha_legitimize_address emits
+   movdi_er_tlsgd and movdi_er_tlsldm together with their paired
+   call_value_osf_tlsgd/tlsldm at expand time, and those already carry the
+   sequence number that ties each pair together.  Returning false before
+   reload lets the pre-RA duplicators reach them: unrolling a loop whose
+   body holds such a pair copies the sequence number along with it, and the
+   assembler then rejects the result with "duplicate !tlsgd!N".  */
 
 static bool
 alpha_cannot_copy_insn_p (rtx_insn *insn)
 {
-  if (!reload_completed || !TARGET_EXPLICIT_RELOCS)
+  if (!TARGET_EXPLICIT_RELOCS)
     return false;
   if (recog_memoized (insn) >= 0)
     return get_attr_cannot_copy (insn);
diff --git a/gcc/testsuite/gcc.target/alpha/tlsgd-dup-1.c b/gcc/testsuite/gcc.target/alpha/tlsgd-dup-1.c
new file mode 100644
index 000000000000..33ffc4d5deaf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/alpha/tlsgd-dup-1.c
@@ -0,0 +1,22 @@
+/* Verify that a TLS sequence insn and its paired call are not duplicated by
+   the pre-RA passes.  Each movdi_er_tlsgd carries a sequence number that must
+   stay in 1-1 correspondence with the !lituse_tlsgd of its call; duplicating
+   the loop body used to copy both halves and make the assembler reject the
+   result with "duplicate !tlsgd!1".  */
+/* { dg-do assemble } */
+/* { dg-require-effective-target tls_native } */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-O2 -funroll-loops -fno-move-loop-invariants -fPIC -ftls-model=global-dynamic" } */
+
+extern __thread int tv;
+extern int cond (int);
+
+int
+f (int n)
+{
+  int s = 0;
+  for (int i = 0; i < n; i++)
+    if (cond (i))
+      s += tv;
+  return s;
+}