/* ELF linking support for BFD.

   Copyright (C) 1995-2026 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

   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,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   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.  */

#include "sysdep.h"

#include "bfd.h"

#include "bfdlink.h"

#include "libbfd.h"

#define ARCH_SIZE 0

#include "elf-bfd.h"

#include "sframe-api.h"

#include "safe-ctype.h"

#include "libiberty.h"

#include "objalloc.h"

#include "plugin.h"

#include <limits.h>

#ifndef CHAR_BIT

#define CHAR_BIT 8

#endif

/* This struct is used to pass information to routines called via

   elf_link_hash_traverse which must return failure.  */

struct elf_info_failed

{

  struct bfd_link_info *info;

  bool failed;

};

static bool _bfd_elf_fix_symbol_flags

  (struct elf_link_hash_entry *, struct elf_info_failed *);

/* Return false if linker should avoid caching relocation information

   and symbol tables of input files in memory.  */

static bool

_bfd_elf_link_keep_memory (struct bfd_link_info *info)

{

#ifdef USE_MMAP

  /* Don't cache symbol nor relocation tables if they are mapped in.

     NB: Since the --no-keep-memory linker option causes:

     https://sourceware.org/bugzilla/show_bug.cgi?id=31458

     this is opt-in by each backend.  */

  elf_backend_data *obed = get_elf_backend_data (info->output_bfd);

  if (obed->use_mmap)

    return false;

#endif

  bfd *abfd;

  bfd_size_type size;

  if (!info->keep_memory)

    return false;

  if (info->max_cache_size == (bfd_size_type) -1)

    return true;

  abfd = info->input_bfds;

  size = info->cache_size;

  do

    {

      if (size >= info->max_cache_size)

  {

    /* Over the limit.  Reduce the memory usage.  */

    info->keep_memory = false;

    return false;

  }

      if (!abfd)

  break;

      size += abfd->alloc_size;

      abfd = abfd->link.next;

    }

  while (1);

  return true;

}

struct elf_link_hash_entry *

_bfd_elf_get_link_hash_entry (struct elf_link_hash_entry **sym_hashes,

            unsigned int symndx,

            unsigned int ext_sym_start,

            unsigned int num_sym)

{

  if (sym_hashes == NULL

      /* Guard against corrupt input.  See PR 32636 for an example.  */

      || symndx < ext_sym_start

      || symndx >= num_sym)

    return NULL;

  struct elf_link_hash_entry *h = sym_hashes[symndx - ext_sym_start];

  /* The hash might be empty when bad_symtab.  Also see PR32641.  */

  if (h == NULL)

    return NULL;

  while (h->root.type == bfd_link_hash_indirect

   || h->root.type == bfd_link_hash_warning)

    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  return h;

}

static struct elf_link_hash_entry *

get_ext_sym_hash_from_cookie (struct elf_reloc_cookie *cookie,

            unsigned int symndx)

{

  if (cookie == NULL)

    return NULL;

  return _bfd_elf_get_link_hash_entry (elf_sym_hashes (cookie->abfd), symndx,

               cookie->extsymoff, cookie->num_sym);

}

asection *

_bfd_get_local_sym_section (struct elf_reloc_cookie *cookie,

          unsigned int symndx)

{

  if (symndx >= cookie->locsymcount)

    return NULL;

  bfd *abfd = cookie->abfd;

  if (elf_loc_shndx (abfd) == NULL)

    {

      Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);

      Elf_Internal_Sym *locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,

              cookie->locsymcount, 0,

              NULL, NULL, NULL);

      if (locsyms == NULL)

  return NULL;

      unsigned int *loc_shndx

  = bfd_alloc (abfd, cookie->locsymcount * sizeof (*loc_shndx));

      if (loc_shndx == NULL)

  return NULL;

      elf_loc_shndx (abfd) = loc_shndx;

      for (unsigned int i = 0; i < cookie->locsymcount; i++)

  {

    loc_shndx[i] = locsyms[i].st_shndx;

    if (ELF_ST_BIND (locsyms[i].st_info) != STB_LOCAL)

      loc_shndx[i] = SHN_BAD;

  }

      free (locsyms);

    }

  return bfd_section_from_elf_index (abfd, elf_loc_shndx (abfd)[symndx]);

}

asection *

