daily update

[deliverable/binutils-gdb.git] / bfd / elf64-alpha.c

diff --git a/bfd/elf64-alpha.c b/bfd/elf64-alpha.c
index efda7530e5bd99b2362d3a44b3be37f5c19f441d..c22b4fd5ab128bd5223729c2b8fa7cd468a914cc 100644 (file)
--- a/bfd/elf64-alpha.c
+++ b/bfd/elf64-alpha.c
@@ -1,13 +1,13 @@
 /* Alpha specific support for 64-bit ELF
    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
 /* Alpha specific support for 64-bit ELF
    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,

-   2006, 2007 Free Software Foundation, Inc.
+   2006, 2007, 2008 Free Software Foundation, Inc.

    Contributed by Richard Henderson <rth@tamu.edu>.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    Contributed by Richard Henderson <rth@tamu.edu>.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -17,13 +17,15 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software

-   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
+

 
 /* We need a published ABI spec for this.  Until one comes out, don't
    assume this'll remain unchanged forever.  */
 
 
 /* We need a published ABI spec for this.  Until one comes out, don't
    assume this'll remain unchanged forever.  */
 

-#include "bfd.h"

 #include "sysdep.h"
 #include "sysdep.h"

+#include "bfd.h"

 #include "libbfd.h"
 #include "elf-bfd.h"
 
 #include "libbfd.h"
 #include "elf-bfd.h"
 


@@ -184,6 +186,10 @@ struct alpha_elf_link_hash_table
   /* The head of a list of .got subsections linked through
      alpha_elf_tdata(abfd)->got_link_next.  */
   bfd *got_list;
   /* The head of a list of .got subsections linked through
      alpha_elf_tdata(abfd)->got_link_next.  */
   bfd *got_list;

+
+  /* The most recent relax pass that we've seen.  The GOTs
+     should be regenerated if this doesn't match.  */
+  int relax_trip;

 };
 
 /* Look up an entry in a Alpha ELF linker hash table.  */
 };
 
 /* Look up an entry in a Alpha ELF linker hash table.  */


@@ -318,17 +324,16 @@ struct alpha_elf_obj_tdata
 #define alpha_elf_tdata(abfd) \
   ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
 
 #define alpha_elf_tdata(abfd) \
   ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
 

+#define is_alpha_elf(bfd) \
+  (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
+   && elf_tdata (bfd) != NULL \
+   && elf_object_id (bfd) == ALPHA_ELF_TDATA)
+

 static bfd_boolean
 elf64_alpha_mkobject (bfd *abfd)
 {
 static bfd_boolean
 elf64_alpha_mkobject (bfd *abfd)
 {

-  if (abfd->tdata.any == NULL)
-    {
-      bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
-      abfd->tdata.any = bfd_zalloc (abfd, amt);
-      if (abfd->tdata.any == NULL)
-       return FALSE;
-    }
-  return bfd_elf_mkobject (abfd);
+  return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata),
+                                 ALPHA_ELF_TDATA);

 }
 
 static bfd_boolean
 }
 
 static bfd_boolean


@@ -1055,6 +1060,23 @@ elf64_alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
   return 0;
 }
 
   return 0;
 }
 

+static reloc_howto_type *
+elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+                                  const char *r_name)
+{
+  unsigned int i;
+
+  for (i = 0;
+       i < (sizeof (elf64_alpha_howto_table)
+           / sizeof (elf64_alpha_howto_table[0]));
+       i++)
+    if (elf64_alpha_howto_table[i].name != NULL
+       && strcasecmp (elf64_alpha_howto_table[i].name, r_name) == 0)
+      return &elf64_alpha_howto_table[i];
+
+  return NULL;
+}
+

 /* Given an Alpha ELF reloc type, fill in an arelent structure.  */
 
 static void
 /* Given an Alpha ELF reloc type, fill in an arelent structure.  */
 
 static void


@@ -1211,6 +1233,9 @@ elf64_alpha_create_got_section (bfd *abfd,
   flagword flags;
   asection *s;
 
   flagword flags;
   asection *s;
 

+  if (! is_alpha_elf (abfd))
+    return FALSE;
+

   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
           | SEC_LINKER_CREATED);
   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
           | SEC_LINKER_CREATED);
   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);


