Re: Enable --build-id for moxie-elf-ld

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

diff --git a/bfd/elf64-sparc.c b/bfd/elf64-sparc.c
index 0eefc95c125eb982c9df3420b4bd5fdf32f259c9..8bf9623bd9fca6e240db79135353c19a2391fbb8 100644 (file)
--- a/bfd/elf64-sparc.c
+++ b/bfd/elf64-sparc.c
@@ -1,12 +1,11 @@
 /* SPARC-specific support for 64-bit ELF
 /* SPARC-specific support for 64-bit ELF

-   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 1993-2019 Free Software Foundation, Inc.

 
    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
 
    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,


@@ -16,10 +15,12 @@
 
    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.  */

 
 

-#include "bfd.h"

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

+#include <limits.h>
+#include "bfd.h"

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


@@ -36,13 +37,28 @@
 static long
 elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
 {
 static long
 elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
 {

+#if SIZEOF_LONG == SIZEOF_INT
+  if (sec->reloc_count >= LONG_MAX / 2 / sizeof (arelent *))
+    {
+      bfd_set_error (bfd_error_file_too_big);
+      return -1;
+    }
+#endif

   return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
 }
 
 static long
 elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
 {
   return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
 }
 
 static long
 elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
 {

-  return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
+  long ret = _bfd_elf_get_dynamic_reloc_upper_bound (abfd);
+  if (ret > LONG_MAX / 2)
+    {
+      bfd_set_error (bfd_error_file_too_big);
+      ret = -1;
+    }
+  else if (ret > 0)
+    ret *= 2;
+  return ret;

 }
 
 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
 }
 
 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of


@@ -55,7 +71,7 @@ elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
                                   Elf_Internal_Shdr *rel_hdr,
                                   asymbol **symbols, bfd_boolean dynamic)
 {
                                   Elf_Internal_Shdr *rel_hdr,
                                   asymbol **symbols, bfd_boolean dynamic)
 {

-  PTR allocated = NULL;
+  void * allocated = NULL;

   bfd_byte *native_relocs;
   arelent *relent;
   unsigned int i;
   bfd_byte *native_relocs;
   arelent *relent;
   unsigned int i;


@@ -63,7 +79,7 @@ elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
   bfd_size_type count;
   arelent *relents;
 
   bfd_size_type count;
   arelent *relents;
 

-  allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
+  allocated = bfd_malloc (rel_hdr->sh_size);

   if (allocated == NULL)
     goto error_return;
 
   if (allocated == NULL)
     goto error_return;
 


@@ -97,8 +113,20 @@ elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
       else
        relent->address = rela.r_offset - asect->vma;
 
       else
        relent->address = rela.r_offset - asect->vma;
 

-      if (ELF64_R_SYM (rela.r_info) == 0)
+      if (ELF64_R_SYM (rela.r_info) == STN_UNDEF)

        relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
        relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;

+      else if (/* PR 17512: file: 996185f8.  */
+              ELF64_R_SYM (rela.r_info) > (dynamic
+                                           ? bfd_get_dynamic_symcount (abfd)
+                                           : bfd_get_symcount (abfd)))
+       {
+         _bfd_error_handler
+           /* xgettext:c-format */
+           (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
+            abfd, asect, i, (long) ELF64_R_SYM (rela.r_info));
+         bfd_set_error (bfd_error_bad_value);
+         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
+       }

       else
        {
          asymbol **ps, *s;
       else
        {
          asymbol **ps, *s;


@@ -118,15 +146,19 @@ elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
       r_type = ELF64_R_TYPE_ID (rela.r_info);
       if (r_type == R_SPARC_OLO10)
        {
       r_type = ELF64_R_TYPE_ID (rela.r_info);
       if (r_type == R_SPARC_OLO10)
        {

-         relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10);
+         relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_LO10);

          relent[1].address = relent->address;
          relent++;
          relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
          relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
          relent[1].address = relent->address;
          relent++;
          relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
          relent->addend = ELF64_R_TYPE_DATA (rela.r_info);

-         relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_13);
+         relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_13);

        }
       else
        }
       else

-       relent->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
+       {
+         relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, r_type);
+         if (relent->howto == NULL)
+           goto error_return;
+       }

     }
 
   canon_reloc_count (asect) += relent - relents;
     }
 
   canon_reloc_count (asect) += relent - relents;