_bfd_elf_section_for_symbol (struct elf_reloc_cookie *cookie,

           unsigned long r_symndx)

{

  struct elf_link_hash_entry *h;

  h = get_ext_sym_hash_from_cookie (cookie, r_symndx);

  if (h != NULL)

    {

      if (h->root.type == bfd_link_hash_defined

    || h->root.type == bfd_link_hash_defweak)

  return h->root.u.def.section;

      else

  return NULL;

    }

  return _bfd_get_local_sym_section (cookie, r_symndx);

}

/* Define a symbol in a dynamic linkage section.  */

struct elf_link_hash_entry *

_bfd_elf_define_linkage_sym (bfd *dynobj,

           struct bfd_link_info *info,

           asection *sec,

           const char *name)

{

  struct elf_link_hash_entry *h;

  struct bfd_link_hash_entry *bh;

  elf_backend_data *obed;

  h = elf_link_hash_lookup (elf_hash_table (info), name, false, false, false);

  if (h != NULL)

    {

      /* Zap symbol defined in an as-needed lib that wasn't linked.

   This is a symptom of a larger problem:  Absolute symbols

   defined in shared libraries can't be overridden, because we

   lose the link to the bfd which is via the symbol section.  */

      h->root.type = bfd_link_hash_new;

      bh = &h->root;

    }

  else

    bh = NULL;

  obed = get_elf_backend_data (dynobj);

  if (!_bfd_generic_link_add_one_symbol (info, dynobj, name, BSF_GLOBAL,

           sec, 0, NULL, false, obed->collect,

           &bh))

    return NULL;

  h = (struct elf_link_hash_entry *) bh;

  BFD_ASSERT (h != NULL);

  h->def_regular = 1;

  h->non_elf = 0;

  h->root.linker_def = 1;

  h->type = STT_OBJECT;

  if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)

    h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;

  obed->elf_backend_hide_symbol (info, h, true);

  return h;

}

bool

_bfd_elf_create_got_section (bfd *dynobj, struct bfd_link_info *info)

{

  flagword flags;

  asection *s;

  struct elf_link_hash_entry *h;

  elf_backend_data *obed = get_elf_backend_data (dynobj);

  struct elf_link_hash_table *htab = elf_hash_table (info);

  /* This function may be called more than once.  */

  if (htab->sgot != NULL)

    return true;

  flags = obed->dynamic_sec_flags;

  s = bfd_make_section_anyway_with_flags (dynobj, ".got", flags);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

  htab->sgot = s;

  if (obed->want_got_plt)

    {

      s = bfd_make_section_anyway_with_flags (dynobj, ".got.plt", flags);

      if (s == NULL

    || !bfd_set_section_alignment (s, obed->s->log_file_align))

  return false;

      htab->sgotplt = s;

    }

  /* The first bit of the global offset table is the header.  */

  s->size += obed->got_header_size;

  if (obed->want_got_sym)

    {

      /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got

   (or .got.plt) section.  We don't do this in the linker script

   because we don't want to define the symbol if we are not creating

   a global offset table.  */

      h = _bfd_elf_define_linkage_sym (dynobj, info, s,

               "_GLOBAL_OFFSET_TABLE_");

      elf_hash_table (info)->hgot = h;

      if (h == NULL)

  return false;

    }

  s = bfd_make_section_anyway_with_flags (dynobj,

            (obed->rela_plts_and_copies_p

             ? ".rela.got" : ".rel.got"),

            flags | SEC_READONLY);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

  htab->srelgot = s;

  return true;

}

/* Return true if IBFD is compatible with the output.  Used for example

   to decide whether an object file can hold linker generated dynamic

   sections, and whether object file relocations can be examined by

   check_relocs (for plt/got/dyn reloc generation).  */

static bool

compatible_format (struct bfd_link_info *info, bfd *ibfd)

{

  return (bfd_get_flavour (ibfd) == bfd_target_elf_flavour

    && is_elf_hash_table (info->hash)

    && elf_object_id (ibfd) == elf_hash_table_id (elf_hash_table (info))

    && !(ibfd->sections != NULL

         && ibfd->sections->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)

    && (get_elf_backend_data (ibfd)

        ->relocs_compatible (ibfd->xvec, info->output_bfd->xvec)));

}

/* Find a suitable object for attaching dynamic sections.  */

bfd *