@@ -1237,6 +1262,9 @@ elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   flagword flags;
   struct elf_link_hash_entry *h;
 
   flagword flags;
   struct elf_link_hash_entry *h;
 

+  if (! is_alpha_elf (abfd))
+    return FALSE;
+

   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY


@@ -1720,7 +1748,6 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 {
   bfd *dynobj;
   asection *sreloc;
 {
   bfd *dynobj;
   asection *sreloc;

-  const char *rel_sec_name;

   Elf_Internal_Shdr *symtab_hdr;
   struct alpha_elf_link_hash_entry **sym_hashes;
   const Elf_Internal_Rela *rel, *relend;
   Elf_Internal_Shdr *symtab_hdr;
   struct alpha_elf_link_hash_entry **sym_hashes;
   const Elf_Internal_Rela *rel, *relend;


@@ -1738,14 +1765,15 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
   if ((sec->flags & SEC_ALLOC) == 0)
     return TRUE;
 
   if ((sec->flags & SEC_ALLOC) == 0)
     return TRUE;
 

-  dynobj = elf_hash_table(info)->dynobj;
+  BFD_ASSERT (is_alpha_elf (abfd));
+
+  dynobj = elf_hash_table (info)->dynobj;

   if (dynobj == NULL)
   if (dynobj == NULL)

-    elf_hash_table(info)->dynobj = dynobj = abfd;
+    elf_hash_table (info)->dynobj = dynobj = abfd;

 
   sreloc = NULL;
 
   sreloc = NULL;

-  rel_sec_name = NULL;
-  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
-  sym_hashes = alpha_elf_sym_hashes(abfd);
+  symtab_hdr = &elf_symtab_hdr (abfd);
+  sym_hashes = alpha_elf_sym_hashes (abfd);

 
   relend = relocs + sec->reloc_count;
   for (rel = relocs; rel < relend; ++rel)
 
   relend = relocs + sec->reloc_count;
   for (rel = relocs; rel < relend; ++rel)


@@ -1893,41 +1921,16 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 
       if (need & NEED_DYNREL)
        {
 
       if (need & NEED_DYNREL)
        {

-         if (rel_sec_name == NULL)
-           {
-             rel_sec_name = (bfd_elf_string_from_elf_section
-                             (abfd, elf_elfheader(abfd)->e_shstrndx,
-                              elf_section_data(sec)->rel_hdr.sh_name));
-             if (rel_sec_name == NULL)
-               return FALSE;
-
-             BFD_ASSERT (CONST_STRNEQ (rel_sec_name, ".rela")
-                         && strcmp (bfd_get_section_name (abfd, sec),
-                                    rel_sec_name+5) == 0);
-           }
-

          /* We need to create the section here now whether we eventually
             use it or not so that it gets mapped to an output section by
          /* We need to create the section here now whether we eventually
             use it or not so that it gets mapped to an output section by

-            the linker.  If not used, we'll kill it in
-            size_dynamic_sections.  */
+            the linker.  If not used, we'll kill it in size_dynamic_sections.  */

          if (sreloc == NULL)
            {
          if (sreloc == NULL)
            {

-             sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
+             sreloc = _bfd_elf_make_dynamic_reloc_section
+               (sec, dynobj, 3, abfd, /*rela?*/ TRUE);
+

              if (sreloc == NULL)
              if (sreloc == NULL)

-               {
-                 flagword flags;
-
-                 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
-                          | SEC_LINKER_CREATED | SEC_READONLY);
-                 if (sec->flags & SEC_ALLOC)
-                   flags |= SEC_ALLOC | SEC_LOAD;
-                 sreloc = bfd_make_section_with_flags (dynobj,
-                                                       rel_sec_name,
-                                                       flags);
-                 if (sreloc == NULL
-                     || !bfd_set_section_alignment (dynobj, sreloc, 3))
-                   return FALSE;
-               }
+               return FALSE;

            }
 
          if (h)
            }
 
          if (h)


@@ -2358,7 +2361,6 @@ static bfd_boolean
 elf64_alpha_size_got_sections (struct bfd_link_info *info)
 {
   bfd *i, *got_list, *cur_got_obj = NULL;
 elf64_alpha_size_got_sections (struct bfd_link_info *info)
 {
   bfd *i, *got_list, *cur_got_obj = NULL;

-  int something_changed = 0;

 
   got_list = alpha_elf_hash_table (info)->got_list;
 
 
   got_list = alpha_elf_hash_table (info)->got_list;
 


@@ -2368,7 +2370,12 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info)
     {
       for (i = info->input_bfds; i ; i = i->link_next)
        {
     {
       for (i = info->input_bfds; i ; i = i->link_next)
        {

-         bfd *this_got = alpha_elf_tdata (i)->gotobj;
+         bfd *this_got;
+
+         if (! is_alpha_elf (i))
+           continue;
+
+         this_got = alpha_elf_tdata (i)->gotobj;

          if (this_got == NULL)
            continue;
 
          if (this_got == NULL)
            continue;
 


@@ -2396,12 +2403,12 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info)
        return TRUE;
 
       alpha_elf_hash_table (info)->got_list = got_list;
        return TRUE;
 
       alpha_elf_hash_table (info)->got_list = got_list;

-
-      /* Force got offsets to be recalculated.  */
-      something_changed = 1;

     }
 
   cur_got_obj = got_list;
     }
 
   cur_got_obj = got_list;

+  if (cur_got_obj == NULL)
+    return FALSE;
+

   i = alpha_elf_tdata(cur_got_obj)->got_link_next;
   while (i != NULL)
     {
   i = alpha_elf_tdata(cur_got_obj)->got_link_next;
   while (i != NULL)
     {


@@ -2412,8 +2419,6 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info)
          alpha_elf_tdata(i)->got->size = 0;
          i = alpha_elf_tdata(i)->got_link_next;
          alpha_elf_tdata(cur_got_obj)->got_link_next = i;
          alpha_elf_tdata(i)->got->size = 0;
          i = alpha_elf_tdata(i)->got_link_next;
          alpha_elf_tdata(cur_got_obj)->got_link_next = i;

-         
-         something_changed = 1;

        }
       else
        {
        }
       else
        {


@@ -2424,8 +2429,7 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info)
 
   /* Once the gots have been merged, fill in the got offsets for
      everything therein.  */
 
   /* Once the gots have been merged, fill in the got offsets for
      everything therein.  */

-  if (1 || something_changed)
-    elf64_alpha_calc_got_offsets (info);
+  elf64_alpha_calc_got_offsets (info);

 
   return TRUE;
 }
 
   return TRUE;
 }


@@ -2460,10 +2464,10 @@ elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h, PTR data)
   return TRUE;
 }
 
   return TRUE;
 }
 