@@ -162,10 +194,10 @@ elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
          || asect->reloc_count == 0)
        return TRUE;
 
          || asect->reloc_count == 0)
        return TRUE;
 

-      rel_hdr = &d->rel_hdr;
-      rel_hdr2 = d->rel_hdr2;
+      rel_hdr = d->rel.hdr;
+      rel_hdr2 = d->rela.hdr;

 
 

-      BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
+      BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)

                  || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
     }
   else
                  || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
     }
   else


@@ -192,8 +224,9 @@ elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
      canon_reloc_count.  */
   canon_reloc_count (asect) = 0;
 
      canon_reloc_count.  */
   canon_reloc_count (asect) = 0;
 

-  if (!elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
-                                         dynamic))
+  if (rel_hdr
+      && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
+                                            dynamic))

     return FALSE;
 
   if (rel_hdr2
     return FALSE;
 
   if (rel_hdr2


@@ -273,10 +306,22 @@ elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
   return ret;
 }
 
   return ret;
 }
 

+/* Install a new set of internal relocs.  */
+
+static void
+elf64_sparc_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
+                      asection *asect,
+                      arelent **location,
+                      unsigned int count)
+{
+  asect->orelocation = location;
+  canon_reloc_count (asect) = count;
+}
+

 /* Write out the relocs.  */
 
 static void
 /* Write out the relocs.  */
 
 static void

-elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
+elf64_sparc_write_relocs (bfd *abfd, asection *sec, void * data)

 {
   bfd_boolean *failedp = (bfd_boolean *) data;
   Elf_Internal_Shdr *rela_hdr;
 {
   bfd_boolean *failedp = (bfd_boolean *) data;
   Elf_Internal_Shdr *rela_hdr;


@@ -297,14 +342,14 @@ elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
      reloc_count field to zero to inhibit writing them here.  Also,
      sometimes the SEC_RELOC flag gets set even when there aren't any
      relocs.  */
      reloc_count field to zero to inhibit writing them here.  Also,
      sometimes the SEC_RELOC flag gets set even when there aren't any
      relocs.  */

-  if (sec->reloc_count == 0)
+  if (canon_reloc_count (sec) == 0)

     return;
 
   /* We can combine two relocs that refer to the same address
      into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
      latter is R_SPARC_13 with no associated symbol.  */
   count = 0;
     return;
 
   /* We can combine two relocs that refer to the same address
      into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
      latter is R_SPARC_13 with no associated symbol.  */
   count = 0;

-  for (idx = 0; idx < sec->reloc_count; idx++)
+  for (idx = 0; idx < canon_reloc_count (sec); idx++)

     {
       bfd_vma addr;
 
     {
       bfd_vma addr;
 


@@ -312,7 +357,7 @@ elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
 
       addr = sec->orelocation[idx]->address;
       if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
 
       addr = sec->orelocation[idx]->address;
       if (sec->orelocation[idx]->howto->type == R_SPARC_LO10

-         && idx < sec->reloc_count - 1)
+         && idx < canon_reloc_count (sec) - 1)

        {
          arelent *r = sec->orelocation[idx + 1];
 
        {
          arelent *r = sec->orelocation[idx + 1];
 


@@ -324,10 +369,10 @@ elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
        }
     }
 
        }
     }
 

-  rela_hdr = &elf_section_data (sec)->rel_hdr;
+  rela_hdr = elf_section_data (sec)->rela.hdr;

 
   rela_hdr->sh_size = rela_hdr->sh_entsize * count;
 
   rela_hdr->sh_size = rela_hdr->sh_entsize * count;

-  rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
+  rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);

   if (rela_hdr->contents == NULL)
     {
       *failedp = TRUE;
   if (rela_hdr->contents == NULL)
     {
       *failedp = TRUE;


@@ -349,7 +394,7 @@ elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
   outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
   src_rela = outbound_relocas;
 
   outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
   src_rela = outbound_relocas;
 

-  for (idx = 0; idx < sec->reloc_count; idx++)
+  for (idx = 0; idx < canon_reloc_count (sec); idx++)

     {
       Elf_Internal_Rela dst_rela;
       arelent *ptr;
     {
       Elf_Internal_Rela dst_rela;
       arelent *ptr;


@@ -383,7 +428,7 @@ elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
        }
 
       if (ptr->howto->type == R_SPARC_LO10
        }
 
       if (ptr->howto->type == R_SPARC_LO10

-         && idx < sec->reloc_count - 1)
+         && idx < canon_reloc_count (sec) - 1)

        {
          arelent *r = sec->orelocation[idx + 1];
 
        {
          arelent *r = sec->orelocation[idx + 1];
 


@@ -434,31 +479,32 @@ elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
        case 2: reg -= 2; break;
        case 6: reg -= 4; break;
        default:
        case 2: reg -= 2; break;
        case 6: reg -= 4; break;
        default:

-          (*_bfd_error_handler)
-            (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
-             abfd);
+         _bfd_error_handler
+           (_("%pB: only registers %%g[2367] can be declared using STT_REGISTER"),
+            abfd);

          return FALSE;
        }
 
          return FALSE;
        }
 

-      if (info->hash->creator != abfd->xvec
+      if (info->output_bfd->xvec != abfd->xvec

          || (abfd->flags & DYNAMIC) != 0)
          || (abfd->flags & DYNAMIC) != 0)

-        {
+       {

          /* STT_REGISTER only works when linking an elf64_sparc object.
             If STT_REGISTER comes from a dynamic object, don't put it into
             the output bfd.  The dynamic linker will recheck it.  */
          *namep = NULL;
          return TRUE;
          /* STT_REGISTER only works when linking an elf64_sparc object.
             If STT_REGISTER comes from a dynamic object, don't put it into
             the output bfd.  The dynamic linker will recheck it.  */
          *namep = NULL;
          return TRUE;

-        }
+       }

 
       p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
 
       if (p->name != NULL && strcmp (p->name, *namep))
        {
 
       p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
 
       if (p->name != NULL && strcmp (p->name, *namep))
        {

-          (*_bfd_error_handler)
-            (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
-             abfd, p->abfd, (int) sym->st_value,
-             **namep ? *namep : "#scratch",
-             *p->name ? p->name : "#scratch");
+         _bfd_error_handler
+           /* xgettext:c-format */
+           (_("register %%g%d used incompatibly: %s in %pB,"
+              " previously %s in %pB"),
+            (int) sym->st_value, **namep ? *namep : "#scratch", abfd,
+            *p->name ? p->name : "#scratch", p->abfd);

          return FALSE;
        }
 
          return FALSE;
        }
 


@@ -477,9 +523,11 @@ elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
 
                  if (type > STT_FUNC)
                    type = 0;
 
                  if (type > STT_FUNC)
                    type = 0;

-                 (*_bfd_error_handler)
-                   (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
-                    abfd, p->abfd, *namep, stt_types[type]);
+                 _bfd_error_handler
+                   /* xgettext:c-format */
+                   (_("symbol `%s' has differing types: REGISTER in %pB,"
+                      " previously %s in %pB"),
+                    *namep, abfd, stt_types[type], p->abfd);

                  return FALSE;
                }
 
                  return FALSE;
                }
 


@@ -509,7 +557,7 @@ elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
       return TRUE;
     }
   else if (*namep && **namep
       return TRUE;
     }
   else if (*namep && **namep

-          && info->hash->creator == abfd->xvec)
+          && info->output_bfd->xvec == abfd->xvec)

     {
       int i;
       struct _bfd_sparc_elf_app_reg *p;
     {
       int i;
       struct _bfd_sparc_elf_app_reg *p;


@@ -522,9 +570,11 @@ elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
 
            if (type > STT_FUNC)
              type = 0;
 
            if (type > STT_FUNC)
              type = 0;

-           (*_bfd_error_handler)
-             (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
-              abfd, p->abfd, *namep, stt_types[type]);
+           _bfd_error_handler
+             /* xgettext:c-format */
+             (_("Symbol `%s' has differing types: %s in %pB,"
+                " previously REGISTER in %pB"),
+              *namep, stt_types[type], abfd, p->abfd);

            return FALSE;
          }
     }
            return FALSE;
          }
     }