_bfd_elf_link_dynobj_internal (struct bfd_link_info *info, bool report)

{

  struct elf_link_hash_table *htab = elf_hash_table (info);

  BFD_ASSERT (htab->dynobj != NULL);

  if (htab->dynobj == NULL)

    {

      /* We need to find an input file of the same format as the

   output to hold linker created sections.  */

      bfd *ibfd;

      for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)

  if (compatible_format (info, ibfd))

    break;

      if (ibfd == NULL && report)

  _bfd_error_handler (_("no %s input object found"),

          bfd_get_target (info->output_bfd));

      htab->dynobj = ibfd;

    }

  return htab->dynobj;

}

/* Return the strtab for dynamic symbol names.  Create it if

   necessary.  */

static struct elf_strtab_hash *

_bfd_elf_link_dynstr (struct bfd_link_info *info)

{

  struct elf_link_hash_table *htab = elf_hash_table (info);

  if (htab->dynstr == NULL)

    htab->dynstr = _bfd_elf_strtab_init ();

  return htab->dynstr;

}

/* Create some sections which will be filled in with dynamic linking

   information.  The dynamic sections take up virtual memory space

   when the final executable is run, so we need to create them before

   addresses are assigned to the output sections.  We work out the

   actual contents and size of these sections later.  */

bool

bfd_elf_link_create_dynamic_sections (struct bfd_link_info *info)

{

  flagword flags;

  asection *s;

  bfd *dynobj;

  elf_backend_data *obed;

  struct elf_link_hash_entry *h;

  if (! is_elf_hash_table (info->hash))

    return false;

  if (elf_hash_table (info)->dynamic_sections_created)

    return true;

  if (!_bfd_elf_link_dynstr (info))

    return false;

  dynobj = _bfd_elf_link_dynobj (info);

  if (dynobj == NULL)

    return false;

  obed = get_elf_backend_data (dynobj);

  flags = obed->dynamic_sec_flags;

  /* A dynamically linked executable has a .interp section, but a

     shared library does not.  */

  if (bfd_link_executable (info) && !info->nointerp)

    {

      s = bfd_make_section_anyway_with_flags (dynobj, ".interp",

                flags | SEC_READONLY);

      if (s == NULL)

  return false;

      elf_hash_table (info)->interp = s;

    }

  /* Create sections to hold version informations.  These are removed

     if they are not needed.  */

  s = bfd_make_section_anyway_with_flags (dynobj, ".gnu.version_d",

            flags | SEC_READONLY);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

  s = bfd_make_section_anyway_with_flags (dynobj, ".gnu.version",

            flags | SEC_READONLY);

  if (s == NULL

      || !bfd_set_section_alignment (s, 1))

    return false;

  s = bfd_make_section_anyway_with_flags (dynobj, ".gnu.version_r",

            flags | SEC_READONLY);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

  s = bfd_make_section_anyway_with_flags (dynobj, ".dynsym",

            flags | SEC_READONLY);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

  elf_hash_table (info)->dynsym = s;

  s = bfd_make_section_anyway_with_flags (dynobj, ".dynstr",

            flags | SEC_READONLY);

  if (s == NULL)

    return false;

  s = bfd_make_section_anyway_with_flags (dynobj, ".dynamic", flags);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

  elf_hash_table (info)->dynamic = s;

  /* The special symbol _DYNAMIC is always set to the start of the

     .dynamic section.  We could set _DYNAMIC in a linker script, but we

     only want to define it if we are, in fact, creating a .dynamic

     section.  We don't want to define it if there is no .dynamic

     section, since on some ELF platforms the start up code examines it

     to decide how to initialize the process.  */

  h = _bfd_elf_define_linkage_sym (dynobj, info, s, "_DYNAMIC");

  elf_hash_table (info)->hdynamic = h;

  if (h == NULL)

    return false;

  if (info->emit_hash)

    {

      s = bfd_make_section_anyway_with_flags (dynobj, ".hash",

                flags | SEC_READONLY);

      if (s == NULL

    || !bfd_set_section_alignment (s, obed->s->log_file_align))

  return false;

      elf_section_data (s)->this_hdr.sh_entsize = obed->s->sizeof_hash_entry;

    }

  if (info->emit_gnu_hash && obed->record_xhash_symbol == NULL)

    {

      s = bfd_make_section_anyway_with_flags (dynobj, ".gnu.hash",

                flags | SEC_READONLY);

      if (s == NULL

    || !bfd_set_section_alignment (s, obed->s->log_file_align))

  return false;

      /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:

   4 32-bit words followed by variable count of 64-bit words, then

   variable count of 32-bit words.  */

      if (obed->s->arch_size == 64)

  elf_section_data (s)->this_hdr.sh_entsize = 0;

      else

  elf_section_data (s)->this_hdr.sh_entsize = 4;

    }

  if (info->enable_dt_relr)

    {

      s = bfd_make_section_anyway_with_flags (dynobj, ".relr.dyn",

                flags | SEC_READONLY);

      if (s == NULL

    || !bfd_set_section_alignment (s, obed->s->log_file_align))

  return false;

      elf_hash_table (info)->srelrdyn = s;

    }

  /* Let the backend create the rest of the sections.  This lets the

     backend set the right flags.  The backend will normally create

     the .got and .plt sections.  */

  if (obed->elf_backend_create_dynamic_sections == NULL

      || !obed->elf_backend_create_dynamic_sections (dynobj, info))

    return false;

  elf_hash_table (info)->dynamic_sections_created = true;

  return true;

}