-/* Called from relax_section to rebuild the PLT in light of
-   potential changes in the function's status.  */
+/* Called from relax_section to rebuild the PLT in light of potential changes
+   in the function's status.  */

 
 

-static bfd_boolean
+static void

 elf64_alpha_size_plt_section (struct bfd_link_info *info)
 {
   asection *splt, *spltrel, *sgotplt;
 elf64_alpha_size_plt_section (struct bfd_link_info *info)
 {
   asection *splt, *spltrel, *sgotplt;


@@ -2473,7 +2477,7 @@ elf64_alpha_size_plt_section (struct bfd_link_info *info)
   dynobj = elf_hash_table(info)->dynobj;
   splt = bfd_get_section_by_name (dynobj, ".plt");
   if (splt == NULL)
   dynobj = elf_hash_table(info)->dynobj;
   splt = bfd_get_section_by_name (dynobj, ".plt");
   if (splt == NULL)

-    return TRUE;
+    return;

 
   splt->size = 0;
 
 
   splt->size = 0;
 


@@ -2482,6 +2486,7 @@ elf64_alpha_size_plt_section (struct bfd_link_info *info)
 
   /* Every plt entry requires a JMP_SLOT relocation.  */
   spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");
 
   /* Every plt entry requires a JMP_SLOT relocation.  */
   spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");

+  entries = 0;

   if (splt->size)
     {
       if (elf64_alpha_use_secureplt)
   if (splt->size)
     {
       if (elf64_alpha_use_secureplt)


@@ -2489,8 +2494,6 @@ elf64_alpha_size_plt_section (struct bfd_link_info *info)
       else
        entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
     }
       else
        entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
     }

-  else
-    entries = 0;

   spltrel->size = entries * sizeof (Elf64_External_Rela);
 
   /* When using the secureplt, we need two words somewhere in the data
   spltrel->size = entries * sizeof (Elf64_External_Rela);
 
   /* When using the secureplt, we need two words somewhere in the data


@@ -2501,8 +2504,6 @@ elf64_alpha_size_plt_section (struct bfd_link_info *info)
       sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
       sgotplt->size = entries ? 16 : 0;
     }
       sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
       sgotplt->size = entries ? 16 : 0;
     }

-
-  return TRUE;

 }
 
 static bfd_boolean
 }
 
 static bfd_boolean


@@ -2673,7 +2674,7 @@ elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
 
 /* Set the sizes of the dynamic relocation sections.  */
 
 
 /* Set the sizes of the dynamic relocation sections.  */
 

-static bfd_boolean
+static void

 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
 {
   unsigned long entries;
 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
 {
   unsigned long entries;


@@ -2712,15 +2713,13 @@ elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
   if (!srel)
     {
       BFD_ASSERT (entries == 0);
   if (!srel)
     {
       BFD_ASSERT (entries == 0);

-      return TRUE;
+      return;

     }
   srel->size = sizeof (Elf64_External_Rela) * entries;
 
   /* Now do the non-local symbols.  */
   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
                                elf64_alpha_size_rela_got_1, info);
     }
   srel->size = sizeof (Elf64_External_Rela) * entries;
 
   /* Now do the non-local symbols.  */
   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
                                elf64_alpha_size_rela_got_1, info);

-
-  return TRUE;

 }
 
 /* Set the sizes of the dynamic sections.  */
 }
 
 /* Set the sizes of the dynamic sections.  */