@@ -537,39 +587,17 @@ elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
 static bfd_boolean
 elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
                              struct bfd_link_info *info,
 static bfd_boolean
 elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
                              struct bfd_link_info *info,

-                             PTR finfo, bfd_boolean (*func) (PTR, const char *,
-                                                             Elf_Internal_Sym *,
-                                                             asection *,
-                                                             struct elf_link_hash_entry *))
+                             void * flaginfo,
+                             int (*func) (void *, const char *,
+                                          Elf_Internal_Sym *,
+                                          asection *,
+                                          struct elf_link_hash_entry *))

 {
   int reg;
   struct _bfd_sparc_elf_app_reg *app_regs =
     _bfd_sparc_elf_hash_table(info)->app_regs;
   Elf_Internal_Sym sym;
 
 {
   int reg;
   struct _bfd_sparc_elf_app_reg *app_regs =
     _bfd_sparc_elf_hash_table(info)->app_regs;
   Elf_Internal_Sym sym;
 

-  /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
-     at the end of the dynlocal list, so they came at the end of the local
-     symbols in the symtab.  Except that they aren't STB_LOCAL, so we need
-     to back up symtab->sh_info.  */
-  if (elf_hash_table (info)->dynlocal)
-    {
-      bfd * dynobj = elf_hash_table (info)->dynobj;
-      asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
-      struct elf_link_local_dynamic_entry *e;
-
-      for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
-       if (e->input_indx == -1)
-         break;
-      if (e)
-       {
-         elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
-           = e->dynindx;
-       }
-    }
-
-  if (info->strip == strip_all)
-    return TRUE;
-

   for (reg = 0; reg < 4; reg++)
     if (app_regs [reg].name != NULL)
       {
   for (reg = 0; reg < 4; reg++)
     if (app_regs [reg].name != NULL)
       {


@@ -584,10 +612,11 @@ elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
        sym.st_other = 0;
        sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
        sym.st_shndx = app_regs [reg].shndx;
        sym.st_other = 0;
        sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
        sym.st_shndx = app_regs [reg].shndx;

-       if (! (*func) (finfo, app_regs [reg].name, &sym,
-                      sym.st_shndx == SHN_ABS
-                        ? bfd_abs_section_ptr : bfd_und_section_ptr,
-                      NULL))
+       sym.st_target_internal = 0;
+       if ((*func) (flaginfo, app_regs [reg].name, &sym,
+                    sym.st_shndx == SHN_ABS
+                    ? bfd_abs_section_ptr : bfd_und_section_ptr,
+                    NULL) != 1)

          return FALSE;
       }
 
          return FALSE;
       }
 


@@ -626,8 +655,9 @@ elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
    object file when linking.  */
 
 static bfd_boolean
    object file when linking.  */
 
 static bfd_boolean

-elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+elf64_sparc_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)

 {
 {

+  bfd *obfd = info->output_bfd;

   bfd_boolean error;
   flagword new_flags, old_flags;
   int new_mm, old_mm;
   bfd_boolean error;
   flagword new_flags, old_flags;
   int new_mm, old_mm;


@@ -648,7 +678,7 @@ elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
   else if (new_flags == old_flags)      /* Compatible flags are ok */
     ;
 
   else if (new_flags == old_flags)      /* Compatible flags are ok */
     ;
 

-  else                                  /* Incompatible flags */
+  else                                 /* Incompatible flags */

     {
       error = FALSE;
 
     {
       error = FALSE;
 


@@ -673,8 +703,8 @@ elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
              && (old_flags & EF_SPARC_HAL_R1))
            {
              error = TRUE;
              && (old_flags & EF_SPARC_HAL_R1))
            {
              error = TRUE;

-             (*_bfd_error_handler)
-               (_("%B: linking UltraSPARC specific with HAL specific code"),
+             _bfd_error_handler
+               (_("%pB: linking UltraSPARC specific with HAL specific code"),

                 ibfd);
            }
          /* Choose the most restrictive memory ordering.  */
                 ibfd);
            }
          /* Choose the most restrictive memory ordering.  */


@@ -690,22 +720,23 @@ elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 
       /* Warn about any other mismatches */
       if (new_flags != old_flags)
 
       /* Warn about any other mismatches */
       if (new_flags != old_flags)

-        {
-          error = TRUE;
-          (*_bfd_error_handler)
-            (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
-             ibfd, (long) new_flags, (long) old_flags);
-        }
+       {
+         error = TRUE;
+         _bfd_error_handler
+           /* xgettext:c-format */
+           (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
+            ibfd, new_flags, old_flags);
+       }

 
       elf_elfheader (obfd)->e_flags = old_flags;
 
       if (error)
 
       elf_elfheader (obfd)->e_flags = old_flags;
 
       if (error)

-        {
-          bfd_set_error (bfd_error_bad_value);
-          return FALSE;
-        }
+       {
+         bfd_set_error (bfd_error_bad_value);
+         return FALSE;
+       }

     }
     }

-  return TRUE;
+  return _bfd_sparc_elf_merge_private_bfd_data (ibfd, info);

 }
 
 /* MARCO: Set the correct entry size for the .stab section.  */
 }
 
 /* MARCO: Set the correct entry size for the .stab section.  */