/* Create dynamic sections when linking against a dynamic object.  */

bool

_bfd_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)

{

  flagword flags, pltflags;

  struct elf_link_hash_entry *h;

  asection *s;

  elf_backend_data *obed = get_elf_backend_data (dynobj);

  struct elf_link_hash_table *htab = elf_hash_table (info);

  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and

     .rel[a].bss sections.  */

  flags = obed->dynamic_sec_flags;

  pltflags = flags;

  if (obed->plt_not_loaded)

    /* We do not clear SEC_ALLOC here because we still want the OS to

       allocate space for the section; it's just that there's nothing

       to read in from the object file.  */

    pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);

  else

    pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;

  if (obed->plt_readonly)

    pltflags |= SEC_READONLY;

  s = bfd_make_section_anyway_with_flags (dynobj, ".plt", pltflags);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->plt_alignment))

    return false;

  htab->splt = s;

  /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the

     .plt section.  */

  if (obed->want_plt_sym)

    {

      h = _bfd_elf_define_linkage_sym (dynobj, info, s,

               "_PROCEDURE_LINKAGE_TABLE_");

      elf_hash_table (info)->hplt = h;

      if (h == NULL)

  return false;

    }

  s = bfd_make_section_anyway_with_flags (dynobj,

            (obed->rela_plts_and_copies_p

             ? ".rela.plt" : ".rel.plt"),

            flags | SEC_READONLY);

  if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

  htab->srelplt = s;

  if (! _bfd_elf_create_got_section (dynobj, info))

    return false;

  if (obed->want_dynbss)

    {

      /* The .dynbss section is a place to put symbols which are defined

   by dynamic objects, are referenced by regular objects, and are

   not functions.  We must allocate space for them in the process

   image and use a R_*_COPY reloc to tell the dynamic linker to

   initialize them at run time.  The linker script puts the .dynbss

   section into the .bss section of the final image.  */

      s = bfd_make_section_anyway_with_flags (dynobj, ".dynbss",

                SEC_ALLOC | SEC_LINKER_CREATED);

      if (s == NULL)

  return false;

      htab->sdynbss = s;

      if (obed->want_dynrelro)

  {

    /* Similarly, but for symbols that were originally in read-only

       sections.  This section doesn't really need to have contents,

       but make it like other .data.rel.ro sections.  */

    s = bfd_make_section_anyway_with_flags (dynobj, ".data.rel.ro",

              flags);

    if (s == NULL)

      return false;

    htab->sdynrelro = s;

  }

      /* The .rel[a].bss section holds copy relocs.  This section is not

   normally needed.  We need to create it here, though, so that the

   linker will map it to an output section.  We can't just create it

   only if we need it, because we will not know whether we need it

   until we have seen all the input files, and the first time the

   main linker code calls BFD after examining all the input files

   (size_dynamic_sections) the input sections have already been

   mapped to the output sections.  If the section turns out not to

   be needed, we can discard it later.  We will never need this

   section when generating a shared object, since they do not use

   copy relocs.  */

      if (bfd_link_executable (info))

  {

    s = bfd_make_section_anyway_with_flags (dynobj,

              (obed->rela_plts_and_copies_p

               ? ".rela.bss" : ".rel.bss"),

              flags | SEC_READONLY);

    if (s == NULL

        || !bfd_set_section_alignment (s, obed->s->log_file_align))

      return false;

    htab->srelbss = s;

    if (obed->want_dynrelro)

      {

        s = (bfd_make_section_anyway_with_flags

       (dynobj, (obed->rela_plts_and_copies_p

           ? ".rela.data.rel.ro" : ".rel.data.rel.ro"),

        flags | SEC_READONLY));

        if (s == NULL

      || !bfd_set_section_alignment (s, obed->s->log_file_align))

    return false;

        htab->sreldynrelro = s;

      }

  }

    }

  return true;

}

