dyn_relocs tidy

Many targets define their own dyn_relocs struct when they could use
struct elf_dyn_relocs.  This patch tidies that, and uses
readonly_dynrelocs in a few more places.

The SH adjust_dynamic_symbol had some really weird code dating back to
2002 that looked over dynamic relocations for any in SEC_HAS_CONTENTS
or SEC_READONLY sections, rather than just the usual SEC_READONLY
sections.  So basically any dynamic relocation.  What's more, the SH
relocate_section has no support for emitting dynamic relocations in
non-PIC.  In other words, SH has no support for avoiding copy relocs
in non-PIC.  I've made that more obvious by using "if (0 && ..)" in
asjust_dynamic_symbol.

Unfortunately, LM32, M32R, NDS32, and OR1K copied the bogus SH
adjust_dynamic_symbol code.  So none of those targets would have
avoided copy relocs.  LM32, M32R, NDS32 get the "if (0)" treatment
too.  (LM32 is even more broken in that non_got_ref is never set.)

OR1K relocate_section looks like it might support dynamic relocs in
non-PIC, so I've enabled the copy reloc avoidance code for that
target.

	* elf32-hppa.c (struct elf32_hppa_dyn_reloc_entry): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(elf32_hppa_adjust_dynamic_symbol): Comment tidy.
	* elf32-lm32.c (struct elf_lm32_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(lm32_elf_adjust_dynamic_symbol): Use readonly_dynrelocs, but disable.
	Disable -z no-copyreloc too.
	* elf32-m32r.c (struct elf_m32r_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(m32r_elf_adjust_dynamic_symbol): Use readonly_dynrelocs, but disable.
	Disable -z no-copyreloc too.
	* elf32-metag.c (struct elf_metag_dyn_reloc_entry): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(elf_metag_adjust_dynamic_symbol): Use readonly_dynrelocs.
	* elf32-microblaze.c (struct elf32_mb_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(readonly_dynrelocs): New function.
	(microblaze_elf_adjust_dynamic_symbol): Use it.
	* elf32-nds32.c (struct elf_nds32_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(nds32_elf_adjust_dynamic_symbol): Use readonly_dynrelocs, but disable.
	Disable -z no-copyreloc too.
	* elf32-nios2.c (struct elf32_nios2_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	* elf32-or1k.c (struct elf_or1k_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(or1k_elf_adjust_dynamic_symbol): Use readonly_dynrelocs.
	* elf32-sh.c (struct elf_sh_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(sh_elf_adjust_dynamic_symbol): Use readonly_dynrelocs, but disable.
	Disable -z no-copyreloc too.
	* elf32-tilepro.c (struct tilepro_elf_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(tilepro_elf_adjust_dynamic_symbol): Use readonly_dynrelocs.
	* elfnn-riscv.c (struct riscv_elf_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(riscv_elf_adjust_dynamic_symbol): Use readonly_dynrelocs.
	* elfxx-sparc.c (struct _bfd_sparc_elf_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(_bfd_sparc_elf_adjust_dynamic_symbol): Use readonly_dynrelocs.
	* elfxx-tilegx.c (struct tilegx_elf_dyn_relocs): Delete.  Use
	struct elf_dyn_relocs throughout file instead.
	(tilegx_elf_adjust_dynamic_symbol): Use readonly_dynrelocs.
	* elf32-s390.c (elf_s390_adjust_dynamic_symbol): Use readonly_dynrelocs.
	* elf64-s390.c (elf_s390_adjust_dynamic_symbol): Use readonly_dynrelocs.

1 files changed, 29 insertions, 48 deletions

diff --git a/bfd/elf32-hppa.c b/bfd/elf32-hppa.c
index 57d746e..8b52ff0 100644
--- a/bfd/elf32-hppa.c
+++ b/bfd/elf32-hppa.c
@@ -132,8 +132,6 @@
    bfd_hash_table containing stubs	"bstab"
    elf32_hppa_stub_hash_entry		"hsh"
 
-   elf32_hppa_dyn_reloc_entry		"hdh"
-
    Always remember to use GNU Coding Style. */
 
 #define PLT_ENTRY_SIZE 8
@@ -226,22 +224,7 @@ struct elf32_hppa_link_hash_entry
 
   /* Used to count relocations for delayed sizing of relocation
      sections.  */
-  struct elf32_hppa_dyn_reloc_entry
-  {
-    /* Next relocation in the chain.  */
-    struct elf32_hppa_dyn_reloc_entry *hdh_next;
-
-    /* The input section of the reloc.  */
-    asection *sec;
-
-    /* Number of relocs copied in this section.  */
-    bfd_size_type count;
-
-#if RELATIVE_DYNRELOCS
-  /* Number of relative relocs copied for the input section.  */
-    bfd_size_type relative_count;
-#endif
-  } *dyn_relocs;
+  struct elf_dyn_relocs *dyn_relocs;
 
   ENUM_BITFIELD (_tls_type) tls_type : 8;
 
@@ -1026,29 +1009,29 @@ elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info,
     {
       if (hh_dir->dyn_relocs != NULL)
 	{
-	  struct elf32_hppa_dyn_reloc_entry **hdh_pp;
-	  struct elf32_hppa_dyn_reloc_entry *hdh_p;
+	  struct elf_dyn_relocs **hdh_pp;
+	  struct elf_dyn_relocs *hdh_p;
 
 	  /* Add reloc counts against the indirect sym to the direct sym
 	     list.  Merge any entries against the same section.  */
 	  for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
 	    {
-	      struct elf32_hppa_dyn_reloc_entry *hdh_q;
+	      struct elf_dyn_relocs *hdh_q;
 
 	      for (hdh_q = hh_dir->dyn_relocs;
 		   hdh_q != NULL;
-		   hdh_q = hdh_q->hdh_next)
+		   hdh_q = hdh_q->next)
 		if (hdh_q->sec == hdh_p->sec)
 		  {
 #if RELATIVE_DYNRELOCS
-		    hdh_q->relative_count += hdh_p->relative_count;
+		    hdh_q->pc_count += hdh_p->pc_count;
 #endif
 		    hdh_q->count += hdh_p->count;
-		    *hdh_pp = hdh_p->hdh_next;
+		    *hdh_pp = hdh_p->next;
 		    break;
 		  }
 	      if (hdh_q == NULL)
-		hdh_pp = &hdh_p->hdh_next;
+		hdh_pp = &hdh_p->next;
 	    }
 	  *hdh_pp = hh_dir->dyn_relocs;
 	}
@@ -1451,8 +1434,8 @@ elf32_hppa_check_relocs (bfd *abfd,
 		  && (hh->eh.root.type == bfd_link_hash_defweak
 		      || !hh->eh.def_regular)))
 	    {
-	      struct elf32_hppa_dyn_reloc_entry *hdh_p;
-	      struct elf32_hppa_dyn_reloc_entry **hdh_head;
+	      struct elf_dyn_relocs *hdh_p;
+	      struct elf_dyn_relocs **hdh_head;
 
 	      /* Create a reloc section in dynobj and make room for
 		 this reloc.  */
@@ -1493,7 +1476,7 @@ elf32_hppa_check_relocs (bfd *abfd,
 		    sr = sec;
 
 		  vpp = &elf_section_data (sr)->local_dynrel;
-		  hdh_head = (struct elf32_hppa_dyn_reloc_entry **) vpp;
+		  hdh_head = (struct elf_dyn_relocs **) vpp;
 		}
 
 	      hdh_p = *hdh_head;
@@ -1502,19 +1485,19 @@ elf32_hppa_check_relocs (bfd *abfd,
 		  hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
 		  if (hdh_p == NULL)
 		    return FALSE;
-		  hdh_p->hdh_next = *hdh_head;
+		  hdh_p->next = *hdh_head;
 		  *hdh_head = hdh_p;
 		  hdh_p->sec = sec;
 		  hdh_p->count = 0;
 #if RELATIVE_DYNRELOCS
-		  hdh_p->relative_count = 0;
+		  hdh_p->pc_count = 0;
 #endif
 		}
 
 	      hdh_p->count += 1;
 #if RELATIVE_DYNRELOCS
 	      if (!IS_ABSOLUTE_RELOC (rtype))
-		hdh_p->relative_count += 1;
+		hdh_p->pc_count += 1;
 #endif
 	    }
 	}
@@ -1643,10 +1626,10 @@ static asection *
 readonly_dynrelocs (struct elf_link_hash_entry *eh)
 {
   struct elf32_hppa_link_hash_entry *hh;
-  struct elf32_hppa_dyn_reloc_entry *hdh_p;
+  struct elf_dyn_relocs *hdh_p;
 
   hh = hppa_elf_hash_entry (eh);
-  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
+  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
     {
       asection *sec = hdh_p->sec->output_section;
 
@@ -1770,13 +1753,11 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
   if (info->nocopyreloc)
     return TRUE;
 
+  /* If we don't find any dynamic relocs in read-only sections, then
+     we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
   if (ELIMINATE_COPY_RELOCS
       && !alias_readonly_dynrelocs (eh))
-    {
-      /* If we didn't find any dynamic relocs in read-only sections, then
-	 we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
-      return TRUE;
-    }
+    return TRUE;
 
   /* We must allocate the symbol in our .dynbss section, which will
      become part of the .bss section of the executable.  There will be
@@ -1935,7 +1916,7 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
   struct elf32_hppa_link_hash_table *htab;
   asection *sec;
   struct elf32_hppa_link_hash_entry *hh;
-  struct elf32_hppa_dyn_reloc_entry *hdh_p;
+  struct elf_dyn_relocs *hdh_p;
 
   if (eh->root.type == bfd_link_hash_indirect)
     return TRUE;
@@ -2011,16 +1992,16 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
 #if RELATIVE_DYNRELOCS
       if (SYMBOL_CALLS_LOCAL (info, eh))
 	{
-	  struct elf32_hppa_dyn_reloc_entry **hdh_pp;
+	  struct elf_dyn_relocs **hdh_pp;
 
 	  for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
 	    {
-	      hdh_p->count -= hdh_p->relative_count;
-	      hdh_p->relative_count = 0;
+	      hdh_p->count -= hdh_p->pc_count;
+	      hdh_p->pc_count = 0;
 	      if (hdh_p->count == 0)
-		*hdh_pp = hdh_p->hdh_next;
+		*hdh_pp = hdh_p->next;
 	      else
-		hdh_pp = &hdh_p->hdh_next;
+		hdh_pp = &hdh_p->next;
 	    }
 	}
 #endif
@@ -2052,7 +2033,7 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
     }
 
   /* Finally, allocate space.  */
-  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
+  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
     {
       asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
       sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
@@ -2163,12 +2144,12 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 
       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
 	{
-	  struct elf32_hppa_dyn_reloc_entry *hdh_p;
+	  struct elf_dyn_relocs *hdh_p;
 
-	  for (hdh_p = ((struct elf32_hppa_dyn_reloc_entry *)
+	  for (hdh_p = ((struct elf_dyn_relocs *)
 		    elf_section_data (sec)->local_dynrel);
 	       hdh_p != NULL;
-	       hdh_p = hdh_p->hdh_next)
+	       hdh_p = hdh_p->next)
 	    {
 	      if (!bfd_is_abs_section (hdh_p->sec)
 		  && bfd_is_abs_section (hdh_p->sec->output_section))