@@ -717,7 +748,7 @@ elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
 {
   const char *name;
 
 {
   const char *name;
 

-  name = bfd_get_section_name (abfd, sec);
+  name = bfd_section_name (sec);

 
   if (strcmp (name, ".stab") == 0)
     {
 
   if (strcmp (name, ".stab") == 0)
     {


@@ -731,7 +762,7 @@ elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
 /* Print a STT_REGISTER symbol to file FILE.  */
 
 static const char *
 /* Print a STT_REGISTER symbol to file FILE.  */
 
 static const char *

-elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, PTR filep,
+elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep,

                              asymbol *symbol)
 {
   FILE *file = (FILE *) filep;
                              asymbol *symbol)
 {
   FILE *file = (FILE *) filep;


@@ -746,19 +777,52 @@ elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, PTR filep,
   fprintf (file, "REG_%c%c%11s%c%c    R", "GOLI" [reg / 8], '0' + (reg & 7), "",
                 ((type & BSF_LOCAL)
                  ? (type & BSF_GLOBAL) ? '!' : 'l'
   fprintf (file, "REG_%c%c%11s%c%c    R", "GOLI" [reg / 8], '0' + (reg & 7), "",
                 ((type & BSF_LOCAL)
                  ? (type & BSF_GLOBAL) ? '!' : 'l'

-                 : (type & BSF_GLOBAL) ? 'g' : ' '),
-                (type & BSF_WEAK) ? 'w' : ' ');
+                 : (type & BSF_GLOBAL) ? 'g' : ' '),
+                (type & BSF_WEAK) ? 'w' : ' ');

   if (symbol->name == NULL || symbol->name [0] == '\0')
     return "#scratch";
   else
     return symbol->name;
 }
 \f
   if (symbol->name == NULL || symbol->name [0] == '\0')
     return "#scratch";
   else
     return symbol->name;
 }
 \f

+/* Used to decide how to sort relocs in an optimal manner for the
+   dynamic linker, before writing them out.  */
+

 static enum elf_reloc_type_class
 static enum elf_reloc_type_class

-elf64_sparc_reloc_type_class (const Elf_Internal_Rela *rela)
+elf64_sparc_reloc_type_class (const struct bfd_link_info *info,
+                             const asection *rel_sec ATTRIBUTE_UNUSED,
+                             const Elf_Internal_Rela *rela)

 {
 {

+  bfd *abfd = info->output_bfd;
+  const struct 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);
+
+  if (htab->elf.dynsym != NULL
+      && htab->elf.dynsym->contents != NULL)
+    {
+      /* Check relocation against STT_GNU_IFUNC symbol if there are
+        dynamic symbols.  */
+      unsigned long r_symndx = htab->r_symndx (rela->r_info);
+      if (r_symndx != STN_UNDEF)
+       {
+         Elf_Internal_Sym sym;
+         if (!bed->s->swap_symbol_in (abfd,
+                                      (htab->elf.dynsym->contents
+                                       + r_symndx * bed->s->sizeof_sym),
+                                      0, &sym))
+           abort ();
+
+         if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
+           return reloc_class_ifunc;
+       }
+    }
+

   switch ((int) ELF64_R_TYPE (rela->r_info))
     {
   switch ((int) ELF64_R_TYPE (rela->r_info))
     {

+    case R_SPARC_IRELATIVE:
+      return reloc_class_ifunc;

     case R_SPARC_RELATIVE:
       return reloc_class_relative;
     case R_SPARC_JMP_SLOT:
     case R_SPARC_RELATIVE:
       return reloc_class_relative;
     case R_SPARC_JMP_SLOT:


@@ -797,6 +861,7 @@ const struct elf_size_info elf64_sparc_size_info =
   EV_CURRENT,
   bfd_elf64_write_out_phdrs,
   bfd_elf64_write_shdrs_and_ehdr,
   EV_CURRENT,
   bfd_elf64_write_out_phdrs,
   bfd_elf64_write_shdrs_and_ehdr,

+  bfd_elf64_checksum_contents,

   elf64_sparc_write_relocs,
   bfd_elf64_swap_symbol_in,
   bfd_elf64_swap_symbol_out,
   elf64_sparc_write_relocs,
   bfd_elf64_swap_symbol_in,
   bfd_elf64_swap_symbol_out,


@@ -810,7 +875,7 @@ const struct elf_size_info elf64_sparc_size_info =
   bfd_elf64_swap_reloca_out
 };
 
   bfd_elf64_swap_reloca_out
 };
 

-#define TARGET_BIG_SYM bfd_elf64_sparc_vec
+#define TARGET_BIG_SYM sparc_elf64_vec

 #define TARGET_BIG_NAME        "elf64-sparc"
 #define ELF_ARCH       bfd_arch_sparc
 #define ELF_MAXPAGESIZE 0x100000
 #define TARGET_BIG_NAME        "elf64-sparc"
 #define ELF_ARCH       bfd_arch_sparc
 #define ELF_MAXPAGESIZE 0x100000


@@ -832,6 +897,8 @@ const struct elf_size_info elf64_sparc_size_info =
   elf64_sparc_canonicalize_reloc
 #define bfd_elf64_canonicalize_dynamic_reloc \
   elf64_sparc_canonicalize_dynamic_reloc
   elf64_sparc_canonicalize_reloc
 #define bfd_elf64_canonicalize_dynamic_reloc \
   elf64_sparc_canonicalize_dynamic_reloc

+#define bfd_elf64_set_reloc \
+  elf64_sparc_set_reloc

 #define elf_backend_add_symbol_hook \
   elf64_sparc_add_symbol_hook
 #define elf_backend_get_symbol_type \
 #define elf_backend_add_symbol_hook \
   elf64_sparc_add_symbol_hook
 #define elf_backend_get_symbol_type \


@@ -859,6 +926,8 @@ const struct elf_size_info elf64_sparc_size_info =
   _bfd_sparc_elf_copy_indirect_symbol
 #define bfd_elf64_bfd_reloc_type_lookup \
   _bfd_sparc_elf_reloc_type_lookup
   _bfd_sparc_elf_copy_indirect_symbol
 #define bfd_elf64_bfd_reloc_type_lookup \
   _bfd_sparc_elf_reloc_type_lookup

+#define bfd_elf64_bfd_reloc_name_lookup \
+  _bfd_sparc_elf_reloc_name_lookup

 #define bfd_elf64_bfd_relax_section \
   _bfd_sparc_elf_relax_section
 #define bfd_elf64_new_section_hook \
 #define bfd_elf64_bfd_relax_section \
   _bfd_sparc_elf_relax_section
 #define bfd_elf64_new_section_hook \


@@ -866,6 +935,8 @@ const struct elf_size_info elf64_sparc_size_info =
 
 #define elf_backend_create_dynamic_sections \
   _bfd_sparc_elf_create_dynamic_sections
 
 #define elf_backend_create_dynamic_sections \
   _bfd_sparc_elf_create_dynamic_sections

+#define elf_backend_relocs_compatible \
+  _bfd_elf_relocs_compatible

 #define elf_backend_check_relocs \
   _bfd_sparc_elf_check_relocs
 #define elf_backend_adjust_dynamic_symbol \
 #define elf_backend_check_relocs \
   _bfd_sparc_elf_check_relocs
 #define elf_backend_adjust_dynamic_symbol \


@@ -880,6 +951,8 @@ const struct elf_size_info elf64_sparc_size_info =
   _bfd_sparc_elf_finish_dynamic_symbol
 #define elf_backend_finish_dynamic_sections \
   _bfd_sparc_elf_finish_dynamic_sections
   _bfd_sparc_elf_finish_dynamic_symbol
 #define elf_backend_finish_dynamic_sections \
   _bfd_sparc_elf_finish_dynamic_sections

+#define elf_backend_fixup_symbol \
+  _bfd_sparc_elf_fixup_symbol

 
 #define bfd_elf64_mkobject \
   _bfd_sparc_elf_mkobject
 
 #define bfd_elf64_mkobject \
   _bfd_sparc_elf_mkobject


@@ -887,8 +960,6 @@ const struct elf_size_info elf64_sparc_size_info =
   _bfd_sparc_elf_object_p
 #define elf_backend_gc_mark_hook \
   _bfd_sparc_elf_gc_mark_hook
   _bfd_sparc_elf_object_p
 #define elf_backend_gc_mark_hook \
   _bfd_sparc_elf_gc_mark_hook

-#define elf_backend_gc_sweep_hook \
-  _bfd_sparc_elf_gc_sweep_hook

 #define elf_backend_init_index_section \
   _bfd_elf_init_1_index_section
 
 #define elf_backend_init_index_section \
   _bfd_elf_init_1_index_section
 


@@ -898,6 +969,7 @@ const struct elf_size_info elf64_sparc_size_info =
 #define elf_backend_plt_readonly 0
 #define elf_backend_want_plt_sym 1
 #define elf_backend_got_header_size 8
 #define elf_backend_plt_readonly 0
 #define elf_backend_want_plt_sym 1
 #define elf_backend_got_header_size 8

+#define elf_backend_want_dynrelro 1

 #define elf_backend_rela_normal 1
 
 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table.  */
 #define elf_backend_rela_normal 1
 
 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table.  */


@@ -907,30 +979,34 @@ const struct elf_size_info elf64_sparc_size_info =
 
 /* FreeBSD support */
 #undef  TARGET_BIG_SYM
 
 /* FreeBSD support */
 #undef  TARGET_BIG_SYM

-#define TARGET_BIG_SYM bfd_elf64_sparc_freebsd_vec
+#define TARGET_BIG_SYM sparc_elf64_fbsd_vec

 #undef  TARGET_BIG_NAME
 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
 #undef  TARGET_BIG_NAME
 #define TARGET_BIG_NAME "elf64-sparc-freebsd"

+#undef ELF_OSABI
+#define        ELF_OSABI ELFOSABI_FREEBSD

 
 

-/* The kernel recognizes executables as valid only if they carry a
-   "FreeBSD" label in the ELF header.  So we put this label on all
-   executables and (for simplicity) also all other object files.  */
+#undef  elf64_bed
+#define elf64_bed                              elf64_sparc_fbsd_bed

 
 

-static void
-elf64_sparc_fbsd_post_process_headers (bfd *abfd,
-                                       struct bfd_link_info *info ATTRIBUTE_UNUSED)
-{
-  Elf_Internal_Ehdr *i_ehdrp;  /* ELF file header, internal form.  */
+#include "elf64-target.h"

 
 

-  i_ehdrp = elf_elfheader (abfd);
+/* Solaris 2.  */

 
 

-  /* Put an ABI label supported by FreeBSD >= 4.1 */
-  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
-}
+#undef TARGET_BIG_SYM
+#define        TARGET_BIG_SYM                          sparc_elf64_sol2_vec
+#undef TARGET_BIG_NAME
+#define        TARGET_BIG_NAME                         "elf64-sparc-sol2"

 
 

-#undef  elf_backend_post_process_headers
-#define elf_backend_post_process_headers       elf64_sparc_fbsd_post_process_headers
-#undef  elf64_bed
-#define elf64_bed                              elf64_sparc_fbsd_bed
+/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
+   objects won't be recognized.  */
+#undef ELF_OSABI

 
 

-#include "elf64-target.h"
+#undef elf64_bed
+#define elf64_bed                              elf64_sparc_sol2_bed
+
+/* The 64-bit static TLS arena size is rounded to the nearest 16-byte
+   boundary.  */
+#undef elf_backend_static_tls_alignment
+#define elf_backend_static_tls_alignment       16

 
 

+#include "elf64-target.h"