/* Record a new dynamic symbol.  We record the dynamic symbols as we

   read the input files, since we need to have a list of all of them

   before we can determine the final sizes of the output sections.

   Note that we may actually call this function even though we are not

   going to output any dynamic symbols; in some cases we know that a

   symbol should be in the dynamic symbol table, but only if there is

   one.  */

bool

bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,

            struct elf_link_hash_entry *h)

{

  if (h->dynindx == -1)

    {

      struct elf_strtab_hash *dynstr;

      const char *p;

      const char *name;

      size_t indx;

      if (h->root.type == bfd_link_hash_defined

    || h->root.type == bfd_link_hash_defweak)

  {

    /* An IR symbol should not be made dynamic.  */

    if (h->root.u.def.section != NULL

        && h->root.u.def.section->owner != NULL

        && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)

      return true;

  }

      /* XXX: The ABI draft says the linker must turn hidden and

   internal symbols into STB_LOCAL symbols when producing the

   DSO. However, if ld.so honors st_other in the dynamic table,

   this would not be necessary.  */

      switch (ELF_ST_VISIBILITY (h->other))

  {

  case STV_INTERNAL:

  case STV_HIDDEN:

    if (h->root.type != bfd_link_hash_undefined

        && h->root.type != bfd_link_hash_undefweak)

      {

        h->forced_local = 1;

        return true;

      }

  default:

    break;

  }

      h->dynindx = elf_hash_table (info)->dynsymcount;

      if (h->forced_local)

  elf_hash_table (info)->has_local_dynsyms = true;

      ++elf_hash_table (info)->dynsymcount;

      dynstr = _bfd_elf_link_dynstr (info);

      if (dynstr == NULL)

  return false;

      char *unversioned_name = NULL;

      /* We don't put any version information in the dynamic string

   table.  */

      name = h->root.root.string;

      p = strchr (name, ELF_VER_CHR);

      if (p != NULL)

  {

    unversioned_name = bfd_malloc (p - name + 1);

    if (unversioned_name == NULL)

      return false;

    memcpy (unversioned_name, name, p - name);

    unversioned_name[p - name] = 0;

    name = unversioned_name;

  }

      indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);

      if (p != NULL)

  free (unversioned_name);

      if (indx == (size_t) -1)

  return false;

      h->dynstr_index = indx;

    }

  return true;

}

/* Mark a symbol dynamic.  */

static void

bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,

          struct elf_link_hash_entry *h,

          Elf_Internal_Sym *sym)

{

  struct bfd_elf_dynamic_list *d = info->dynamic_list;

  /* It may be called more than once on the same H.  */

  if(h->dynamic || bfd_link_relocatable (info))

    return;

  if ((info->dynamic_data

       && (h->type == STT_OBJECT

     || h->type == STT_COMMON

     || (sym != NULL

         && (ELF_ST_TYPE (sym->st_info) == STT_OBJECT

       || ELF_ST_TYPE (sym->st_info) == STT_COMMON))))

      || (d != NULL

    && h->non_elf

    && (*d->match) (&d->head, NULL, h->root.root.string)))

    {

      h->dynamic = 1;

      /* NB: If a symbol is made dynamic by --dynamic-list, it has

   non-IR reference.  */

      h->root.non_ir_ref_dynamic = 1;

    }

}

/* Record an assignment to a symbol made by a linker script.  We need

   this in case some dynamic object refers to this symbol.  */

bool

bfd_elf_record_link_assignment (struct bfd_link_info *info,

        const char *name,

        bool provide,

        bool hidden)