@@ -3078,7 +3077,7 @@ elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
 
   /* We've now determined that we can skip an initial gp load.  Verify
      that the call and the target use the same gp.   */
 
   /* We've now determined that we can skip an initial gp load.  Verify
      that the call and the target use the same gp.   */

-  if (info->link_info->hash->creator != info->tsec->owner->xvec
+  if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec

       || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
     return 0;
 
       || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
     return 0;
 


@@ -3592,7 +3591,7 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec,
   struct alpha_elf_got_entry **local_got_entries;
   struct alpha_relax_info info;
 
   struct alpha_elf_got_entry **local_got_entries;
   struct alpha_relax_info info;
 

-  /* We are not currently changing any sizes, so only one pass.  */
+  /* There's nothing to change, yet.  */

   *again = FALSE;
 
   if (link_info->relocatable
   *again = FALSE;
 
   if (link_info->relocatable


@@ -3601,7 +3600,25 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec,
       || sec->reloc_count == 0)
     return TRUE;
 
       || sec->reloc_count == 0)
     return TRUE;
 

-  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  BFD_ASSERT (is_alpha_elf (abfd));
+
+  /* Make sure our GOT and PLT tables are up-to-date.  */
+  if (alpha_elf_hash_table(link_info)->relax_trip != link_info->relax_trip)
+    {
+      alpha_elf_hash_table(link_info)->relax_trip = link_info->relax_trip;
+
+      /* This should never fail after the initial round, since the only
+        error is GOT overflow, and relaxation only shrinks the table.  */
+      if (!elf64_alpha_size_got_sections (link_info))
+       abort ();
+      if (elf_hash_table (link_info)->dynamic_sections_created)
+       {
+         elf64_alpha_size_plt_section (link_info);
+         elf64_alpha_size_rela_got_section (link_info);
+       }
+    }
+
+  symtab_hdr = &elf_symtab_hdr (abfd);

   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
 
   /* Load the relocations for this section.  */
   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
 
   /* Load the relocations for this section.  */


@@ -3810,13 +3827,6 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec,
        }
     }
 
        }
     }
 

