From: Alan Modra <amodra@gmail.com>
Date: Sat, 3 Jan 2026 03:20:45 +0000 (+1030)
Subject: elf_backend_data typedef
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=39d685b15e4ad7cf11c1d7a5cb032191c909405a;p=thirdparty%2Fbinutils-gdb.git

elf_backend_data typedef

"const struct elf_backend_data" appears many places in the source,
and in some cases makes a line too long without wrapping.  This patch
introduces a "typedef const struct elf_backend_data elf_backend_data;"
and uses it throughout binutils sources, with a few exceptions for c++
use of header files.
---

diff --git a/bfd/bfd.c b/bfd/bfd.c
index 74bf117652e..d1d1df56451 100644
--- a/bfd/bfd.c
+++ b/bfd/bfd.c
@@ -2795,7 +2795,7 @@ is32bit (bfd *abfd)
 {
   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
     {
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       return bed->s->elfclass == ELFCLASS32;
     }
 
@@ -2947,9 +2947,7 @@ bfd_emul_get_commonpagesize (const char *emul)
   if (target != NULL
       && target->flavour == bfd_target_elf_flavour)
     {
-      const struct elf_backend_data *bed;
-
-      bed = xvec_get_elf_backend_data (target);
+      elf_backend_data *bed = xvec_get_elf_backend_data (target);
       return bed->commonpagesize;
     }
   return 0;
@@ -3088,7 +3086,7 @@ bfd_group_signature (asection *group, asymbol **isympp)
   ghdr = &elf_section_data (group)->this_hdr;
   if (ghdr->sh_link == elf_onesymtab (abfd))
     {
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       Elf_Internal_Shdr *symhdr = &elf_symtab_hdr (abfd);
 
       if (ghdr->sh_info > 0
diff --git a/bfd/compress.c b/bfd/compress.c
index 4a73a2d26c4..48bf221baca 100644
--- a/bfd/compress.c
+++ b/bfd/compress.c
@@ -158,7 +158,7 @@ bfd_update_compression_header (bfd *abfd, bfd_byte *contents,
     case bfd_target_elf_flavour:
       if ((abfd->flags & BFD_COMPRESS_GABI) != 0)
 	{
-	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+	  elf_backend_data *bed = get_elf_backend_data (abfd);
 	  struct bfd_elf_section_data * esd = elf_section_data (sec);
 	  enum compression_type ch_type = (abfd->flags & BFD_COMPRESS_ZSTD
 					   ? ch_compress_zstd
@@ -225,7 +225,7 @@ bfd_check_compression_header (bfd *abfd, bfd_byte *contents,
       && (elf_section_flags (sec) & SHF_COMPRESSED) != 0)
     {
       Elf_Internal_Chdr chdr;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       if (bed->s->elfclass == ELFCLASS32)
 	{
 	  Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c
index e4e2b467276..4c88add7bc7 100644
--- a/bfd/dwarf2.c
+++ b/bfd/dwarf2.c
@@ -6287,7 +6287,7 @@ _bfd_elf_find_function (bfd *abfd,
 	 make a better choice of file name for local symbols by ignoring
 	 file symbols appearing after a given local symbol.  */
       enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
 
       file = NULL;
       state = nothing_seen;
diff --git a/bfd/elf-bfd.h b/bfd/elf-bfd.h
index 717b0912bb8..efe40e10605 100644
--- a/bfd/elf-bfd.h
+++ b/bfd/elf-bfd.h
@@ -1809,6 +1809,10 @@ struct elf_backend_data
   unsigned use_mmap : 1;
 };
 
+#ifndef __cplusplus
+typedef const struct elf_backend_data elf_backend_data;
+#endif
+
 /* Information about reloc sections associated with a bfd_elf_section_data
    structure.  */
 struct bfd_elf_section_reloc_data
diff --git a/bfd/elf-eh-frame.c b/bfd/elf-eh-frame.c
index f75daeaec2e..66a79ae9fb4 100644
--- a/bfd/elf-eh-frame.c
+++ b/bfd/elf-eh-frame.c
@@ -1871,7 +1871,7 @@ bool
 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
 				       asection *sec, bfd_byte *contents)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte cantunwind[8];
   bfd_vma addr;
   bfd_vma last_addr;
@@ -2417,7 +2417,7 @@ write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
   struct elf_link_hash_table *htab;
   struct eh_frame_hdr_info *hdr_info;
   asection *sec;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_vma count;
   bfd_byte contents[8];
   unsigned int i;
diff --git a/bfd/elf-ifunc.c b/bfd/elf-ifunc.c
index eae1719a457..adb53cacc4d 100644
--- a/bfd/elf-ifunc.c
+++ b/bfd/elf-ifunc.c
@@ -35,7 +35,7 @@ _bfd_elf_create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags, pltflags;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   if (htab->irelifunc != NULL || htab->iplt != NULL)
@@ -115,7 +115,7 @@ _bfd_elf_allocate_ifunc_dyn_relocs (struct bfd_link_info *info,
   asection *plt, *gotplt, *relplt;
   struct elf_dyn_relocs *p;
   unsigned int sizeof_reloc;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_table *htab;
   /* If AVOID_PLT is TRUE, don't use PLT if possible.  */
   bool use_plt = !avoid_plt || h->plt.refcount > 0;
diff --git a/bfd/elf-m10300.c b/bfd/elf-m10300.c
index 3cdbafc921d..9988b3edcbb 100644
--- a/bfd/elf-m10300.c
+++ b/bfd/elf-m10300.c
@@ -689,7 +689,7 @@ _bfd_mn10300_elf_create_got_section (bfd * abfd,
   flagword   pltflags;
   asection * s;
   struct elf_link_hash_entry * h;
-  const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+  elf_backend_data * bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab;
   int ptralign;
 
@@ -4788,7 +4788,7 @@ _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword   flags;
   asection * s;
-  const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
   int ptralign = 0;
 
diff --git a/bfd/elf-properties.c b/bfd/elf-properties.c
index ac02c43f161..988b7d0dd02 100644
--- a/bfd/elf-properties.c
+++ b/bfd/elf-properties.c
@@ -138,7 +138,7 @@ _bfd_elf_get_property (bfd *abfd, unsigned int type, unsigned int datasz)
 bool
 _bfd_elf_parse_gnu_properties (bfd *abfd, Elf_Internal_Note *note)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   unsigned int align_size = bed->s->elfclass == ELFCLASS64 ? 8 : 4;
   bfd_byte *ptr = (bfd_byte *) note->descdata;
   bfd_byte *ptr_end = ptr + note->descsz;
@@ -302,7 +302,7 @@ static bool
 elf_merge_gnu_properties (struct bfd_link_info *info, bfd *abfd, bfd *bbfd,
 			  elf_property *aprop, elf_property *bprop)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
   unsigned int number;
   bool updated;
@@ -725,8 +725,7 @@ _bfd_elf_link_setup_gnu_properties (struct bfd_link_info *info)
   elf_property_list *list;
   asection *sec;
   bool has_properties = false;
-  const struct elf_backend_data *bed
-    = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
   unsigned int elfclass = bed->s->elfclass;
   int elf_machine_code = bed->elf_machine_code;
   elf_property *p;
@@ -967,7 +966,7 @@ bfd_size_type
 _bfd_elf_convert_gnu_property_size (bfd *ibfd, bfd *obfd)
 {
   unsigned int align_size;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   elf_property_list *list = elf_properties (ibfd);
 
   bed = get_elf_backend_data (obfd);
@@ -987,7 +986,7 @@ _bfd_elf_convert_gnu_properties (bfd *ibfd, asection *isec,
   unsigned int size;
   bfd_byte *contents;
   unsigned int align_shift;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   elf_property_list *list = elf_properties (ibfd);
 
   bed = get_elf_backend_data (obfd);
diff --git a/bfd/elf-s390-common.c b/bfd/elf-s390-common.c
index b26f049670a..6edf208a7ea 100644
--- a/bfd/elf-s390-common.c
+++ b/bfd/elf-s390-common.c
@@ -118,7 +118,7 @@ s390_elf_create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   if (htab->iplt != NULL)
diff --git a/bfd/elf-vxworks.c b/bfd/elf-vxworks.c
index d01237e163c..e77cd9cc305 100644
--- a/bfd/elf-vxworks.c
+++ b/bfd/elf-vxworks.c
@@ -81,7 +81,7 @@ elf_vxworks_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info,
 				     asection **srelplt2_out)
 {
   struct elf_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   asection *s;
 
   htab = elf_hash_table (info);
@@ -153,7 +153,7 @@ elf_vxworks_emit_relocs (bfd *output_bfd,
 			 Elf_Internal_Rela *internal_relocs,
 			 struct elf_link_hash_entry **rel_hash)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   int j;
 
   bed = get_elf_backend_data (output_bfd);
diff --git a/bfd/elf.c b/bfd/elf.c
index f327653e5f6..d2cf2bb4b9c 100644
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -454,7 +454,7 @@ bfd_elf_get_elf_syms (bfd *ibfd,
   Elf_Internal_Sym *alloc_intsym;
   Elf_Internal_Sym *isym;
   Elf_Internal_Sym *isymend;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   size_t extsym_size;
   size_t amt;
   file_ptr pos;
@@ -895,7 +895,7 @@ _bfd_elf_make_section_from_shdr (bfd *abfd,
 {
   asection *newsect;
   flagword flags;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned int opb = bfd_octets_per_byte (abfd, NULL);
 
   if (hdr->bfd_section != NULL)
@@ -1278,7 +1278,7 @@ copy_special_section_fields (const bfd *ibfd,
 			     Elf_Internal_Shdr *oheader,
 			     const unsigned int secnum)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+  elf_backend_data *bed = get_elf_backend_data (obfd);
   const Elf_Internal_Shdr **iheaders
     = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
   bool changed = false;
@@ -1382,7 +1382,7 @@ _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
 {
   const Elf_Internal_Shdr **iheaders;
   Elf_Internal_Shdr **oheaders;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned int i;
 
   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
@@ -1608,7 +1608,7 @@ _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
 	  const char *name = "";
 	  char ab[20];
 	  bool stringp;
-	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+	  elf_backend_data *bed = get_elf_backend_data (abfd);
 
 	  (*swap_dyn_in) (abfd, extdyn, &dyn);
 
@@ -1896,7 +1896,7 @@ _bfd_elf_get_dynamic_symbols (bfd *abfd, Elf_Internal_Phdr *phdr,
   size_t verdef_size = 0;
   size_t verneed_size = 0;
   size_t extsym_size;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   void *dynbuf_addr = NULL;
   void *esymbuf_addr = NULL;
   size_t dynbuf_size = 0;
@@ -2422,7 +2422,7 @@ _bfd_elf_print_symbol (bfd *abfd,
       {
 	const char *section_name;
 	const char *name = NULL;
-	const struct elf_backend_data *bed;
+	elf_backend_data *bed;
 	unsigned char st_other;
 	bfd_vma val;
 	const char *version_string;
@@ -2499,7 +2499,7 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
 {
   Elf_Internal_Shdr *hdr;
   Elf_Internal_Ehdr *ehdr;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   const char *name;
   bool ret = true;
 
@@ -3279,7 +3279,7 @@ _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
 {
   int i;
   const struct bfd_elf_special_section *spec;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   /* See if this is one of the special sections.  */
   if (sec->name == NULL)
@@ -3315,7 +3315,7 @@ bool
 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
 {
   struct bfd_elf_section_data *sdata;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   const struct bfd_elf_special_section *ssect;
 
   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
@@ -3462,7 +3462,7 @@ _bfd_elf_core_find_build_id (bfd *templ, bfd_vma offset)
 bool
 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   switch (hdr->p_type)
     {
@@ -3566,7 +3566,7 @@ _bfd_elf_init_reloc_shdr (bfd *abfd,
 			  bool delay_sh_name_p)
 {
   Elf_Internal_Shdr *rel_hdr;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   BFD_ASSERT (reldata->hdr == NULL);
   rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
@@ -3615,7 +3615,7 @@ static void
 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
 {
   struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct bfd_elf_section_data *esd = elf_section_data (asect);
   Elf_Internal_Shdr *this_hdr;
   unsigned int sh_type;
@@ -4089,7 +4089,7 @@ elf_get_reloc_section (asection *reloc_sec)
   const char *name;
   unsigned int type;
   bfd *abfd;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   type = elf_section_data (reloc_sec)->this_hdr.sh_type;
   if (type != SHT_REL && type != SHT_RELA)
@@ -4444,7 +4444,7 @@ static bool
 sym_is_global (bfd *abfd, asymbol *sym)
 {
   /* If the backend has a special mapping, use it.  */
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   if (bed->elf_backend_sym_is_global)
     return (*bed->elf_backend_sym_is_global) (abfd, sym);
 
@@ -4694,7 +4694,7 @@ bool
 _bfd_elf_compute_section_file_positions (bfd *abfd,
 					 struct bfd_link_info *link_info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct fake_section_arg fsargs;
   bool failed;
   struct elf_strtab_hash *strtab = NULL;
@@ -4816,7 +4816,7 @@ get_program_header_size (bfd *abfd, struct bfd_link_info *info)
 {
   size_t segs;
   asection *s;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   /* Assume we will need exactly two PT_LOAD segments: one for text
      and one for data.  */
@@ -5034,7 +5034,7 @@ elf_modify_segment_map (bfd *abfd,
 			bool remove_empty_load)
 {
   struct elf_segment_map **m;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   /* The placement algorithm assumes that non allocated sections are
      not in PT_LOAD segments.  We ensure this here by removing such
@@ -5091,7 +5091,7 @@ bfd_elf_map_sections_to_segments (bfd *abfd,
   unsigned int count;
   struct elf_segment_map *m;
   asection **sections = NULL;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bool no_user_phdrs;
 
   no_user_phdrs = elf_seg_map (abfd) == NULL;
@@ -5892,7 +5892,7 @@ static bool
 assign_file_positions_for_load_sections (bfd *abfd,
 					 struct bfd_link_info *link_info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_segment_map *m;
   struct elf_segment_map *phdr_load_seg;
   Elf_Internal_Phdr *phdrs;
@@ -6599,7 +6599,7 @@ static bool
 assign_file_positions_for_non_load_sections (bfd *abfd,
 					     struct bfd_link_info *link_info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   Elf_Internal_Shdr **i_shdrpp;
   Elf_Internal_Shdr **hdrpp, **end_hdrpp;
   Elf_Internal_Phdr *phdrs;
@@ -6864,7 +6864,7 @@ assign_file_positions_except_relocs (bfd *abfd,
 {
   struct elf_obj_tdata *tdata = elf_tdata (abfd);
   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   unsigned int alloc;
 
   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
@@ -7009,7 +7009,7 @@ _bfd_elf_init_file_header (bfd *abfd,
 {
   Elf_Internal_Ehdr *i_ehdrp;	/* Elf file header, internal form.  */
   struct elf_strtab_hash *shstrtab;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   i_ehdrp = elf_elfheader (abfd);
 
@@ -7124,7 +7124,7 @@ _bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
   Elf_Internal_Shdr **shdrpp, **end_shdrpp;
   Elf_Internal_Shdr *shdrp;
   Elf_Internal_Ehdr *i_ehdrp;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   /* Skip non-load sections without section header.  */
   if ((abfd->flags & BFD_NO_SECTION_HEADER) != 0)
@@ -7219,7 +7219,7 @@ _bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
 bool
 _bfd_elf_write_object_contents (bfd *abfd)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   Elf_Internal_Shdr **i_shdrp;
   bool failed;
   unsigned int count, num_sec;
@@ -7310,7 +7310,7 @@ _bfd_elf_write_corefile_contents (bfd *abfd)
 unsigned int
 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned int sec_index;
 
   if (elf_section_data (asect) != NULL
@@ -7474,7 +7474,7 @@ rewrite_elf_program_header (bfd *ibfd, bfd *obfd, bfd_vma maxpagesize)
   bool p_paddr_valid;
   struct elf_segment_map *phdr_adjust_seg = NULL;
   unsigned int phdr_adjust_num = 0;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned int opb = bfd_octets_per_byte (ibfd, NULL);
 
   bed = get_elf_backend_data (ibfd);
@@ -8101,7 +8101,7 @@ elf_is_p_align_valid (bfd *abfd)
   unsigned int i;
   Elf_Internal_Phdr *segment;
   unsigned int num_segments;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bfd_size_type maxpagesize = bed->maxpagesize;
   bfd_size_type p_align = bed->p_align;
 
@@ -8326,7 +8326,7 @@ copy_private_bfd_data (bfd *ibfd, bfd *obfd)
       asection * prev;
       unsigned int i, num_segments;
       Elf_Internal_Shdr *this_hdr;
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
 
       bed = get_elf_backend_data (ibfd);
 
@@ -8724,7 +8724,7 @@ swap_out_syms (bfd *abfd,
 	       int relocatable_p,
 	       struct bfd_link_info *info)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned int symcount;
   asymbol **syms;
   struct elf_strtab_hash *stt;
@@ -9204,7 +9204,7 @@ _bfd_elf_canonicalize_reloc (bfd *abfd,
 {
   arelent *tblptr;
   unsigned int i;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
     return -1;
@@ -9221,7 +9221,7 @@ _bfd_elf_canonicalize_reloc (bfd *abfd,
 long
 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   long symcount = bed->s->slurp_symbol_table (abfd, allocation, false);
 
   if (symcount >= 0)
@@ -9233,7 +9233,7 @@ long
 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
 				      asymbol **allocation)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   long symcount = bed->s->slurp_symbol_table (abfd, allocation, true);
 
   if (symcount >= 0)
@@ -10004,7 +10004,7 @@ _bfd_elf_find_inliner_info (bfd *abfd,
 int
 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int ret = bed->s->sizeof_ehdr;
 
   if (!bfd_link_relocatable (info))
@@ -11157,7 +11157,7 @@ elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
 static bool
 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   /* Short cut for LINUX notes.  */
   if (note->namesz == 6 /* strlen (NOTE_NAME_LINUX) + 1 */
@@ -11484,7 +11484,7 @@ elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
 static bool
 elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   switch (note->type)
     {
@@ -12139,7 +12139,7 @@ elfcore_write_prpsinfo (bfd  *abfd,
 			const char *fname,
 			const char *psargs)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   if (bed->elf_backend_write_core_note != NULL)
     {
@@ -12248,7 +12248,7 @@ elfcore_write_prstatus (bfd *abfd,
 			int cursig,
 			const void *gregs)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   if (bed->elf_backend_write_core_note != NULL)
     {
@@ -12331,7 +12331,7 @@ elfcore_write_pstatus (bfd *abfd,
 		       const void *gregs ATTRIBUTE_UNUSED)
 {
 #if defined (HAVE_PSTATUS32_T)
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   if (bed->s->elfclass == ELFCLASS32)
     {
@@ -13351,7 +13351,7 @@ _bfd_elf_section_offset (bfd *abfd,
       if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
 	{
 	  /* Reverse the offset.  */
-	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+	  elf_backend_data *bed = get_elf_backend_data (abfd);
 	  bfd_size_type address_size = bed->s->arch_size / 8;
 
 	  /* address_size and sec->size are in octets.  Convert
@@ -13371,7 +13371,7 @@ _bfd_elf_get_synthetic_symtab (bfd *abfd,
 			       asymbol **dynsyms,
 			       asymbol **ret)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   asection *relplt;
   asymbol *s;
   const char *relplt_name;
@@ -13484,7 +13484,7 @@ bool
 _bfd_elf_final_write_processing (bfd *abfd)
 {
   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE)
     i_ehdrp->e_ident[EI_OSABI] = bed->elf_osabi;
@@ -13606,7 +13606,7 @@ _bfd_elf_slurp_secondary_reloc_section (bfd *       abfd,
 					asymbol **  symbols,
 					bool dynamic)
 {
-  const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+  elf_backend_data *ebd = get_elf_backend_data (abfd);
   asection * relsec;
   bool result = true;
   bfd_vma (*r_sym) (bfd_vma);
@@ -13866,7 +13866,7 @@ _bfd_elf_copy_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
 bool
 _bfd_elf_write_secondary_reloc_section (bfd *abfd, asection *sec)
 {
-  const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+  elf_backend_data *ebd = get_elf_backend_data (abfd);
   bfd_vma addr_offset;
   asection * relsec;
   bfd_vma (*r_info) (bfd_vma, bfd_vma);
@@ -14078,7 +14078,7 @@ static bool
 elf_mmap_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **buf)
 {
 #ifdef USE_MMAP
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   if (bed->use_mmap
       && sec->compress_status == COMPRESS_SECTION_NONE
       && (sec->flags & SEC_LINKER_CREATED) == 0)
diff --git a/bfd/elf32-arm.c b/bfd/elf32-arm.c
index ea599413d22..9465efc5953 100644
--- a/bfd/elf32-arm.c
+++ b/bfd/elf32-arm.c
@@ -3787,16 +3787,11 @@ create_got_section (bfd *dynobj, struct bfd_link_info *info)
 static bool
 create_ifunc_sections (struct bfd_link_info *info)
 {
-  struct elf32_arm_link_hash_table *htab;
-  const struct elf_backend_data *bed;
-  bfd *dynobj;
+  struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
+  bfd *dynobj = htab->root.dynobj;
+  elf_backend_data *bed = get_elf_backend_data (dynobj);
   asection *s;
-  flagword flags;
-
-  htab = elf32_arm_hash_table (info);
-  dynobj = htab->root.dynobj;
-  bed = get_elf_backend_data (dynobj);
-  flags = bed->dynamic_sec_flags;
+  flagword flags = bed->dynamic_sec_flags;
 
   if (htab->root.iplt == NULL)
     {
@@ -5915,7 +5910,7 @@ cmse_scan (bfd *input_bfd, struct elf32_arm_link_hash_table *htab,
 	   obj_attribute *out_attr, struct elf_link_hash_entry **sym_hashes,
 	   int *cmse_stub_created)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed = get_elf_backend_data (input_bfd);
   Elf_Internal_Shdr *symtab_hdr;
   unsigned i, j, sym_count, ext_start;
   Elf_Internal_Sym *cmse_sym, *local_syms;
@@ -5927,7 +5922,6 @@ cmse_scan (bfd *input_bfd, struct elf32_arm_link_hash_table *htab,
   struct elf32_arm_stub_hash_entry *stub_entry;
   bool is_v8m, new_stub, cmse_invalid, ret = true;
 
-  bed = get_elf_backend_data (input_bfd);
   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   sym_count = symtab_hdr->sh_size / bed->s->sizeof_sym;
   ext_start = symtab_hdr->sh_info;
@@ -15707,7 +15701,7 @@ elf32_arm_update_relocs (asection *o,
 {
   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   _arm_elf_section_data *eado;
   struct bfd_link_order *p;
   bfd_byte *erela_head, *erela;
@@ -15879,7 +15873,7 @@ elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
   obj_attribute *out_attr;
   Elf_Internal_Shdr *symtab_hdr;
   unsigned i, sym_count, ext_start;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_entry **sym_hashes;
   struct elf32_arm_link_hash_entry *cmse_hash;
   bool again, is_v8m, first_bfd_browse = true;
@@ -17090,8 +17084,7 @@ elf32_arm_early_size_sections (bfd *output_bfd, struct bfd_link_info *info)
       if (tlsbase)
 	{
 	  struct bfd_link_hash_entry *bh = NULL;
-	  const struct elf_backend_data *bed
-	    = get_elf_backend_data (output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
 	  if (!(_bfd_generic_link_add_one_symbol
 		(info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
@@ -17604,7 +17597,7 @@ elf32_arm_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
       /* Check relocation against STT_GNU_IFUNC symbol if there are
 	 dynamic symbols.  */
       bfd *abfd = info->output_bfd;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
       if (r_symndx != STN_UNDEF)
 	{
diff --git a/bfd/elf32-bfin.c b/bfd/elf32-bfin.c
index e337f1d02d8..2662449c7eb 100644
--- a/bfd/elf32-bfin.c
+++ b/bfd/elf32-bfin.c
@@ -3188,7 +3188,7 @@ _bfin_create_got_section (bfd *abfd, struct bfd_link_info *info)
   flagword flags, pltflags;
   asection *s;
   struct elf_link_hash_entry *h;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int ptralign;
 
   /* This function may be called more than once.  */
@@ -3315,7 +3315,7 @@ elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
      elflink.c:_bfd_elf_create_dynamic_sections().  */
   flagword flags;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 	   | SEC_LINKER_CREATED);
diff --git a/bfd/elf32-cr16.c b/bfd/elf32-cr16.c
index 046c6dc43a3..dda2e6874f9 100644
--- a/bfd/elf32-cr16.c
+++ b/bfd/elf32-cr16.c
@@ -582,7 +582,7 @@ _bfd_cr16_elf_create_got_section (bfd * abfd, struct bfd_link_info * info)
   flagword   flags;
   asection * s;
   struct elf_link_hash_entry * h;
-  const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+  elf_backend_data * bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
   int ptralign;
 
@@ -2179,7 +2179,7 @@ _bfd_cr16_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword   flags;
   asection * s;
-  const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+  elf_backend_data * bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
   int ptralign = 0;
 
diff --git a/bfd/elf32-frv.c b/bfd/elf32-frv.c
index f0af7e15f49..6a0e2fd844d 100644
--- a/bfd/elf32-frv.c
+++ b/bfd/elf32-frv.c
@@ -4171,7 +4171,7 @@ _frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
   asection *s;
   struct elf_link_hash_entry *h;
   struct bfd_link_hash_entry *bh;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int ptralign;
   int offset;
 
@@ -4324,7 +4324,7 @@ elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
      elflink.c:_bfd_elf_create_dynamic_sections().  */
   flagword flags;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 	   | SEC_LINKER_CREATED);
diff --git a/bfd/elf32-i386.c b/bfd/elf32-i386.c
index d1843f501d5..a367fd9f6f0 100644
--- a/bfd/elf32-i386.c
+++ b/bfd/elf32-i386.c
@@ -2091,7 +2091,7 @@ static bfd_vma
 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
 {
   struct elf_link_hash_table *htab = elf_hash_table (info);
-  const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
   bfd_vma static_tls_size;
 
   /* If tls_sec is NULL, we should have signalled an error already.  */
@@ -4095,7 +4095,7 @@ elf_i386_reloc_type_class (const struct bfd_link_info *info,
 			   const Elf_Internal_Rela *rela)
 {
   bfd *abfd = info->output_bfd;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   if (htab->dynsym != NULL
diff --git a/bfd/elf32-lm32.c b/bfd/elf32-lm32.c
index 79f2d30dbd2..adf5a6ff226 100644
--- a/bfd/elf32-lm32.c
+++ b/bfd/elf32-lm32.c
@@ -2201,7 +2201,7 @@ lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   struct elf_lm32_link_hash_table *htab;
   flagword flags, pltflags;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int ptralign = 2; /* 32bit */
 
   htab = lm32_elf_hash_table (info);
diff --git a/bfd/elf32-m32r.c b/bfd/elf32-m32r.c
index 84f64beab5e..af8268b86ba 100644
--- a/bfd/elf32-m32r.c
+++ b/bfd/elf32-m32r.c
@@ -1534,7 +1534,7 @@ m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   struct elf_link_hash_table *htab;
   flagword flags, pltflags;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int ptralign = 2; /* 32bit */
 
   htab = m32r_elf_hash_table (info);
diff --git a/bfd/elf32-m68hc1x.c b/bfd/elf32-m68hc1x.c
index 2b99bbf4ab9..e90b307c8e4 100644
--- a/bfd/elf32-m68hc1x.c
+++ b/bfd/elf32-m68hc1x.c
@@ -935,7 +935,7 @@ elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
   Elf_Internal_Rela *rel, *relend;
   const char *name = NULL;
   struct m68hc11_page_info *pinfo;
-  const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
+  elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
   struct m68hc11_elf_link_hash_table *htab;
   unsigned long e_flags;
 
diff --git a/bfd/elf32-metag.c b/bfd/elf32-metag.c
index f71d2ba54a2..d3d9a8e950a 100644
--- a/bfd/elf32-metag.c
+++ b/bfd/elf32-metag.c
@@ -1977,7 +1977,7 @@ elf_metag_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   struct elf_metag_link_hash_table *htab;
   struct elf_link_hash_entry *eh;
   struct bfd_link_hash_entry *bh;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   /* Don't try to create the .plt and .got twice.  */
   htab = metag_link_hash_table (info);
diff --git a/bfd/elf32-nds32.c b/bfd/elf32-nds32.c
index 97f3fcb760b..f308f2f16e1 100644
--- a/bfd/elf32-nds32.c
+++ b/bfd/elf32-nds32.c
@@ -3794,7 +3794,7 @@ nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   struct elf_nds32_link_hash_table *htab;
   flagword flags, pltflags;
   register asection *s;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   int ptralign = 2;		/* 32-bit  */
   const char *secname;
   char *relname;
diff --git a/bfd/elf32-rx.c b/bfd/elf32-rx.c
index f1567eb748f..5aadc167709 100644
--- a/bfd/elf32-rx.c
+++ b/bfd/elf32-rx.c
@@ -3693,7 +3693,7 @@ rx_final_link (bfd * abfd, struct bfd_link_info * info)
 static bool
 elf32_rx_modify_headers (bfd *abfd, struct bfd_link_info *info)
 {
-  const struct elf_backend_data * bed;
+  elf_backend_data *bed;
   struct elf_obj_tdata * tdata;
   Elf_Internal_Phdr * phdr;
   unsigned int count;
diff --git a/bfd/elf32-s390.c b/bfd/elf32-s390.c
index c879a42cf62..a47eb99b040 100644
--- a/bfd/elf32-s390.c
+++ b/bfd/elf32-s390.c
@@ -3577,7 +3577,7 @@ elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
 			   const Elf_Internal_Rela *rela)
 {
   bfd *abfd = info->output_bfd;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
   unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
   Elf_Internal_Sym sym;
diff --git a/bfd/elf32-score.c b/bfd/elf32-score.c
index 1953873339d..49ff8105bfb 100644
--- a/bfd/elf32-score.c
+++ b/bfd/elf32-score.c
@@ -2407,7 +2407,7 @@ s3_bfd_score_elf_relocate_section (bfd *output_bfd,
       if (bfd_link_pic (info))
 	{
 	  asection * p;
-	  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
 	  for (p = output_bfd->sections; p ; p = p->next)
 	    if ((p->flags & SEC_EXCLUDE) == 0
diff --git a/bfd/elf32-score7.c b/bfd/elf32-score7.c
index 600be88be61..7219b364269 100644
--- a/bfd/elf32-score7.c
+++ b/bfd/elf32-score7.c
@@ -2249,7 +2249,7 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd,
       if (bfd_link_pic (info))
 	{
 	  asection * p;
-	  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
 	  for (p = output_bfd->sections; p ; p = p->next)
 	    if ((p->flags & SEC_EXCLUDE) == 0
diff --git a/bfd/elf32-sh.c b/bfd/elf32-sh.c
index 246e725af85..28589600a0e 100644
--- a/bfd/elf32-sh.c
+++ b/bfd/elf32-sh.c
@@ -2343,7 +2343,7 @@ sh_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   struct elf_sh_link_hash_table *htab;
   flagword flags, pltflags;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int ptralign = 0;
 
   switch (bed->s->arch_size)
diff --git a/bfd/elf32-sparc.c b/bfd/elf32-sparc.c
index 37dc926d0de..421549a7a33 100644
--- a/bfd/elf32-sparc.c
+++ b/bfd/elf32-sparc.c
@@ -175,7 +175,7 @@ elf32_sparc_reloc_type_class (const struct bfd_link_info *info,
 			      const Elf_Internal_Rela *rela)
 {
   bfd *abfd = info->output_bfd;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct _bfd_sparc_elf_link_hash_table *htab
     = _bfd_sparc_elf_hash_table (info);
   BFD_ASSERT (htab != NULL);
diff --git a/bfd/elf32-spu.c b/bfd/elf32-spu.c
index ec9ac49f379..4a2af62e082 100644
--- a/bfd/elf32-spu.c
+++ b/bfd/elf32-spu.c
@@ -5353,7 +5353,7 @@ spu_elf_modify_headers (bfd *abfd, struct bfd_link_info *info)
 {
   if (info != NULL)
     {
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
       struct elf_obj_tdata *tdata;
       Elf_Internal_Phdr *phdr, *last;
       struct spu_link_hash_table *htab;
diff --git a/bfd/elf32-tic6x.c b/bfd/elf32-tic6x.c
index f2acb95ea60..c776f31092e 100644
--- a/bfd/elf32-tic6x.c
+++ b/bfd/elf32-tic6x.c
@@ -1721,7 +1721,7 @@ elf32_tic6x_finish_dynamic_symbol (bfd * output_bfd,
       Elf_Internal_Rela rela;
       bfd_byte *loc;
       asection *plt, *gotplt, *relplt;
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
 
       bed = get_elf_backend_data (output_bfd);
 
@@ -2101,7 +2101,7 @@ elf32_tic6x_rel_relocation_p (bfd *abfd, asection *sec,
 			      const Elf_Internal_Rela *rel)
 {
   Elf_Internal_Shdr *rel_hdr;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   /* To determine which flavor of relocation this is, we depend on the
      fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR.  */
diff --git a/bfd/elf32-tilepro.c b/bfd/elf32-tilepro.c
index 1b03845684e..3b2e01757d5 100644
--- a/bfd/elf32-tilepro.c
+++ b/bfd/elf32-tilepro.c
@@ -1200,7 +1200,7 @@ tilepro_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
   flagword flags;
   asection *s, *s_got;
   struct elf_link_hash_entry *h;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   /* This function may be called more than once.  */
diff --git a/bfd/elf32-xtensa.c b/bfd/elf32-xtensa.c
index 4b6b2d1e0f8..1faa884f1d8 100644
--- a/bfd/elf32-xtensa.c
+++ b/bfd/elf32-xtensa.c
@@ -1794,7 +1794,7 @@ elf_xtensa_early_size_sections (bfd *output_bfd, struct bfd_link_info *info)
     {
       struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
       struct bfd_link_hash_entry *bh = &tlsbase->root;
-      const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+      elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
       tlsbase->type = STT_TLS;
       if (!(_bfd_generic_link_add_one_symbol
diff --git a/bfd/elf64-ia64-vms.c b/bfd/elf64-ia64-vms.c
index 983750595cf..bdd1b5b9753 100644
--- a/bfd/elf64-ia64-vms.c
+++ b/bfd/elf64-ia64-vms.c
@@ -1263,7 +1263,7 @@ elf64_ia64_create_dynamic_sections (bfd *abfd,
   struct elf64_ia64_link_hash_table *ia64_info;
   asection *s;
   flagword flags;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   ia64_info = elf64_ia64_hash_table (info);
   if (ia64_info == NULL)
@@ -2772,7 +2772,7 @@ elf64_ia64_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
       asection *dynsec;
       asection *dynstrsec;
       Elf_Internal_Dyn dyn;
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
       unsigned int shl_num = 0;
       bfd_vma fixups_off = 0;
       bfd_vma strdyn_off;
@@ -4747,7 +4747,7 @@ elf64_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   Elf_Internal_Sym *isymbuf = NULL;
   Elf_Internal_Sym *isym;
   Elf_Internal_Sym *isymend;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_table *htab;
   bfd_size_type amt;
 
diff --git a/bfd/elf64-s390.c b/bfd/elf64-s390.c
index c20f784d802..2ff38adfd60 100644
--- a/bfd/elf64-s390.c
+++ b/bfd/elf64-s390.c
@@ -3808,7 +3808,7 @@ elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
 			   const Elf_Internal_Rela *rela)
 {
   bfd *abfd = info->output_bfd;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
   unsigned long r_symndx = ELF64_R_SYM (rela->r_info);
   Elf_Internal_Sym sym;
diff --git a/bfd/elf64-sparc.c b/bfd/elf64-sparc.c
index d249cbce6de..06c4e492ff8 100644
--- a/bfd/elf64-sparc.c
+++ b/bfd/elf64-sparc.c
@@ -251,7 +251,7 @@ elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
 {
   arelent *tblptr;
   unsigned int i;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
     return -1;
@@ -803,7 +803,7 @@ elf64_sparc_reloc_type_class (const struct bfd_link_info *info,
 			      const Elf_Internal_Rela *rela)
 {
   bfd *abfd = info->output_bfd;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct _bfd_sparc_elf_link_hash_table *htab
     = _bfd_sparc_elf_hash_table (info);
   BFD_ASSERT (htab != NULL);
diff --git a/bfd/elf64-x86-64.c b/bfd/elf64-x86-64.c
index 4be86c3aa24..72a828a8c13 100644
--- a/bfd/elf64-x86-64.c
+++ b/bfd/elf64-x86-64.c
@@ -479,7 +479,7 @@ static char *
 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
 			    int note_type, ...)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   va_list ap;
   const char *fname, *psargs;
   long pid;
@@ -3148,7 +3148,7 @@ static bfd_vma
 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
 {
   struct elf_link_hash_table *htab = elf_hash_table (info);
-  const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
   bfd_vma static_tls_size;
 
   /* If tls_segment is NULL, we should have signalled an error already.  */
@@ -5171,7 +5171,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
       Elf_Internal_Rela rela;
       bfd_byte *loc;
       asection *plt, *gotplt, *relplt, *resolved_plt;
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
       bfd_vma plt_got_pcrel_offset;
 
       /* When building a static executable, use .iplt, .igot.plt and
@@ -5607,7 +5607,7 @@ elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
 			     const Elf_Internal_Rela *rela)
 {
   bfd *abfd = info->output_bfd;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_x86_link_hash_table *htab
     = elf_x86_hash_table (info, X86_64_ELF_DATA);
 
@@ -6217,7 +6217,7 @@ static bfd *
 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info)
 {
   struct elf_x86_init_table init_table;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_x86_link_hash_table *htab;
 
   if ((int) R_X86_64_standard >= (int) R_X86_64_converted_reloc_bit
diff --git a/bfd/elfcode.h b/bfd/elfcode.h
index 18c007ae36a..3fde79c9c53 100644
--- a/bfd/elfcode.h
+++ b/bfd/elfcode.h
@@ -410,11 +410,8 @@ elf_swap_phdr_out (bfd *abfd,
 		   const Elf_Internal_Phdr *src,
 		   Elf_External_Phdr *dst)
 {
-  const struct elf_backend_data *bed;
-  bfd_vma p_paddr;
-
-  bed = get_elf_backend_data (abfd);
-  p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
+  elf_backend_data *bed = get_elf_backend_data (abfd);
+  bfd_vma p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
 
   /* note that all elements of dst are *arrays of unsigned char* already...  */
   H_PUT_32 (abfd, src->p_type, dst->p_type);
@@ -527,7 +524,7 @@ elf_object_p (bfd *abfd)
   Elf_Internal_Shdr i_shdr;
   Elf_Internal_Shdr *i_shdrp;	/* Section header table, internal form */
   unsigned int shindex;
-  const struct elf_backend_data *ebd;
+  elf_backend_data *ebd;
   asection *s;
   const bfd_target *target;
 
@@ -934,7 +931,7 @@ elf_object_p (bfd *abfd)
 void
 elf_write_relocs (bfd *abfd, asection *sec, void *data)
 {
-  const struct elf_backend_data * const bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bool *failedp = (bool *) data;
   Elf_Internal_Shdr *rela_hdr;
   bfd_vma addr_offset;
@@ -1252,7 +1249,7 @@ elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bool dynamic)
   Elf_Internal_Sym *isymbuf = NULL;
   Elf_External_Versym *xver;
   Elf_External_Versym *xverbuf = NULL;
-  const struct elf_backend_data *ebd;
+  elf_backend_data *ebd;
   size_t amt;
 
   /* Read each raw ELF symbol, converting from external ELF form to
@@ -1548,7 +1545,7 @@ elf_slurp_reloc_table_from_section (bfd *abfd,
 				    asymbol **symbols,
 				    bool dynamic)
 {
-  const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+  elf_backend_data *ebd = get_elf_backend_data (abfd);
   void *allocated = NULL;
   bfd_byte *native_relocs;
   arelent *relent;
@@ -1646,7 +1643,7 @@ elf_slurp_reloc_table (bfd *abfd,
 		       asymbol **symbols,
 		       bool dynamic)
 {
-  const struct elf_backend_data * const bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct bfd_elf_section_data * const d = elf_section_data (asect);
   Elf_Internal_Shdr *rel_hdr;
   Elf_Internal_Shdr *rel_hdr2;
diff --git a/bfd/elfcore.h b/bfd/elfcore.h
index 5978ba768ba..c570479c2ac 100644
--- a/bfd/elfcore.h
+++ b/bfd/elfcore.h
@@ -90,7 +90,6 @@ elf_core_file_p (bfd *abfd)
   Elf_Internal_Ehdr *i_ehdrp;	/* Elf file header, internal form.  */
   Elf_Internal_Phdr *i_phdrp;	/* Elf program header, internal form.  */
   unsigned int phindex;
-  const struct elf_backend_data *ebd;
   bfd_size_type amt;
   ufile_ptr filesize;
 
@@ -140,7 +139,7 @@ elf_core_file_p (bfd *abfd)
   elf_debug_file (i_ehdrp);
 #endif
 
-  ebd = get_elf_backend_data (abfd);
+  elf_backend_data *ebd = get_elf_backend_data (abfd);
 
   /* Check that the ELF e_machine field matches what this particular
      BFD format expects.  */
diff --git a/bfd/elflink.c b/bfd/elflink.c
index 3807da017fa..64c1a57b465 100644
--- a/bfd/elflink.c
+++ b/bfd/elflink.c
@@ -59,8 +59,7 @@ _bfd_elf_link_keep_memory (struct bfd_link_info *info)
      https://sourceware.org/bugzilla/show_bug.cgi?id=31458
 
      this is opt-in by each backend.  */
-  const struct elf_backend_data *bed
-    = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
   if (bed != NULL && bed->use_mmap)
     return false;
 #endif
@@ -192,7 +191,7 @@ _bfd_elf_define_linkage_sym (bfd *abfd,
 {
   struct elf_link_hash_entry *h;
   struct bfd_link_hash_entry *bh;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   h = elf_link_hash_lookup (elf_hash_table (info), name, false, false, false);
   if (h != NULL)
@@ -231,7 +230,7 @@ _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
   flagword flags;
   asection *s;
   struct elf_link_hash_entry *h;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   /* This function may be called more than once.  */
@@ -336,7 +335,7 @@ bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags;
   asection *s;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_entry *h;
 
   if (! is_elf_hash_table (info->hash))
@@ -469,7 +468,7 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   flagword flags, pltflags;
   struct elf_link_hash_entry *h;
   asection *s;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
@@ -710,7 +709,7 @@ bfd_elf_record_link_assignment (bfd *output_bfd,
 {
   struct elf_link_hash_entry *h, *hv;
   struct elf_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   if (!is_elf_hash_table (info->hash))
     return true;
@@ -1046,7 +1045,7 @@ _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
   if (bfd_link_pic (info)
       || elf_hash_table (info)->is_relocatable_executable)
     {
-      const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+      elf_backend_data *bed = get_elf_backend_data (output_bfd);
       asection *p;
       for (p = output_bfd->sections; p ; p = p->next)
 	if ((p->flags & SEC_EXCLUDE) == 0
@@ -1098,7 +1097,7 @@ elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
 		    unsigned int st_other, asection *sec,
 		    bool definition, bool dynamic)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   /* If st_other has a processor-specific meaning, specific
      code might be needed here.  */
@@ -1160,7 +1159,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
   bfd *oldbfd;
   bool newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
   bool newweak, oldweak, newfunc, oldfunc;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   const char *new_version;
   bool default_sym = *matched;
   struct elf_link_hash_table *htab;
@@ -1961,7 +1960,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
   char *shortname;
   struct elf_link_hash_entry *hi;
   struct bfd_link_hash_entry *bh;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bool collect;
   bool dynamic;
   bfd *override;
@@ -2602,8 +2601,7 @@ _bfd_elf_link_hide_sym_by_version (struct bfd_link_info *info,
 {
   const char *p;
   bool hide = false;
-  const struct elf_backend_data *bed
-    = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
 
   /* Version script only hides symbols defined in regular objects.  */
   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
@@ -2655,7 +2653,7 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_info_failed *sinfo;
   struct bfd_link_info *info;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_info_failed eif;
   const char *p;
   bool hide;
@@ -2799,7 +2797,7 @@ elf_link_read_relocs_from_section (bfd *abfd,
 				   size_t *external_relocs_size,
 				   Elf_Internal_Rela *internal_relocs)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
   const bfd_byte *erela;
   const bfd_byte *erelaend;
@@ -2903,7 +2901,7 @@ _bfd_elf_link_info_read_relocs (bfd *abfd,
   void *alloc1 = NULL;
   size_t alloc1_size;
   Elf_Internal_Rela *alloc2 = NULL;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct bfd_elf_section_data *esdo = elf_section_data (o);
   Elf_Internal_Rela *internal_rela_relocs;
 
@@ -3029,7 +3027,7 @@ _bfd_elf_link_output_relocs (bfd *output_bfd,
   bfd_byte *erel;
   struct bfd_elf_section_reloc_data *output_reldata;
   asection *output_section;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
   struct bfd_elf_section_data *esdo;
 
@@ -3105,7 +3103,7 @@ static bool
 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
 			   struct elf_info_failed *eif)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   /* If this symbol was mentioned in a non-ELF file, try to set
      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
@@ -3271,7 +3269,7 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_info_failed *eif = (struct elf_info_failed *) data;
   struct elf_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   if (! is_elf_hash_table (eif->info->hash))
     return false;
@@ -3485,7 +3483,7 @@ _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
 			   bool not_local_protected)
 {
   bool binding_stays_local_p;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_table *hash_table;
 
   if (h == NULL)
@@ -3557,7 +3555,7 @@ _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
 			      struct bfd_link_info *info,
 			      bool local_protected)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_table *hash_table;
 
   /* If it's a local sym, of course we resolve locally.  */
@@ -3656,7 +3654,7 @@ static bool
 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
 				  Elf_Internal_Sym *sym)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   /* Local symbols do not count, but target specific ones might.  */
   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
@@ -3796,7 +3794,7 @@ _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
 			    bfd_vma val)
 {
   struct elf_link_hash_table *hash_table;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   asection *s;
   bfd_size_type newsize;
   bfd_byte *newcontents;
@@ -3834,7 +3832,7 @@ bool
 _bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info)
 {
   struct elf_link_hash_table *hash_table;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   asection *s, *sdynamic, **pp;
   asection *rela_dyn, *rel_dyn;
   Elf_Internal_Dyn dyn;
@@ -3948,7 +3946,7 @@ bfd_elf_add_dt_needed_tag (bfd *abfd, struct bfd_link_info *info)
   if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
     {
       asection *sdyn;
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
       bfd_byte *extdyn;
 
       bed = get_elf_backend_data (hash_table->dynobj);
@@ -4085,7 +4083,7 @@ elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
   bfd *dynobj = hash_table->dynobj;
   asection *sdyn;
   bfd_size_type size;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *extdyn;
 
   _bfd_elf_strtab_finalize (dynstr);
@@ -4225,7 +4223,7 @@ bool
 _bfd_elf_relocs_compatible (const bfd_target *input,
 			    const bfd_target *output)
 {
-  const struct elf_backend_data *obed, *ibed;
+  elf_backend_data *obed, *ibed;
 
   if (input == output)
     return true;
@@ -4260,7 +4258,7 @@ _bfd_elf_link_iterate_on_relocs
    bool (*action) (bfd *, struct bfd_link_info *, asection *,
 		   const Elf_Internal_Rela *))
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   /* If this object is the same format as the output object, and it is
@@ -4334,7 +4332,7 @@ _bfd_elf_link_iterate_on_relocs
 bool
 _bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   if (bed->check_relocs != NULL)
     return _bfd_elf_link_iterate_on_relocs (abfd, info,
 					    bed->check_relocs);
@@ -4424,7 +4422,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   Elf_Internal_Sym *isymbuf = NULL;
   Elf_Internal_Sym *isym;
   Elf_Internal_Sym *isymend;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bool add_needed;
   struct elf_link_hash_table *htab;
   void *alloc_mark = NULL;
@@ -6255,7 +6253,7 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
   carsym *symdefs;
   bool loop;
   size_t amt;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct bfd_link_hash_entry * (*archive_symbol_lookup)
     (bfd *, struct bfd_link_info *, const char *);
 
@@ -6516,7 +6514,7 @@ elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
 struct collect_gnu_hash_codes
 {
   bfd *output_bfd;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned long int nsyms;
   unsigned long int maskbits;
   unsigned long int *hashcodes;
@@ -6697,7 +6695,7 @@ compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
       uint64_t best_chlen = ~((uint64_t) 0);
       bfd *dynobj = elf_hash_table (info)->dynobj;
       size_t dynsymcount = elf_hash_table (info)->dynsymcount;
-      const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
+      elf_backend_data *bed = get_elf_backend_data (dynobj);
       unsigned long int *counts;
       bfd_size_type amt;
       unsigned int no_improvement_count = 0;
@@ -6937,7 +6935,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 			       asection **sinterpptr)
 {
   bfd *dynobj;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   *sinterpptr = NULL;
 
@@ -7879,7 +7877,7 @@ _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
 bool
 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned long section_sym_count;
   bfd_size_type dynsymcount = 0;
 
@@ -8368,7 +8366,7 @@ _bfd_elf_link_hide_symbol (bfd *output_bfd,
 {
   if (is_elf_hash_table (info->hash))
     {
-      const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+      elf_backend_data *bed = get_elf_backend_data (output_bfd);
       struct elf_link_hash_entry *eh = (struct elf_link_hash_entry *) h;
       eh->def_dynamic = 0;
       eh->ref_dynamic = 0;
@@ -8390,7 +8388,7 @@ _bfd_elf_link_hash_table_init
    unsigned int entsize)
 {
   bool ret;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int can_refcount = bed->can_refcount;
 
   table->init_got_refcount.refcount = can_refcount - 1;
@@ -8733,7 +8731,7 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
 				   struct bfd_link_info *info)
 {
   bfd *bfd1, *bfd2;
-  const struct elf_backend_data *bed1, *bed2;
+  elf_backend_data *bed1, *bed2;
   Elf_Internal_Shdr *hdr1, *hdr2;
   size_t symcount1, symcount2;
   Elf_Internal_Sym *isymbuf1, *isymbuf2;
@@ -9767,7 +9765,7 @@ elf_link_adjust_relocs (bfd *abfd,
 			struct bfd_link_info *info)
 {
   unsigned int i;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bfd_byte *erela;
   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
@@ -10032,7 +10030,7 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
   size_t i, ret, sort_elt, ext_size;
   bfd_byte *sort, *s_non_relative, *p;
   struct elf_link_sort_rela *sq;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   int i2e = bed->s->int_rels_per_ext_rel;
   unsigned int opb = bfd_octets_per_byte (abfd, NULL);
   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
@@ -10341,7 +10339,7 @@ elf_link_output_symstrtab (void *finf,
     (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
      struct elf_link_hash_entry *);
   struct elf_link_hash_table *hash_table;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_size_type strtabsize;
 
   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
@@ -10465,7 +10463,7 @@ elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
   struct elf_link_hash_table *hash_table = elf_hash_table (flinfo->info);
   size_t amt;
   size_t i;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *symbuf;
   Elf_Internal_Shdr *hdr;
   file_ptr pos;
@@ -10564,7 +10562,7 @@ check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
 
 static bool
 elf_link_check_versioned_symbol (struct bfd_link_info *info,
-				 const struct elf_backend_data *bed,
+				 elf_backend_data *bed,
 				 struct elf_link_hash_entry *h)
 {
   bfd *abfd;
@@ -10745,7 +10743,7 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
   bool strip;
   Elf_Internal_Sym sym;
   asection *input_sec;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   long indx;
   int ret;
   unsigned int type;
@@ -11272,7 +11270,7 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 static bool
 elf_section_ignore_discarded_relocs (asection *sec)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   switch (sec->sec_info_type)
     {
@@ -11399,7 +11397,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
   long *pindex;
   asection **ppsection;
   asection *o;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_entry **sym_hashes;
   bfd_size_type address_size;
   bfd_vma r_type_mask;
@@ -12339,7 +12337,7 @@ elf_reloc_link_order (bfd *output_bfd,
   struct bfd_elf_section_reloc_data *reldata;
   struct elf_link_hash_entry **rel_hash_ptr;
   Elf_Internal_Shdr *rel_hdr;
-  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (output_bfd);
   Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
   bfd_byte *erel;
   unsigned int i;
@@ -12502,7 +12500,7 @@ elf_output_implib (bfd *abfd, struct bfd_link_info *info)
 {
   bool ret = false;
   bfd *implib_bfd;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   flagword flags;
   enum bfd_architecture arch;
   unsigned int mach;
@@ -12650,7 +12648,7 @@ _bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   unsigned int i;
   Elf_Internal_Shdr *symtab_hdr;
   Elf_Internal_Shdr *symtab_shndx_hdr;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_outext_info eoinfo;
   bool merged;
   size_t relativecount;
@@ -13892,7 +13890,7 @@ static bool
 init_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
 {
   Elf_Internal_Shdr *symtab_hdr;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   bed = get_elf_backend_data (abfd);
   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
@@ -14402,7 +14400,7 @@ static bool
 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
 {
   bfd *sub;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
     {
@@ -14491,7 +14489,7 @@ elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
       pu = h->u2.vtable->parent->u2.vtable->used;
       if (pu != NULL)
 	{
-	  const struct elf_backend_data *bed;
+	  elf_backend_data *bed;
 	  unsigned int log_file_align;
 
 	  bed = get_elf_backend_data (h->root.u.def.section->owner);
@@ -14523,7 +14521,7 @@ elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h,
   asection *sec;
   bfd_vma hstart, hend;
   Elf_Internal_Rela *relstart, *relend, *rel;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned int log_file_align;
   struct link_info_ok *info = (struct link_info_ok *) ptr;
 
@@ -14666,7 +14664,7 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
   bool ok = true;
   bfd *sub;
   elf_gc_mark_hook_fn gc_mark_hook;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab;
   struct link_info_ok info_ok;
 
@@ -14782,7 +14780,7 @@ bfd_elf_gc_record_vtinherit (bfd *abfd,
   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
   struct elf_link_hash_entry **search, *child;
   size_t extsymcount;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
 
   /* The sh_info field of the symtab header tells us where the
      external symbols start.  We don't care about the local symbols at
@@ -14842,7 +14840,7 @@ bfd_elf_gc_record_vtentry (bfd *abfd, asection *sec,
 			   struct elf_link_hash_entry *h,
 			   bfd_vma addend)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   unsigned int log_file_align = bed->s->log_file_align;
 
   if (!h || addend > 1u << 28)
@@ -14951,7 +14949,7 @@ bfd_elf_lookup_section_flags (struct bfd_link_info *info,
   if (!flaginfo->flags_initialized)
     {
       bfd *obfd = info->output_bfd;
-      const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+      elf_backend_data *bed = get_elf_backend_data (obfd);
       struct flag_info_list *tf = flaginfo->flag_list;
       int with_hex = 0;
       int without_hex = 0;
@@ -15022,7 +15020,7 @@ elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
 {
   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
   bfd *obfd = gofarg->info->output_bfd;
-  const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+  elf_backend_data *bed = get_elf_backend_data (obfd);
 
   if (h->got.refcount > 0)
     {
@@ -15043,7 +15041,7 @@ bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
 					struct bfd_link_info *info)
 {
   bfd *i;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bfd_vma gotoff;
   struct alloc_got_off_arg gofarg;
 
@@ -15324,7 +15322,7 @@ bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
 
   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
     {
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
       asection *s;
 
       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
@@ -15530,7 +15528,7 @@ _bfd_elf_default_got_elt_size (bfd *abfd,
 			       bfd *ibfd ATTRIBUTE_UNUSED,
 			       unsigned long symndx ATTRIBUTE_UNUSED)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   return bed->s->arch_size / 8;
 }
 
@@ -15663,7 +15661,7 @@ _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
 void
 _bfd_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
   BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
   bed->s->swap_reloca_out (abfd, rel, loc);
@@ -15674,7 +15672,7 @@ _bfd_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 void
 _bfd_elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
   BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
   bed->s->swap_reloc_out (abfd, rel, loc);
@@ -15711,8 +15709,7 @@ bfd_elf_define_start_stop (struct bfd_link_info *info,
       if (symbol[0] == '.')
 	{
 	  /* .startof. and .sizeof. symbols are local.  */
-	  const struct elf_backend_data *bed;
-	  bed = get_elf_backend_data (info->output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
 	  (*bed->elf_backend_hide_symbol) (info, h, true);
 	}
       else
@@ -15797,8 +15794,7 @@ _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
 #define add_dynamic_entry(TAG, VAL) \
   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
 
-      const struct elf_backend_data *bed
-	= get_elf_backend_data (output_bfd);
+      elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
       if (bfd_link_executable (info))
 	{
diff --git a/bfd/elfnn-aarch64.c b/bfd/elfnn-aarch64.c
index cf023360525..0e0200a47db 100644
--- a/bfd/elfnn-aarch64.c
+++ b/bfd/elfnn-aarch64.c
@@ -7766,7 +7766,7 @@ elfNN_aarch64_allocate_local_symbols (bfd *abfd, unsigned number)
 static bool
 aarch64_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   flagword flags;
   asection *s;
   struct elf_link_hash_entry *h;
@@ -8348,7 +8348,7 @@ elfNN_aarch64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSE
       /* Check relocation against STT_GNU_IFUNC symbol if there are
 	 dynamic symbols.  */
       bfd *abfd = info->output_bfd;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       unsigned long r_symndx = ELFNN_R_SYM (rela->r_info);
       if (r_symndx != STN_UNDEF)
 	{
@@ -9950,8 +9950,7 @@ elfNN_aarch64_early_size_sections (bfd *output_bfd,
       if (tlsbase)
 	{
 	  struct bfd_link_hash_entry *h = NULL;
-	  const struct elf_backend_data *bed =
-	    get_elf_backend_data (output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
 	  if (!(_bfd_generic_link_add_one_symbol
 		(info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
diff --git a/bfd/elfnn-kvx.c b/bfd/elfnn-kvx.c
index bf41737f10b..e091c8c3a65 100644
--- a/bfd/elfnn-kvx.c
+++ b/bfd/elfnn-kvx.c
@@ -3141,7 +3141,7 @@ elfNN_kvx_allocate_local_symbols (bfd *abfd, unsigned number)
 static bool
 kvx_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   flagword flags;
   asection *s;
   struct elf_link_hash_entry *h;
@@ -4375,8 +4375,7 @@ elfNN_kvx_early_size_sections (bfd *output_bfd, struct bfd_link_info *info)
       if (tlsbase)
 	{
 	  struct bfd_link_hash_entry *h = NULL;
-	  const struct elf_backend_data *bed =
-	    get_elf_backend_data (output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
 	  if (!(_bfd_generic_link_add_one_symbol
 		(info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
diff --git a/bfd/elfnn-loongarch.c b/bfd/elfnn-loongarch.c
index 539084fdfd6..1644416a2ef 100644
--- a/bfd/elfnn-loongarch.c
+++ b/bfd/elfnn-loongarch.c
@@ -614,7 +614,7 @@ loongarch_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
   char *name;
   asection *s, *s_got;
   struct elf_link_hash_entry *h;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   /* This function may be called more than once.  */
@@ -1866,7 +1866,7 @@ local_allocate_ifunc_dyn_relocs (struct bfd_link_info *info,
   asection *plt, *gotplt, *relplt;
   struct elf_dyn_relocs *p;
   unsigned int sizeof_reloc;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_link_hash_table *htab;
   /* If AVOID_PLT is TRUE, don't use PLT if possible.  */
   bool use_plt = !avoid_plt || h->plt.refcount > 0;
@@ -2896,7 +2896,7 @@ static void
 loongarch_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 {
   BFD_ASSERT (s && s->contents);
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *loc;
 
   bed = get_elf_backend_data (abfd);
@@ -6462,7 +6462,7 @@ loongarch_elf_finish_dynamic_symbol (bfd *output_bfd,
 				     Elf_Internal_Sym *sym)
 {
   struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
-  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
   if (h->plt.offset != MINUS_ONE)
     {
@@ -6658,7 +6658,7 @@ loongarch_finish_dyn (bfd *output_bfd, struct bfd_link_info *info, bfd *dynobj,
 		      asection *sdyn)
 {
   struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
-  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (output_bfd);
   size_t dynsize = bed->s->sizeof_dyn, skipped_size = 0;
   bfd_byte *dyncon, *dynconend;
 
@@ -6848,7 +6848,7 @@ loongarch_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
       /* Check relocation against STT_GNU_IFUNC symbol if there are
 	 dynamic symbols.  */
       bfd *abfd = info->output_bfd;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       unsigned long r_symndx = ELFNN_R_SYM (rela->r_info);
       if (r_symndx != STN_UNDEF)
 	{
diff --git a/bfd/elfnn-riscv.c b/bfd/elfnn-riscv.c
index ddb300e2765..4447eea0682 100644
--- a/bfd/elfnn-riscv.c
+++ b/bfd/elfnn-riscv.c
@@ -291,7 +291,7 @@ riscv_info_to_howto_rela (bfd *abfd,
 static void
 riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *loc;
 
   bed = get_elf_backend_data (abfd);
@@ -728,7 +728,7 @@ riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
   flagword flags;
   asection *s, *s_got;
   struct elf_link_hash_entry *h;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   /* This function may be called more than once.  */
@@ -2635,8 +2635,8 @@ riscv_elf_relocate_section (bfd *output_bfd,
 			   relocs into .rela.iplt, since it may cause the
 			   overwrite problems.  This is same as what we did
 			   in the riscv_elf_finish_dynamic_symbol.  */
-			const struct elf_backend_data *bed =
-				get_elf_backend_data (output_bfd);
+			elf_backend_data *bed
+			  = get_elf_backend_data (output_bfd);
 			bfd_vma iplt_idx = htab->last_iplt_index--;
 			bfd_byte *loc = htab->elf.irelplt->contents
 					+ iplt_idx * sizeof (ElfNN_External_Rela);
@@ -3448,7 +3448,7 @@ riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
 				 Elf_Internal_Sym *sym)
 {
   struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
-  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
   if (h->plt.offset != (bfd_vma) -1)
     {
@@ -3723,7 +3723,7 @@ riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
 		  bfd *dynobj, asection *sdyn)
 {
   struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
-  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (output_bfd);
   size_t dynsize = bed->s->sizeof_dyn;
   bfd_byte *dyncon, *dynconend;
 
@@ -3878,7 +3878,7 @@ riscv_reloc_type_class (const struct bfd_link_info *info,
       /* Check relocation against STT_GNU_IFUNC symbol if there are
 	 dynamic symbols.  */
       bfd *abfd = info->output_bfd;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       unsigned long r_symndx = ELFNN_R_SYM (rela->r_info);
       if (r_symndx != STN_UNDEF)
 	{
diff --git a/bfd/elfxx-aarch64.c b/bfd/elfxx-aarch64.c
index 55415d3f594..a4846659fe9 100644
--- a/bfd/elfxx-aarch64.c
+++ b/bfd/elfxx-aarch64.c
@@ -705,9 +705,9 @@ typedef struct
 } bfd_search_result_t;
 
 static inline bool
-bfd_is_non_dynamic_elf_object (bfd *abfd, const struct elf_backend_data *out_be)
+bfd_is_non_dynamic_elf_object (bfd *abfd, elf_backend_data *out_be)
 {
-  const struct elf_backend_data *in_be = get_elf_backend_data (abfd);
+  elf_backend_data *in_be = get_elf_backend_data (abfd);
 
   return bfd_get_flavour (abfd) == bfd_target_elf_flavour
     && bfd_count_sections (abfd) != 0
@@ -722,7 +722,7 @@ bfd_is_non_dynamic_elf_object (bfd *abfd, const struct elf_backend_data *out_be)
 static bfd_search_result_t
 bfd_linear_search_one_with_gnu_property (struct bfd_link_info *info)
 {
-  const struct elf_backend_data *be = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *be = get_elf_backend_data (info->output_bfd);
 
   bfd_search_result_t res = {
     .pbfd = NULL,
@@ -853,7 +853,7 @@ _bfd_aarch64_elf_check_gnu_properties_linked_dynamic_objects (
   struct bfd_link_info * info,
   const uint32_t outprop)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
   const int elf_machine_code = bed->elf_machine_code;
   const unsigned int elfclass = bed->s->elfclass;
 
diff --git a/bfd/elfxx-mips.c b/bfd/elfxx-mips.c
index 84ba94c1cda..34f58c311c1 100644
--- a/bfd/elfxx-mips.c
+++ b/bfd/elfxx-mips.c
@@ -1743,7 +1743,7 @@ section_allows_mips16_refs_p (asection *section)
    function, or 0 if we can't decide which function that is.  */
 
 static unsigned long
-mips16_stub_symndx (const struct elf_backend_data *bed,
+mips16_stub_symndx (elf_backend_data *bed,
 		    asection *sec ATTRIBUTE_UNUSED,
 		    const Elf_Internal_Rela *relocs,
 		    const Elf_Internal_Rela *relend)
@@ -3979,9 +3979,8 @@ count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
   if (bfd_link_pic (info))
     {
       asection *p;
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
-      bed = get_elf_backend_data (output_bfd);
       for (p = output_bfd->sections; p ; p = p->next)
 	if ((p->flags & SEC_EXCLUDE) == 0
 	    && (p->flags & SEC_ALLOC) != 0
@@ -8263,7 +8262,7 @@ mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
 			   const Elf_Internal_Rela *rel)
 {
   Elf_Internal_Shdr *rel_hdr;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   /* To determine which flavor of relocation this is, we depend on the
      fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR.  */
@@ -8501,7 +8500,7 @@ _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
   const Elf_Internal_Rela *rel;
   const Elf_Internal_Rela *rel_end;
   asection *sreloc;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct mips_elf_link_hash_table *htab;
   bfd_byte *contents;
   bfd_vma addend;
@@ -10469,7 +10468,7 @@ mips_reloc_against_discarded_section (bfd *output_bfd,
 				      reloc_howto_type *howto,
 				      bfd_byte *contents)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (output_bfd);
   int count = bed->s->int_rels_per_ext_rel;
   unsigned int r_type;
   int i;
@@ -14862,7 +14861,7 @@ _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   Elf32_RegInfo reginfo;
   struct ecoff_debug_info debug;
   struct mips_htab_traverse_info hti;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
   HDRR *symhdr = &debug.symbolic_header;
   void *mdebug_handle = NULL;
@@ -16601,7 +16600,7 @@ _bfd_mips_elf_get_synthetic_symtab (bfd *abfd,
   static const char mipssuffix[] = "@plt";
 
   bool (*slurp_relocs) (bfd *, asection *, asymbol **, bool);
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   bool micromips_p = MICROMIPS_P (abfd);
   Elf_Internal_Shdr *hdr;
   bfd_byte *plt_data;
diff --git a/bfd/elfxx-sparc.c b/bfd/elfxx-sparc.c
index 1e3ecf87da1..d55dd04996f 100644
--- a/bfd/elfxx-sparc.c
+++ b/bfd/elfxx-sparc.c
@@ -750,7 +750,7 @@ sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
 static void
 sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *loc;
 
   bed = get_elf_backend_data (abfd);
@@ -1242,7 +1242,7 @@ _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
 static bool
 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
   flagword flags, pltflags;
   asection *s;
@@ -2711,7 +2711,7 @@ static bfd_vma
 tpoff (struct bfd_link_info *info, bfd_vma address)
 {
   struct elf_link_hash_table *htab = elf_hash_table (info);
-  const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
   bfd_vma static_tls_size;
 
   /* If tls_sec is NULL, we should have signalled an error already.  */
@@ -4223,7 +4223,7 @@ _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
 				      Elf_Internal_Sym *sym)
 {
   struct _bfd_sparc_elf_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct _bfd_sparc_elf_link_hash_entry  *eh;
   bool resolved_to_zero;
 
@@ -4484,7 +4484,7 @@ sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
 		  asection *splt ATTRIBUTE_UNUSED)
 {
   struct _bfd_sparc_elf_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *dyncon, *dynconend;
   size_t dynsize;
   int stt_regidx = -1;
diff --git a/bfd/elfxx-tilegx.c b/bfd/elfxx-tilegx.c
index 9fcfc086322..fff2ef8ae44 100644
--- a/bfd/elfxx-tilegx.c
+++ b/bfd/elfxx-tilegx.c
@@ -1065,7 +1065,7 @@ static const tilegx_create_func reloc_to_create_func[] =
 static void
 tilegx_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *loc;
 
   bed = get_elf_backend_data (abfd);
@@ -1413,7 +1413,7 @@ tilegx_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
   flagword flags;
   asection *s, *s_got;
   struct elf_link_hash_entry *h;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
   /* This function may be called more than once.  */
@@ -3786,7 +3786,7 @@ tilegx_elf_finish_dynamic_symbol (bfd *output_bfd,
       Elf_Internal_Rela rela;
       bfd_byte *loc;
       bfd_vma r_offset;
-      const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+      elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
 
       int rela_index;
@@ -3918,7 +3918,7 @@ tilegx_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
 		   asection *splt ATTRIBUTE_UNUSED)
 {
   struct tilegx_elf_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_byte *dyncon, *dynconend;
   size_t dynsize;
 
diff --git a/bfd/elfxx-x86.c b/bfd/elfxx-x86.c
index df72acf08bf..36ba7919f47 100644
--- a/bfd/elfxx-x86.c
+++ b/bfd/elfxx-x86.c
@@ -53,7 +53,7 @@ _bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
 {
   struct elf_x86_link_hash_table *htab;
   struct bfd_link_hash_entry *base;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   if (!bfd_link_executable (info))
     return;
@@ -95,7 +95,7 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
   struct elf_dyn_relocs *p;
   unsigned int plt_entry_size;
   bool resolved_to_zero;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   if (h->root.type == bfd_link_hash_indirect)
     return true;
@@ -730,7 +730,7 @@ _bfd_x86_elf_link_hash_table_create (bfd *abfd)
       return NULL;
     }
 
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   if (bed->target_id == X86_64_ELF_DATA)
     {
       ret->is_reloc_section = elf_x86_64_is_reloc_section;
@@ -872,7 +872,7 @@ _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
     {
       /* Check for __tls_get_addr reference.  */
       struct elf_x86_link_hash_table *htab;
-      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+      elf_backend_data *bed = get_elf_backend_data (abfd);
       htab = elf_x86_hash_table (info, bed->target_id);
       if (htab)
 	{
@@ -939,7 +939,7 @@ _bfd_x86_elf_check_relocs (bfd *abfd,
   const Elf_Internal_Rela *rel;
   const Elf_Internal_Rela *rel_end;
   asection *sreloc;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bool is_x86_64;
 
   if (bfd_link_relocatable (info))
@@ -1081,7 +1081,7 @@ _bfd_x86_elf_link_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
   Elf_Internal_Rela *irel, *irelend;
   Elf_Internal_Sym *isymbuf = NULL;
   struct elf_link_hash_entry **sym_hashes;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_x86_link_hash_table *htab;
   bfd_vma *local_got_offsets;
   bool is_x86_64;
@@ -1834,7 +1834,7 @@ _bfd_x86_elf_create_sframe_plt (bfd *output_bfd,
 				unsigned int plt_sec_type)
 {
   struct elf_x86_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
 
   unsigned int plt0_entry_size;
   unsigned char func_info;
@@ -1982,7 +1982,7 @@ _bfd_x86_elf_write_sframe_plt (bfd *output_bfd,
 			       unsigned int plt_sec_type)
 {
   struct elf_x86_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   sframe_encoder_ctx *ectx;
   size_t sec_size;
   asection *sec;
@@ -2033,7 +2033,7 @@ _bfd_elf_x86_size_relative_relocs (struct bfd_link_info *info,
 				   bool *need_layout)
 {
   struct elf_x86_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bool is_x86_64;
   bfd_size_type i, count, unaligned_count;
   asection *sec, *srel;
@@ -2135,7 +2135,7 @@ bool
 _bfd_elf_x86_finish_relative_relocs (struct bfd_link_info *info)
 {
   struct elf_x86_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   Elf_Internal_Rela outrel;
   bool is_x86_64;
   bfd_size_type count;
@@ -2202,7 +2202,7 @@ _bfd_elf_x86_valid_reloc_p (asection *input_section,
   if (bfd_link_pic (info)
       && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, h)))
     {
-      const struct elf_backend_data *bed;
+      elf_backend_data *bed;
       unsigned int r_type;
       Elf_Internal_Rela irel;
 
@@ -2288,8 +2288,7 @@ _bfd_x86_elf_late_size_sections (bfd *output_bfd,
   asection *s;
   bool relocs;
   bfd *ibfd;
-  const struct elf_backend_data *bed
-    = get_elf_backend_data (output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
   htab = elf_x86_hash_table (info, bed->target_id);
   if (htab == NULL)
@@ -2770,7 +2769,7 @@ _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
 				      bfd_byte *buf)
 {
   struct elf_x86_link_hash_table *htab;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd *dynobj;
   asection *sdyn;
   bfd_byte *dyncon, *dynconend;
@@ -3107,8 +3106,7 @@ _bfd_x86_elf_early_size_sections (bfd *output_bfd,
 	{
 	  struct elf_x86_link_hash_table *htab;
 	  struct bfd_link_hash_entry *bh = NULL;
-	  const struct elf_backend_data *bed
-	    = get_elf_backend_data (output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (output_bfd);
 
 	  htab = elf_x86_hash_table (info, bed->target_id);
 	  if (htab == NULL)
@@ -3306,7 +3304,7 @@ _bfd_x86_elf_link_report_tls_transition_error
    enum elf_x86_tls_error_type tls_error)
 {
   const char *name;
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_x86_link_hash_table *htab
     = elf_x86_hash_table (info, bed->target_id);
 
@@ -3427,8 +3425,7 @@ _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
   asection *s, *srel;
   struct elf_x86_link_hash_entry *eh;
   struct elf_dyn_relocs *p;
-  const struct elf_backend_data *bed
-    = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
 
   eh = (struct elf_x86_link_hash_entry *) h;
 
@@ -3793,7 +3790,7 @@ _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
   long dynrelcount;
   arelent **dynrelbuf, *p;
   char *names;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
 			      bfd_vma);
   bool (*valid_plt_reloc_p) (unsigned int);
@@ -4040,7 +4037,7 @@ _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
 {
   unsigned int number, features;
   bool updated = false;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   struct elf_x86_link_hash_table *htab;
   unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
 
@@ -4278,7 +4275,7 @@ _bfd_x86_elf_link_setup_gnu_properties
   bfd *pbfd;
   bfd *ebfd = NULL;
   elf_property *prop;
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
   unsigned int got_align;
 
@@ -4986,8 +4983,7 @@ void
 bfd_elf_linker_x86_set_options (struct bfd_link_info *info,
 				struct elf_linker_x86_params *params)
 {
-  const struct elf_backend_data *bed
-    = get_elf_backend_data (info->output_bfd);
+  elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
   struct elf_x86_link_hash_table *htab
     = elf_x86_hash_table (info, bed->target_id);
   if (htab != NULL)
diff --git a/binutils/addr2line.c b/binutils/addr2line.c
index 4842277df82..141a7099de4 100644
--- a/binutils/addr2line.c
+++ b/binutils/addr2line.c
@@ -314,7 +314,7 @@ translate_addresses (bfd *abfd, asection *section)
         pc = bfd_scan_vma (adr, NULL, 16);
       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 	{
-	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+	  elf_backend_data *bed = get_elf_backend_data (abfd);
 	  bfd_vma sign = (bfd_vma) 1 << (bed->s->arch_size - 1);
 
 	  pc &= (sign << 1) - 1;
diff --git a/binutils/objcopy.c b/binutils/objcopy.c
index 040b34ccae4..ebd2a85c0f6 100644
--- a/binutils/objcopy.c
+++ b/binutils/objcopy.c
@@ -2816,7 +2816,7 @@ copy_object (bfd *ibfd, bfd *obfd, const bfd_arch_info_type *input_arch)
       && bfd_get_flavour (ibfd) != bfd_target_elf_flavour
       && bfd_get_flavour (obfd) == bfd_target_elf_flavour)
     {
-      const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+      elf_backend_data *bed = get_elf_backend_data (obfd);
       iarch = bed->arch;
       imach = 0;
     }
diff --git a/binutils/objdump.c b/binutils/objdump.c
index 6564603c376..1fb944909a0 100644
--- a/binutils/objdump.c
+++ b/binutils/objdump.c
@@ -3746,7 +3746,7 @@ disassemble_bytes (struct disassemble_info *inf,
 static void
 disassemble_section (bfd *abfd, asection *section, void *inf)
 {
-  const struct elf_backend_data *bed;
+  elf_backend_data *bed;
   bfd_vma sign_adjust = 0;
   struct disassemble_info *pinfo = (struct disassemble_info *) inf;
   struct objdump_disasm_info *paux;
@@ -5689,7 +5689,7 @@ might_need_separate_debug_info (bool is_mainfile)
 static void
 dump_bfd (bfd *abfd, bool is_mainfile)
 {
-  const struct elf_backend_data * bed;
+  elf_backend_data *bed;
 
   if (bfd_big_endian (abfd))
     byte_get = byte_get_big_endian;
diff --git a/gas/config/obj-elf.c b/gas/config/obj-elf.c
index 689d5cee45e..579c1df2dc3 100644
--- a/gas/config/obj-elf.c
+++ b/gas/config/obj-elf.c
@@ -582,7 +582,6 @@ change_section (const char *name,
   asection *old_sec;
   segT sec;
   flagword flags;
-  const struct elf_backend_data *bed;
   const struct bfd_elf_special_section *ssect;
 
   if (match_p == NULL)
@@ -628,7 +627,7 @@ change_section (const char *name,
 	group_section_insert (match_p, sec, &group_idx);
     }
 
-  bed = get_elf_backend_data (stdoutput);
+  elf_backend_data *bed = get_elf_backend_data (stdoutput);
   ssect = (*bed->get_sec_type_attr) (stdoutput, sec);
 
   if (ssect != NULL)
@@ -1274,7 +1273,7 @@ obj_elf_section (int push)
 	      return;
 	    }
 
-	  const struct elf_backend_data *bed = get_elf_backend_data (stdoutput);
+	  elf_backend_data *bed = get_elf_backend_data (stdoutput);
 	  bool maybe_gnu = (bed->elf_osabi == ELFOSABI_NONE
 			    || bed->elf_osabi == ELFOSABI_GNU
 			    || bed->elf_osabi == ELFOSABI_FREEBSD);
@@ -2342,9 +2341,7 @@ obj_elf_type (int ignore ATTRIBUTE_UNUSED)
 	   || strcmp (type_name, "10") == 0
 	   || strcmp (type_name, "STT_GNU_IFUNC") == 0)
     {
-      const struct elf_backend_data *bed;
-
-      bed = get_elf_backend_data (stdoutput);
+      elf_backend_data *bed = get_elf_backend_data (stdoutput);
       if (bed->elf_osabi != ELFOSABI_NONE
 	  && bed->elf_osabi != ELFOSABI_GNU
 	  && bed->elf_osabi != ELFOSABI_FREEBSD)
@@ -2359,9 +2356,7 @@ obj_elf_type (int ignore ATTRIBUTE_UNUSED)
     }
   else if (strcmp (type_name, "gnu_unique_object") == 0)
     {
-      const struct elf_backend_data *bed;
-
-      bed = get_elf_backend_data (stdoutput);
+      elf_backend_data *bed = get_elf_backend_data (stdoutput);
       if (bed->elf_osabi != ELFOSABI_NONE
 	  && bed->elf_osabi != ELFOSABI_GNU)
 	as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
diff --git a/ld/emultempl/vms.em b/ld/emultempl/vms.em
index 46fe618b505..5b1a54b699d 100644
--- a/ld/emultempl/vms.em
+++ b/ld/emultempl/vms.em
@@ -188,15 +188,12 @@ fragment <<EOF
 static void
 gld${EMULATION_NAME}_before_allocation (void)
 {
-  const struct elf_backend_data *bed;
-
   if (!is_elf_hash_table (link_info.hash))
     return;
 
-  bed = get_elf_backend_data (link_info.output_bfd);
-
   /* The backend must work out the sizes of all the other dynamic
      sections.  */
+  elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
   if (bed->elf_backend_late_size_sections
       && !bed->elf_backend_late_size_sections (link_info.output_bfd,
 					       &link_info))
diff --git a/ld/ldelf.c b/ld/ldelf.c
index 25e9d68ae62..a67f540b2df 100644
--- a/ld/ldelf.c
+++ b/ld/ldelf.c
@@ -1388,9 +1388,7 @@ ldelf_after_open (int use_libpath, int native, int is_linux, int is_freebsd,
 	}
       if (elfbfd)
 	{
-	  const struct elf_backend_data *bed;
-
-	  bed = get_elf_backend_data (elfbfd);
+	  elf_backend_data *bed = get_elf_backend_data (elfbfd);
 	  s = bfd_make_section_with_flags (elfbfd, ".eh_frame_hdr",
 					   bed->dynamic_sec_flags
 					   | SEC_READONLY);
@@ -1436,7 +1434,7 @@ id_note_section_size (bfd *abfd ATTRIBUTE_UNUSED)
 static bool
 write_build_id (bfd *abfd)
 {
-  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_obj_tdata *t = elf_tdata (abfd);
   const char *style;
   asection *asec;
diff --git a/ld/ldelfgen.c b/ld/ldelfgen.c
index 69b02062ef6..022b9d0160f 100644
--- a/ld/ldelfgen.c
+++ b/ld/ldelfgen.c
@@ -333,8 +333,7 @@ ldelf_map_segments (bool need_layout)
     {
       /* If we don't have user supplied phdrs, strip zero-sized dynamic
 	 sections and regenerate program headers.  */
-      const struct elf_backend_data *bed
-	= get_elf_backend_data (link_info.output_bfd);
+      elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
       if (bed->elf_backend_strip_zero_sized_dynamic_sections
 	  && !bed->elf_backend_strip_zero_sized_dynamic_sections (&link_info))
 	fatal (_("%P: failed to strip zero-sized dynamic sections\n"));
diff --git a/ld/ldlang.c b/ld/ldlang.c
index d126ef22755..76a6c621dcb 100644
--- a/ld/ldlang.c
+++ b/ld/ldlang.c
@@ -7175,11 +7175,10 @@ undef_start_stop (struct bfd_link_hash_entry *h)
       h->u.undef.abfd = NULL;
       if (is_elf_hash_table (link_info.hash))
 	{
-	  const struct elf_backend_data *bed;
+	  elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
 	  struct elf_link_hash_entry *eh = (struct elf_link_hash_entry *) h;
 	  unsigned int was_forced = eh->forced_local;
 
-	  bed = get_elf_backend_data (link_info.output_bfd);
 	  (*bed->elf_backend_hide_symbol) (&link_info, eh, true);
 	  if (!eh->ref_regular_nonweak)
 	    h->type = bfd_link_hash_undefweak;
@@ -7284,8 +7283,7 @@ lang_symbol_tweaks (void)
 	      || h->root.type == bfd_link_hash_undefweak
 	      || h->root.type == bfd_link_hash_common))
 	{
-	  const struct elf_backend_data *bed;
-	  bed = get_elf_backend_data (link_info.output_bfd);
+	  elf_backend_data *bed = get_elf_backend_data (link_info.output_bfd);
 	  (*bed->elf_backend_hide_symbol) (&link_info, h, true);
 	  if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
 	    h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;