{

  struct elf_link_hash_entry *h, *hv;

  struct elf_link_hash_table *htab;

  elf_backend_data *obed;

  if (!is_elf_hash_table (info->hash))

    return true;

  htab = elf_hash_table (info);

  h = elf_link_hash_lookup (htab, name, !provide, true, false);

  if (h == NULL)

    return provide;

  if (h->root.type == bfd_link_hash_warning)

    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  if (h->versioned == unknown)

    {

      /* Set versioned if symbol version is unknown.  */

      const char *version = strrchr (name, ELF_VER_CHR);

      if (version)

  {

    if (version > name && version[-1] != ELF_VER_CHR)

      h->versioned = versioned_hidden;

    else

      h->versioned = versioned;

  }

    }

  /* Symbols defined in a linker script but not referenced anywhere

     else will have non_elf set.  */

  if (h->non_elf)

    {

      bfd_elf_link_mark_dynamic_symbol (info, h, NULL);

      h->non_elf = 0;

    }

  switch (h->root.type)

    {

    case bfd_link_hash_defined:

    case bfd_link_hash_defweak:

    case bfd_link_hash_common:

      break;

    case bfd_link_hash_undefweak:

    case bfd_link_hash_undefined:

      /* Since we're defining the symbol, don't let it seem to have not

   been defined.  record_dynamic_symbol and size_dynamic_sections

   may depend on this.  */

      h->root.type = bfd_link_hash_new;

      if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)

  bfd_link_repair_undef_list (&htab->root);

      break;

    case bfd_link_hash_new:

      break;

    case bfd_link_hash_indirect:

      /* We had a versioned symbol in a dynamic library.  We make the

   the versioned symbol point to this one.  */

      obed = get_elf_backend_data (info->output_bfd);

      hv = h;

      while (hv->root.type == bfd_link_hash_indirect

       || hv->root.type == bfd_link_hash_warning)

  hv = (struct elf_link_hash_entry *) hv->root.u.i.link;

      /* We don't need to update h->root.u since linker will set them

   later.  */

      h->root.type = bfd_link_hash_undefined;

      hv->root.type = bfd_link_hash_indirect;

      hv->root.u.i.link = (struct bfd_link_hash_entry *) h;

      obed->elf_backend_copy_indirect_symbol (info, h, hv);

      break;

    default:

      BFD_FAIL ();

      return false;

    }

  /* If this symbol is being provided by the linker script, and it is

     currently defined by a dynamic object, but not by a regular

     object, then mark it as undefined so that the generic linker will

     force the correct value.  */

  if (provide

      && h->def_dynamic

      && !h->def_regular)

    h->root.type = bfd_link_hash_undefined;

  /* If this symbol is currently defined by a dynamic object, but not

     by a regular object, then clear out any version information because

     the symbol will not be associated with the dynamic object any

     more.  */

  if (h->def_dynamic && !h->def_regular)

    h->verinfo.verdef = NULL;

  /* Make sure this symbol is not garbage collected.  */

  h->mark = 1;

  h->def_regular = 1;

  if (hidden)

    {

      obed = get_elf_backend_data (info->output_bfd);

      if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)

  h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;

      obed->elf_backend_hide_symbol (info, h, true);

    }

  /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects

     and executables.  */

  if (!bfd_link_relocatable (info)

      && h->dynindx != -1

      && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN

    || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))

    h->forced_local = 1;

  if ((h->def_dynamic

       || h->ref_dynamic

       || bfd_link_dll (info))

      && !h->forced_local

      && h->dynindx == -1)

    {

      if (! bfd_elf_link_record_dynamic_symbol (info, h))

  return false;

      /* If this is a weak defined symbol, and we know a corresponding

   real symbol from the same dynamic object, make sure the real

   symbol is also made into a dynamic symbol.  */

      if (h->is_weakalias)

  {

    struct elf_link_hash_entry *def = weakdef (h);

    if (def->dynindx == -1

        && !bfd_elf_link_record_dynamic_symbol (info, def))

      return false;

  }

    }

  return true;

}

/* Record a new local dynamic symbol.  Returns 0 on failure, 1 on

   success, and 2 on a failure caused by attempting to record a symbol

   in a discarded section, eg. a discarded link-once section symbol.  */

int

bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,

            bfd *input_bfd,

            long input_indx)

{

  struct elf_link_local_dynamic_entry *entry;