-  if (!elf64_alpha_size_plt_section (link_info))
-    return FALSE;
-  if (!elf64_alpha_size_got_sections (link_info))
-    return FALSE;
-  if (!elf64_alpha_size_rela_got_section (link_info))
-    return FALSE;
-

   if (isymbuf != NULL
       && symtab_hdr->contents != (unsigned char *) isymbuf)
     {
   if (isymbuf != NULL
       && symtab_hdr->contents != (unsigned char *) isymbuf)
     {


@@ -3915,7 +3925,7 @@ elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
   struct elf_link_hash_entry **sym_hashes;
   bfd_boolean ret_val = TRUE;
 
   struct elf_link_hash_entry **sym_hashes;
   bfd_boolean ret_val = TRUE;
 

-  symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info;
+  symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;

   sym_hashes = elf_sym_hashes (input_bfd);
 
   relend = relocs + input_section->reloc_count;
   sym_hashes = elf_sym_hashes (input_bfd);
 
   relend = relocs + input_section->reloc_count;


@@ -4003,6 +4013,8 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
   struct alpha_elf_got_entry **local_got_entries;
   bfd_boolean ret_val;
 
   struct alpha_elf_got_entry **local_got_entries;
   bfd_boolean ret_val;
 

+  BFD_ASSERT (is_alpha_elf (input_bfd));
+  

   /* Handle relocatable links with a smaller loop.  */
   if (info->relocatable)
     return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
   /* Handle relocatable links with a smaller loop.  */
   if (info->relocatable)
     return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,


@@ -4013,7 +4025,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 
   ret_val = TRUE;
 
 
   ret_val = TRUE;
 

-  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+  symtab_hdr = &elf_symtab_hdr (input_bfd);

 
   dynobj = elf_hash_table (info)->dynobj;
   if (dynobj)
 
   dynobj = elf_hash_table (info)->dynobj;
   if (dynobj)


@@ -5023,15 +5035,11 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
              input_section = p->u.indirect.section;
              input_bfd = input_section->owner;
 
              input_section = p->u.indirect.section;
              input_bfd = input_section->owner;
 

-             if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
-                 || (get_elf_backend_data (input_bfd)
-                     ->elf_backend_ecoff_debug_swap) == NULL)
-               {
-                 /* I don't know what a non ALPHA ELF bfd would be
-                    doing with a .mdebug section, but I don't really
-                    want to deal with it.  */
-                 continue;
-               }
+             if (! is_alpha_elf (input_bfd))
+               /* I don't know what a non ALPHA ELF bfd would be
+                  doing with a .mdebug section, but I don't really
+                  want to deal with it.  */
+               continue;

 
              input_swap = (get_elf_backend_data (input_bfd)
                            ->elf_backend_ecoff_debug_swap);
 
              input_swap = (get_elf_backend_data (input_bfd)
                            ->elf_backend_ecoff_debug_swap);


@@ -5257,6 +5265,7 @@ static const struct elf_size_info alpha_elf_size_info =
   ELFCLASS64, EV_CURRENT,
   bfd_elf64_write_out_phdrs,
   bfd_elf64_write_shdrs_and_ehdr,
   ELFCLASS64, EV_CURRENT,
   bfd_elf64_write_out_phdrs,
   bfd_elf64_write_shdrs_and_ehdr,

+  bfd_elf64_checksum_contents,

   bfd_elf64_write_relocs,
   bfd_elf64_swap_symbol_in,
   bfd_elf64_swap_symbol_out,
   bfd_elf64_write_relocs,
   bfd_elf64_swap_symbol_in,
   bfd_elf64_swap_symbol_out,


@@ -5282,6 +5291,8 @@ static const struct elf_size_info alpha_elf_size_info =
 
 #define bfd_elf64_bfd_reloc_type_lookup \
   elf64_alpha_bfd_reloc_type_lookup
 
 #define bfd_elf64_bfd_reloc_type_lookup \
   elf64_alpha_bfd_reloc_type_lookup

+#define bfd_elf64_bfd_reloc_name_lookup \
+  elf64_alpha_bfd_reloc_name_lookup

 #define elf_info_to_howto \
   elf64_alpha_info_to_howto
 
 #define elf_info_to_howto \
   elf64_alpha_info_to_howto
 


@@ -5306,6 +5317,8 @@ static const struct elf_size_info alpha_elf_size_info =
 
 #define elf_backend_add_symbol_hook \
   elf64_alpha_add_symbol_hook
 
 #define elf_backend_add_symbol_hook \
   elf64_alpha_add_symbol_hook

+#define elf_backend_relocs_compatible \
+  _bfd_elf_relocs_compatible

 #define elf_backend_check_relocs \
   elf64_alpha_check_relocs
 #define elf_backend_create_dynamic_sections \
 #define elf_backend_check_relocs \
   elf64_alpha_check_relocs
 #define elf_backend_create_dynamic_sections \