Changeset 609 for branches/GNU/src/binutils/bfd/elf.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/elf.c (modified) (275 diffs, 1 prop)

branches/GNU/src/binutils/bfd/elf.c

@@ -1 +1 @@
 /* ELF executable support for BFD.
-   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
-   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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-/*
-
-SECTION
+   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+   2003 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/*  SECTION
+
         ELF backends
 
@@ -30 +29 @@
         Documentation of the internals of the support code still needs
         to be written.  The code is changing quickly enough that we
-        haven't bothered yet.
- */
+        haven't bothered yet.  */
 
 /* For sparc64-cross-sparc32.  */
@@ -41 +39 @@
 #define ARCH_SIZE 0
 #include "elf-bfd.h"
+#include "libiberty.h"
 
 static INLINE struct elf_segment_map *make_mapping
-  PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
-static boolean map_sections_to_segments PARAMS ((bfd *));
-static int elf_sort_sections PARAMS ((const PTR, const PTR));
-static boolean assign_file_positions_for_segments PARAMS ((bfd *));
-static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
-static boolean prep_headers PARAMS ((bfd *));
-static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
-static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
-static char *elf_read PARAMS ((bfd *, long, unsigned int));
-static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
-static boolean assign_section_numbers PARAMS ((bfd *));
-static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
-static boolean elf_map_symbols PARAMS ((bfd *));
-static bfd_size_type get_program_header_size PARAMS ((bfd *));
-static boolean elfcore_read_notes PARAMS ((bfd *, bfd_vma, bfd_vma));
-static boolean elf_find_function PARAMS ((bfd *, asection *,
-                                         asymbol **,
-                                         bfd_vma, const char **,
-                                         const char **));
+  PARAMS ((bfd *, asection **, unsigned int, unsigned int, bfd_boolean));
+static bfd_boolean map_sections_to_segments
+  PARAMS ((bfd *));
+static int elf_sort_sections
+  PARAMS ((const PTR, const PTR));
+static bfd_boolean assign_file_positions_for_segments
+  PARAMS ((bfd *));
+static bfd_boolean assign_file_positions_except_relocs
+  PARAMS ((bfd *));
+static bfd_boolean prep_headers
+  PARAMS ((bfd *));
+static bfd_boolean swap_out_syms
+  PARAMS ((bfd *, struct bfd_strtab_hash **, int));
+static bfd_boolean copy_private_bfd_data
+  PARAMS ((bfd *, bfd *));
+static char *elf_read
+  PARAMS ((bfd *, file_ptr, bfd_size_type));
+static const char *group_signature
+  PARAMS ((bfd *, Elf_Internal_Shdr *));
+static bfd_boolean setup_group
+  PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
+static void merge_sections_remove_hook
+  PARAMS ((bfd *, asection *));
+static void elf_fake_sections
+  PARAMS ((bfd *, asection *, PTR));
+static bfd_boolean assign_section_numbers
+  PARAMS ((bfd *));
+static INLINE int sym_is_global
+  PARAMS ((bfd *, asymbol *));
+static bfd_boolean elf_map_symbols
+  PARAMS ((bfd *));
+static bfd_size_type get_program_header_size
+  PARAMS ((bfd *));
+static bfd_boolean elfcore_read_notes
+  PARAMS ((bfd *, file_ptr, bfd_size_type));
+static bfd_boolean elf_find_function
+  PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
+           const char **));
+static int elfcore_make_pid
+  PARAMS ((bfd *));
+static bfd_boolean elfcore_maybe_make_sect
+  PARAMS ((bfd *, char *, asection *));
+static bfd_boolean elfcore_make_note_pseudosection
+  PARAMS ((bfd *, char *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_prfpreg
+  PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_prxfpreg
+  PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_note
+  PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_netbsd_get_lwpid
+  PARAMS ((Elf_Internal_Note *, int *));
+static bfd_boolean elfcore_grok_netbsd_procinfo
+  PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_netbsd_note
+  PARAMS ((bfd *, Elf_Internal_Note *));
+static bfd_boolean elfcore_grok_nto_gregs
+  PARAMS ((bfd *, Elf_Internal_Note *, pid_t));
+static bfd_boolean elfcore_grok_nto_status
+  PARAMS ((bfd *, Elf_Internal_Note *, pid_t *));
+static bfd_boolean elfcore_grok_nto_note
+  PARAMS ((bfd *, Elf_Internal_Note *));
 
 /* Swap version information in and out.  The version information is
@@ -75 +117 @@
      Elf_Internal_Verdef *dst;
 {
-  dst->vd_version = bfd_h_get_16 (abfd, src->vd_version);
-  dst->vd_flags   = bfd_h_get_16 (abfd, src->vd_flags);
-  dst->vd_ndx     = bfd_h_get_16 (abfd, src->vd_ndx);
-  dst->vd_cnt     = bfd_h_get_16 (abfd, src->vd_cnt);
-  dst->vd_hash    = bfd_h_get_32 (abfd, src->vd_hash);
-  dst->vd_aux     = bfd_h_get_32 (abfd, src->vd_aux);
-  dst->vd_next    = bfd_h_get_32 (abfd, src->vd_next);
+  dst->vd_version = H_GET_16 (abfd, src->vd_version);
+  dst->vd_flags   = H_GET_16 (abfd, src->vd_flags);
+  dst->vd_ndx     = H_GET_16 (abfd, src->vd_ndx);
+  dst->vd_cnt     = H_GET_16 (abfd, src->vd_cnt);
+  dst->vd_hash    = H_GET_32 (abfd, src->vd_hash);
+  dst->vd_aux     = H_GET_32 (abfd, src->vd_aux);
+  dst->vd_next    = H_GET_32 (abfd, src->vd_next);
 }
 
@@ -92 +134 @@
      Elf_External_Verdef *dst;
 {
-  bfd_h_put_16 (abfd, src->vd_version, dst->vd_version);
-  bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags);
-  bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx);
-  bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt);
-  bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash);
-  bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux);
-  bfd_h_put_32 (abfd, src->vd_next, dst->vd_next);
+  H_PUT_16 (abfd, src->vd_version, dst->vd_version);
+  H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
+  H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
+  H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
+  H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
+  H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
+  H_PUT_32 (abfd, src->vd_next, dst->vd_next);
 }
 
@@ -109 +151 @@
      Elf_Internal_Verdaux *dst;
 {
-  dst->vda_name = bfd_h_get_32 (abfd, src->vda_name);
-  dst->vda_next = bfd_h_get_32 (abfd, src->vda_next);
+  dst->vda_name = H_GET_32 (abfd, src->vda_name);
+  dst->vda_next = H_GET_32 (abfd, src->vda_next);
 }
 
@@ -121 +163 @@
      Elf_External_Verdaux *dst;
 {
-  bfd_h_put_32 (abfd, src->vda_name, dst->vda_name);
-  bfd_h_put_32 (abfd, src->vda_next, dst->vda_next);
+  H_PUT_32 (abfd, src->vda_name, dst->vda_name);
+  H_PUT_32 (abfd, src->vda_next, dst->vda_next);
 }
 
@@ -133 +175 @@
      Elf_Internal_Verneed *dst;
 {
-  dst->vn_version = bfd_h_get_16 (abfd, src->vn_version);
-  dst->vn_cnt     = bfd_h_get_16 (abfd, src->vn_cnt);
-  dst->vn_file    = bfd_h_get_32 (abfd, src->vn_file);
-  dst->vn_aux     = bfd_h_get_32 (abfd, src->vn_aux);
-  dst->vn_next    = bfd_h_get_32 (abfd, src->vn_next);
+  dst->vn_version = H_GET_16 (abfd, src->vn_version);
+  dst->vn_cnt     = H_GET_16 (abfd, src->vn_cnt);
+  dst->vn_file    = H_GET_32 (abfd, src->vn_file);
+  dst->vn_aux     = H_GET_32 (abfd, src->vn_aux);
+  dst->vn_next    = H_GET_32 (abfd, src->vn_next);
 }
 
@@ -148 +190 @@
      Elf_External_Verneed *dst;
 {
-  bfd_h_put_16 (abfd, src->vn_version, dst->vn_version);
-  bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt);
-  bfd_h_put_32 (abfd, src->vn_file, dst->vn_file);
-  bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux);
-  bfd_h_put_32 (abfd, src->vn_next, dst->vn_next);
+  H_PUT_16 (abfd, src->vn_version, dst->vn_version);
+  H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
+  H_PUT_32 (abfd, src->vn_file, dst->vn_file);
+  H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
+  H_PUT_32 (abfd, src->vn_next, dst->vn_next);
 }
 
@@ -163 +205 @@
      Elf_Internal_Vernaux *dst;
 {
-  dst->vna_hash  = bfd_h_get_32 (abfd, src->vna_hash);
-  dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags);
-  dst->vna_other = bfd_h_get_16 (abfd, src->vna_other);
-  dst->vna_name  = bfd_h_get_32 (abfd, src->vna_name);
-  dst->vna_next  = bfd_h_get_32 (abfd, src->vna_next);
+  dst->vna_hash  = H_GET_32 (abfd, src->vna_hash);
+  dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
+  dst->vna_other = H_GET_16 (abfd, src->vna_other);
+  dst->vna_name  = H_GET_32 (abfd, src->vna_name);
+  dst->vna_next  = H_GET_32 (abfd, src->vna_next);
 }
 
@@ -178 +220 @@
      Elf_External_Vernaux *dst;
 {
-  bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash);
-  bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags);
-  bfd_h_put_16 (abfd, src->vna_other, dst->vna_other);
-  bfd_h_put_32 (abfd, src->vna_name, dst->vna_name);
-  bfd_h_put_32 (abfd, src->vna_next, dst->vna_next);
+  H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
+  H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
+  H_PUT_16 (abfd, src->vna_other, dst->vna_other);
+  H_PUT_32 (abfd, src->vna_name, dst->vna_name);
+  H_PUT_32 (abfd, src->vna_next, dst->vna_next);
 }
 
@@ -193 +235 @@
      Elf_Internal_Versym *dst;
 {
-  dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers);
+  dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
 }
 
@@ -204 +246 @@
      Elf_External_Versym *dst;
 {
-  bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers);
+  H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
 }
 
@@ -230 +272 @@
         }
     }
-  return h;
+  return h & 0xffffffff;
 }
 
@@ -240 +282 @@
 elf_read (abfd, offset, size)
      bfd *abfd;
-     long offset;
-     unsigned int size;
+     file_ptr offset;
+     bfd_size_type size;
 {
   char *buf;
@@ -247 +289 @@
   if ((buf = bfd_alloc (abfd, size)) == NULL)
     return NULL;
-  if (bfd_seek (abfd, offset, SEEK_SET) == -1)
+  if (bfd_seek (abfd, offset, SEEK_SET) != 0)
     return NULL;
-  if (bfd_read ((PTR) buf, size, 1, abfd) != size)
+  if (bfd_bread ((PTR) buf, size, abfd) != size)
     {
       if (bfd_get_error () != bfd_error_system_call)
@@ -258 +300 @@
 }
 
-boolean
+bfd_boolean
 bfd_elf_mkobject (abfd)
      bfd *abfd;
@@ -264 +306 @@
   /* This just does initialization.  */
   /* coff_mkobject zalloc's space for tdata.coff_obj_data ...  */
-  elf_tdata (abfd) = (struct elf_obj_tdata *)
-    bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
+  bfd_size_type amt = sizeof (struct elf_obj_tdata);
+  elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
   if (elf_tdata (abfd) == 0)
-    return false;
+    return FALSE;
   /* Since everything is done at close time, do we need any
      initialization?  */
 
-  return true;
-}
-
-boolean
+  return TRUE;
+}
+
+bfd_boolean
 bfd_elf_mkcorefile (abfd)
      bfd *abfd;
@@ -289 +331 @@
   Elf_Internal_Shdr **i_shdrp;
   char *shstrtab = NULL;
-  unsigned int offset;
-  unsigned int shstrtabsize;
+  file_ptr offset;
+  bfd_size_type shstrtabsize;
 
   i_shdrp = elf_elfsections (abfd);
@@ -329 +371 @@
       (*_bfd_error_handler)
         (_("%s: invalid string offset %u >= %lu for section `%s'"),
-         bfd_get_filename (abfd), strindex, (unsigned long) hdr->sh_size,
+         bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
          ((shindex == elf_elfheader(abfd)->e_shstrndx
            && strindex == hdr->sh_name)
@@ -340 +382 @@
 }
 
+/* Read and convert symbols to internal format.
+   SYMCOUNT specifies the number of symbols to read, starting from
+   symbol SYMOFFSET.  If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
+   are non-NULL, they are used to store the internal symbols, external
+   symbols, and symbol section index extensions, respectively.  */
+
+Elf_Internal_Sym *
+bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, symoffset,
+                      intsym_buf, extsym_buf, extshndx_buf)
+     bfd *ibfd;
+     Elf_Internal_Shdr *symtab_hdr;
+     size_t symcount;
+     size_t symoffset;
+     Elf_Internal_Sym *intsym_buf;
+     PTR extsym_buf;
+     Elf_External_Sym_Shndx *extshndx_buf;
+{
+  Elf_Internal_Shdr *shndx_hdr;
+  PTR alloc_ext;
+  const bfd_byte *esym;
+  Elf_External_Sym_Shndx *alloc_extshndx;
+  Elf_External_Sym_Shndx *shndx;
+  Elf_Internal_Sym *isym;
+  Elf_Internal_Sym *isymend;
+  struct elf_backend_data *bed;
+  size_t extsym_size;
+  bfd_size_type amt;
+  file_ptr pos;
+
+  if (symcount == 0)
+    return intsym_buf;
+
+  /* Normal syms might have section extension entries.  */
+  shndx_hdr = NULL;
+  if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
+    shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
+
+  /* Read the symbols.  */
+  alloc_ext = NULL;
+  alloc_extshndx = NULL;
+  bed = get_elf_backend_data (ibfd);
+  extsym_size = bed->s->sizeof_sym;
+  amt = symcount * extsym_size;
+  pos = symtab_hdr->sh_offset + symoffset * extsym_size;
+  if (extsym_buf == NULL)
+    {
+      alloc_ext = bfd_malloc (amt);
+      extsym_buf = alloc_ext;
+    }
+  if (extsym_buf == NULL
+      || bfd_seek (ibfd, pos, SEEK_SET) != 0
+      || bfd_bread (extsym_buf, amt, ibfd) != amt)
+    {
+      intsym_buf = NULL;
+      goto out;
+    }
+
+  if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
+    extshndx_buf = NULL;
+  else
+    {
+      amt = symcount * sizeof (Elf_External_Sym_Shndx);
+      pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
+      if (extshndx_buf == NULL)
+        {
+          alloc_extshndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
+          extshndx_buf = alloc_extshndx;
+        }
+      if (extshndx_buf == NULL
+          || bfd_seek (ibfd, pos, SEEK_SET) != 0
+          || bfd_bread (extshndx_buf, amt, ibfd) != amt)
+        {
+          intsym_buf = NULL;
+          goto out;
+        }
+    }
+
+  if (intsym_buf == NULL)
+    {
+      bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
+      intsym_buf = (Elf_Internal_Sym *) bfd_malloc (amt);
+      if (intsym_buf == NULL)
+        goto out;
+    }
+
+  /* Convert the symbols to internal form.  */
+  isymend = intsym_buf + symcount;
+  for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
+       isym < isymend;
+       esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
+    (*bed->s->swap_symbol_in) (ibfd, esym, (const PTR) shndx, isym);
+
+ out:
+  if (alloc_ext != NULL)
+    free (alloc_ext);
+  if (alloc_extshndx != NULL)
+    free (alloc_extshndx);
+
+  return intsym_buf;
+}
+
+/* Look up a symbol name.  */
+const char *
+bfd_elf_local_sym_name (abfd, isym)
+     bfd *abfd;
+     Elf_Internal_Sym *isym;
+{
+  unsigned int iname = isym->st_name;
+  unsigned int shindex = elf_tdata (abfd)->symtab_hdr.sh_link;
+  if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION)
+    {
+      iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
+      shindex = elf_elfheader (abfd)->e_shstrndx;
+    }
+
+  return bfd_elf_string_from_elf_section (abfd, shindex, iname);
+}
+
+/* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
+   sections.  The first element is the flags, the rest are section
+   pointers.  */
+
+typedef union elf_internal_group {
+  Elf_Internal_Shdr *shdr;
+  unsigned int flags;
+} Elf_Internal_Group;
+
+/* Return the name of the group signature symbol.  Why isn't the
+   signature just a string?  */
+
+static const char *
+group_signature (abfd, ghdr)
+     bfd *abfd;
+     Elf_Internal_Shdr *ghdr;
+{
+  Elf_Internal_Shdr *hdr;
+  unsigned char esym[sizeof (Elf64_External_Sym)];
+  Elf_External_Sym_Shndx eshndx;
+  Elf_Internal_Sym isym;
+
+  /* First we need to ensure the symbol table is available.  */
+  if (! bfd_section_from_shdr (abfd, ghdr->sh_link))
+    return NULL;
+
+  /* Go read the symbol.  */
+  hdr = &elf_tdata (abfd)->symtab_hdr;
+  if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
+                            &isym, esym, &eshndx) == NULL)
+    return NULL;
+
+  return bfd_elf_local_sym_name (abfd, &isym);
+}
+
+/* Set next_in_group list pointer, and group name for NEWSECT.  */
+
+static bfd_boolean
+setup_group (abfd, hdr, newsect)
+     bfd *abfd;
+     Elf_Internal_Shdr *hdr;
+     asection *newsect;
+{
+  unsigned int num_group = elf_tdata (abfd)->num_group;
+
+  /* If num_group is zero, read in all SHT_GROUP sections.  The count
+     is set to -1 if there are no SHT_GROUP sections.  */
+  if (num_group == 0)
+    {
+      unsigned int i, shnum;
+
+      /* First count the number of groups.  If we have a SHT_GROUP
+         section with just a flag word (ie. sh_size is 4), ignore it.  */
+      shnum = elf_numsections (abfd);
+      num_group = 0;
+      for (i = 0; i < shnum; i++)
+        {
+          Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
+          if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
+            num_group += 1;
+        }
+
+      if (num_group == 0)
+        num_group = (unsigned) -1;
+      elf_tdata (abfd)->num_group = num_group;
+
+      if (num_group > 0)
+        {
+          /* We keep a list of elf section headers for group sections,
+             so we can find them quickly.  */
+          bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
+          elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
+          if (elf_tdata (abfd)->group_sect_ptr == NULL)
+            return FALSE;
+
+          num_group = 0;
+          for (i = 0; i < shnum; i++)
+            {
+              Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
+              if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
+                {
+                  unsigned char *src;
+                  Elf_Internal_Group *dest;
+
+                  /* Add to list of sections.  */
+                  elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
+                  num_group += 1;
+
+                  /* Read the raw contents.  */
+                  BFD_ASSERT (sizeof (*dest) >= 4);
+                  amt = shdr->sh_size * sizeof (*dest) / 4;
+                  shdr->contents = bfd_alloc (abfd, amt);
+                  if (shdr->contents == NULL
+                      || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
+                      || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
+                          != shdr->sh_size))
+                    return FALSE;
+
+                  /* Translate raw contents, a flag word followed by an
+                     array of elf section indices all in target byte order,
+                     to the flag word followed by an array of elf section
+                     pointers.  */
+                  src = shdr->contents + shdr->sh_size;
+                  dest = (Elf_Internal_Group *) (shdr->contents + amt);
+                  while (1)
+                    {
+                      unsigned int idx;
+
+                      src -= 4;
+                      --dest;
+                      idx = H_GET_32 (abfd, src);
+                      if (src == shdr->contents)
+                        {
+                          dest->flags = idx;
+                          if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
+                            shdr->bfd_section->flags
+                              |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
+                          break;
+                        }
+                      if (idx >= shnum)
+                        {
+                          ((*_bfd_error_handler)
+                           (_("%s: invalid SHT_GROUP entry"),
+                            bfd_archive_filename (abfd)));
+                          idx = 0;
+                        }
+                      dest->shdr = elf_elfsections (abfd)[idx];
+                    }
+                }
+            }
+        }
+    }
+
+  if (num_group != (unsigned) -1)
+    {
+      unsigned int i;
+
+      for (i = 0; i < num_group; i++)
+        {
+          Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
+          Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
+          unsigned int n_elt = shdr->sh_size / 4;
+
+          /* Look through this group's sections to see if current
+             section is a member.  */
+          while (--n_elt != 0)
+            if ((++idx)->shdr == hdr)
+              {
+                asection *s = NULL;
+
+                /* We are a member of this group.  Go looking through
+                   other members to see if any others are linked via
+                   next_in_group.  */
+                idx = (Elf_Internal_Group *) shdr->contents;
+                n_elt = shdr->sh_size / 4;
+                while (--n_elt != 0)
+                  if ((s = (++idx)->shdr->bfd_section) != NULL
+                      && elf_next_in_group (s) != NULL)
+                    break;
+                if (n_elt != 0)
+                  {
+                    /* Snarf the group name from other member, and
+                       insert current section in circular list.  */
+                    elf_group_name (newsect) = elf_group_name (s);
+                    elf_next_in_group (newsect) = elf_next_in_group (s);
+                    elf_next_in_group (s) = newsect;
+                  }
+                else
+                  {
+                    const char *gname;
+
+                    gname = group_signature (abfd, shdr);
+                    if (gname == NULL)
+                      return FALSE;
+                    elf_group_name (newsect) = gname;
+
+                    /* Start a circular list with one element.  */
+                    elf_next_in_group (newsect) = newsect;
+                  }
+
+                /* If the group section has been created, point to the
+                   new member.  */
+                if (shdr->bfd_section != NULL)
+                  elf_next_in_group (shdr->bfd_section) = newsect;
+
+                i = num_group - 1;
+                break;
+              }
+        }
+    }
+
+  if (elf_group_name (newsect) == NULL)
+    {
+      (*_bfd_error_handler) (_("%s: no group info for section %s"),
+                             bfd_archive_filename (abfd), newsect->name);
+    }
+  return TRUE;
+}
+
+bfd_boolean
+bfd_elf_discard_group (abfd, group)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     asection *group;
+{
+  asection *first = elf_next_in_group (group);
+  asection *s = first;
+
+  while (s != NULL)
+    {
+      s->output_section = bfd_abs_section_ptr;
+      s = elf_next_in_group (s);
+      /* These lists are circular.  */
+      if (s == first)
+        break;
+    }
+  return TRUE;
+}
+
 /* Make a BFD section from an ELF section.  We store a pointer to the
    BFD section in the bfd_section field of the header.  */
 
-boolean
+bfd_boolean
 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
      bfd *abfd;
@@ -357 +735 @@
       BFD_ASSERT (strcmp (name,
                           bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
-      return true;
+      return TRUE;
     }
 
   newsect = bfd_make_section_anyway (abfd, name);
   if (newsect == NULL)
-    return false;
+    return FALSE;
 
   newsect->filepos = hdr->sh_offset;
@@ -369 +747 @@
       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
       || ! bfd_set_section_alignment (abfd, newsect,
-                                      bfd_log2 (hdr->sh_addralign)))
-    return false;
+                                      bfd_log2 ((bfd_vma) hdr->sh_addralign)))
+    return FALSE;
 
   flags = SEC_NO_FLAGS;
   if (hdr->sh_type != SHT_NOBITS)
     flags |= SEC_HAS_CONTENTS;
+  if (hdr->sh_type == SHT_GROUP)
+    flags |= SEC_GROUP | SEC_EXCLUDE;
   if ((hdr->sh_flags & SHF_ALLOC) != 0)
     {
@@ -387 +767 @@
   else if ((flags & SEC_LOAD) != 0)
     flags |= SEC_DATA;
+  if ((hdr->sh_flags & SHF_MERGE) != 0)
+    {
+      flags |= SEC_MERGE;
+      newsect->entsize = hdr->sh_entsize;
+      if ((hdr->sh_flags & SHF_STRINGS) != 0)
+        flags |= SEC_STRINGS;
+    }
+  if (hdr->sh_flags & SHF_GROUP)
+    if (!setup_group (abfd, hdr, newsect))
+      return FALSE;
+  if ((hdr->sh_flags & SHF_TLS) != 0)
+    flags |= SEC_THREAD_LOCAL;
 
   /* The debugging sections appear to be recognized only by name, not
@@ -400 +792 @@
     int i;
 
-    for (i = sizeof (debug_sec_names) / sizeof (debug_sec_names[0]); i--;)
+    for (i = ARRAY_SIZE (debug_sec_names); i--;)
       if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
         break;
@@ -414 +806 @@
      are permitted.  The GNU linker extension is to actually discard
      all but one of the sections.  */
-  if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
+  if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
+      && elf_next_in_group (newsect) == NULL)
     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 
@@ -420 +813 @@
   if (bed->elf_backend_section_flags)
     if (! bed->elf_backend_section_flags (&flags, hdr))
-      return false;
+      return FALSE;
 
   if (! bfd_set_section_flags (abfd, newsect, flags))
-    return false;
+    return FALSE;
 
   if ((flags & SEC_ALLOC) != 0)
@@ -444 +837 @@
           for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
             {
+              /* This section is part of this segment if its file
+                 offset plus size lies within the segment's memory
+                 span and, if the section is loaded, the extent of the
+                 loaded data lies within the extent of the segment.
+
+                 Note - we used to check the p_paddr field as well, and
+                 refuse to set the LMA if it was 0.  This is wrong
+                 though, as a perfectly valid initialised segment can
+                 have a p_paddr of zero.  Some architectures, eg ARM,
+                 place special significance on the address 0 and
+                 executables need to be able to have a segment which
+                 covers this address.  */
               if (phdr->p_type == PT_LOAD
-                  && phdr->p_vaddr != phdr->p_paddr
-                  && phdr->p_vaddr <= hdr->sh_addr
-                  && (phdr->p_vaddr + phdr->p_memsz
-                      >= hdr->sh_addr + hdr->sh_size)
+                  && (bfd_vma) hdr->sh_offset >= phdr->p_offset
+                  && (hdr->sh_offset + hdr->sh_size
+                      <= phdr->p_offset + phdr->p_memsz)
                   && ((flags & SEC_LOAD) == 0
-                      || (phdr->p_offset <= (bfd_vma) hdr->sh_offset
-                          && (phdr->p_offset + phdr->p_filesz
-                              >= hdr->sh_offset + hdr->sh_size))))
+                      || (hdr->sh_offset + hdr->sh_size
+                          <= phdr->p_offset + phdr->p_filesz)))
                 {
-                  newsect->lma += phdr->p_paddr - phdr->p_vaddr;
-                  break;
+                  if ((flags & SEC_LOAD) == 0)
+                    newsect->lma = (phdr->p_paddr
+                                    + hdr->sh_addr - phdr->p_vaddr);
+                  else
+                    /* We used to use the same adjustment for SEC_LOAD
+                       sections, but that doesn't work if the segment
+                       is packed with code from multiple VMAs.
+                       Instead we calculate the section LMA based on
+                       the segment LMA.  It is assumed that the
+                       segment will contain sections with contiguous
+                       LMAs, even if the VMAs are not.  */
+                    newsect->lma = (phdr->p_paddr
+                                    + hdr->sh_offset - phdr->p_offset);
+
+                  /* With contiguous segments, we can't tell from file
+                     offsets whether a section with zero size should
+                     be placed at the end of one segment or the
+                     beginning of the next.  Decide based on vaddr.  */
+                  if (hdr->sh_addr >= phdr->p_vaddr
+                      && (hdr->sh_addr + hdr->sh_size
+                          <= phdr->p_vaddr + phdr->p_memsz))
+                    break;
                 }
             }
@@ -464 +887 @@
   elf_section_data (newsect)->this_hdr = *hdr;
 
-  return true;
+  return TRUE;
 }
 
@@ -495 +918 @@
   if (i_shdrp != NULL)
     {
-      shstrtab = bfd_elf_get_str_section
-        (abfd, elf_elfheader (abfd)->e_shstrndx);
+      shstrtab = bfd_elf_get_str_section (abfd,
+                                          elf_elfheader (abfd)->e_shstrndx);
       if (shstrtab != NULL)
         {
-          max = elf_elfheader (abfd)->e_shnum;
+          max = elf_numsections (abfd);
           for (i = 1; i < max; i++)
             if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
@@ -553 +976 @@
 
 
+/* Make sure sec_info_type is cleared if sec_info is cleared too.  */
+
+static void
+merge_sections_remove_hook (abfd, sec)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     asection *sec;
+{
+  BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
+  sec->sec_info_type = ELF_INFO_TYPE_NONE;
+}
+
+/* Finish SHF_MERGE section merging.  */
+
+bfd_boolean
+_bfd_elf_merge_sections (abfd, info)
+     bfd *abfd;
+     struct bfd_link_info *info;
+{
+  if (!is_elf_hash_table (info))
+    return FALSE;
+  if (elf_hash_table (info)->merge_info)
+    _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info,
+                         merge_sections_remove_hook);
+  return TRUE;
+}
+
+void
+_bfd_elf_link_just_syms (sec, info)
+     asection *sec;
+     struct bfd_link_info *info;
+{
+  sec->output_section = bfd_abs_section_ptr;
+  sec->output_offset = sec->vma;
+  if (!is_elf_hash_table (info))
+    return;
+
+  sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
+}
+
+
+/* Copy the program header and other data from one object module to
+   another.  */
+
+bfd_boolean
+_bfd_elf_copy_private_bfd_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    return TRUE;
+
+  BFD_ASSERT (!elf_flags_init (obfd)
+              || (elf_elfheader (obfd)->e_flags
+                  == elf_elfheader (ibfd)->e_flags));
+
+  elf_gp (obfd) = elf_gp (ibfd);
+  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
+  elf_flags_init (obfd) = TRUE;
+  return TRUE;
+}
+
 /* Print out the program headers.  */
 
-boolean
+bfd_boolean
 _bfd_elf_print_private_bfd_data (abfd, farg)
      bfd *abfd;
@@ -574 +1059 @@
       for (i = 0; i < c; i++, p++)
         {
-          const char *s;
+          const char *pt;
           char buf[20];
 
           switch (p->p_type)
             {
-            case PT_NULL: s = "NULL"; break;
-            case PT_LOAD: s = "LOAD"; break;
-            case PT_DYNAMIC: s = "DYNAMIC"; break;
-            case PT_INTERP: s = "INTERP"; break;
-            case PT_NOTE: s = "NOTE"; break;
-            case PT_SHLIB: s = "SHLIB"; break;
-            case PT_PHDR: s = "PHDR"; break;
-            default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
+            case PT_NULL: pt = "NULL"; break;
+            case PT_LOAD: pt = "LOAD"; break;
+            case PT_DYNAMIC: pt = "DYNAMIC"; break;
+            case PT_INTERP: pt = "INTERP"; break;
+            case PT_NOTE: pt = "NOTE"; break;
+            case PT_SHLIB: pt = "SHLIB"; break;
+            case PT_PHDR: pt = "PHDR"; break;
+            case PT_TLS: pt = "TLS"; break;
+            case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
+            default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
             }
-          fprintf (f, "%8s off    0x", s);
-          fprintf_vma (f, p->p_offset);
+          fprintf (f, "%8s off    0x", pt);
+          bfd_fprintf_vma (abfd, f, p->p_offset);
           fprintf (f, " vaddr 0x");
-          fprintf_vma (f, p->p_vaddr);
+          bfd_fprintf_vma (abfd, f, p->p_vaddr);
           fprintf (f, " paddr 0x");
-          fprintf_vma (f, p->p_paddr);
+          bfd_fprintf_vma (abfd, f, p->p_paddr);
           fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
           fprintf (f, "         filesz 0x");
-          fprintf_vma (f, p->p_filesz);
+          bfd_fprintf_vma (abfd, f, p->p_filesz);
           fprintf (f, " memsz 0x");
-          fprintf_vma (f, p->p_memsz);
+          bfd_fprintf_vma (abfd, f, p->p_memsz);
           fprintf (f, " flags %c%c%c",
                    (p->p_flags & PF_R) != 0 ? 'r' : '-',
                    (p->p_flags & PF_W) != 0 ? 'w' : '-',
                    (p->p_flags & PF_X) != 0 ? 'x' : '-');
-          if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
-            fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
+          if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
+            fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
           fprintf (f, "\n");
         }
@@ -613 +1100 @@
     {
       int elfsec;
-      unsigned long link;
+      unsigned long shlink;
       bfd_byte *extdyn, *extdynend;
       size_t extdynsize;
@@ -630 +1117 @@
       if (elfsec == -1)
         goto error_return;
-      link = elf_elfsections (abfd)[elfsec]->sh_link;
+      shlink = elf_elfsections (abfd)[elfsec]->sh_link;
 
       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
@@ -642 +1129 @@
           const char *name;
           char ab[20];
-          boolean stringp;
+          bfd_boolean stringp;
 
           (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
@@ -649 +1136 @@
             break;
 
-          stringp = false;
+          stringp = FALSE;
           switch (dyn.d_tag)
             {
@@ -657 +1144 @@
               break;
 
-            case DT_NEEDED: name = "NEEDED"; stringp = true; break;
+            case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
             case DT_PLTRELSZ: name = "PLTRELSZ"; break;
             case DT_PLTGOT: name = "PLTGOT"; break;
@@ -670 +1157 @@
             case DT_INIT: name = "INIT"; break;
             case DT_FINI: name = "FINI"; break;
-            case DT_SONAME: name = "SONAME"; stringp = true; break;
-            case DT_RPATH: name = "RPATH"; stringp = true; break;
+            case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
+            case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
             case DT_SYMBOLIC: name = "SYMBOLIC"; break;
             case DT_REL: name = "REL"; break;
@@ -685 +1172 @@
             case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
             case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
-            case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
+            case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
             case DT_FLAGS: name = "FLAGS"; break;
             case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
@@ -697 +1184 @@
             case DT_SYMINSZ: name = "SYMINSZ"; break;
             case DT_SYMINENT: name = "SYMINENT"; break;
-            case DT_CONFIG: name = "CONFIG"; stringp = true; break;
-            case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
-            case DT_AUDIT: name = "AUDIT"; stringp = true; break;
+            case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
+            case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
+            case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
             case DT_PLTPAD: name = "PLTPAD"; break;
             case DT_MOVETAB: name = "MOVETAB"; break;
@@ -711 +1198 @@
             case DT_VERNEED: name = "VERNEED"; break;
             case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
-            case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
+            case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
             case DT_USED: name = "USED"; break;
-            case DT_FILTER: name = "FILTER"; stringp = true; break;
+            case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
             }
 
@@ -722 +1209 @@
             {
               const char *string;
-
-              string = bfd_elf_string_from_elf_section (abfd, link,
-                                                        dyn.d_un.d_val);
+              unsigned int tagv = dyn.d_un.d_val;
+
+              string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
               if (string == NULL)
                 goto error_return;
@@ -740 +1227 @@
     {
       if (! _bfd_elf_slurp_version_tables (abfd))
-        return false;
+        return FALSE;
     }
 
@@ -782 +1269 @@
     }
 
-  return true;
+  return TRUE;
 
  error_return:
   if (dynbuf != NULL)
     free (dynbuf);
-  return false;
+  return FALSE;
 }
 
@@ -807 +1294 @@
     case bfd_print_symbol_more:
       fprintf (file, "elf ");
-      fprintf_vma (file, symbol->value);
+      bfd_fprintf_vma (abfd, file, symbol->value);
       fprintf (file, " %lx", (long) symbol->flags);
       break;
@@ -816 +1303 @@
         struct elf_backend_data *bed;
         unsigned char st_other;
+        bfd_vma val;
 
         section_name = symbol->section ? symbol->section->name : "(*none*)";
@@ -826 +1314 @@
           {
             name = symbol->name;
-            bfd_print_symbol_vandf ((PTR) file, symbol);
+            bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
           }
 
@@ -834 +1322 @@
            For other symbols, we have no specified alignment, and
            we've printed the address; now print the size.  */
-        fprintf_vma (file,
-                     (bfd_is_com_section (symbol->section)
-                      ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
-                      : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
+        if (bfd_is_com_section (symbol->section))
+          val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
+        else
+          val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
+        bfd_fprintf_vma (abfd, file, val);
 
         /* If we have version information, print it.  */
@@ -920 +1409 @@
      const char *string;
 {
-  struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
-
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
-  if (ret == (struct elf_link_hash_entry *) NULL)
-    ret = ((struct elf_link_hash_entry *)
-           bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
-  if (ret == (struct elf_link_hash_entry *) NULL)
-    return (struct bfd_hash_entry *) ret;
+  if (entry == NULL)
+    {
+      entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
+      if (entry == NULL)
+        return entry;
+    }
 
   /* Call the allocation method of the superclass.  */
-  ret = ((struct elf_link_hash_entry *)
-         _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
-                                 table, string));
-  if (ret != (struct elf_link_hash_entry *) NULL)
-    {
+  entry = _bfd_link_hash_newfunc (entry, table, string);
+  if (entry != NULL)
+    {
+      struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
+      struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
+
       /* Set local fields.  */
       ret->indx = -1;
-      ret->size = 0;
       ret->dynindx = -1;
       ret->dynstr_index = 0;
+      ret->elf_hash_value = 0;
       ret->weakdef = NULL;
-      ret->got.offset = (bfd_vma) -1;
-      ret->plt.offset = (bfd_vma) -1;
-      ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
+      ret->linker_section_pointer = NULL;
       ret->verinfo.verdef = NULL;
+      ret->vtable_entries_size = 0;
       ret->vtable_entries_used = NULL;
-      ret->vtable_entries_size = 0;
       ret->vtable_parent = NULL;
+      ret->got = htab->init_refcount;
+      ret->plt = htab->init_refcount;
+      ret->size = 0;
       ret->type = STT_NOTYPE;
       ret->other = 0;
@@ -958 +1448 @@
     }
 
-  return (struct bfd_hash_entry *) ret;
+  return entry;
 }
 
 /* Copy data from an indirect symbol to its direct symbol, hiding the
-   old indirect symbol.  */
+   old indirect symbol.  Also used for copying flags to a weakdef.  */
 
 void
-_bfd_elf_link_hash_copy_indirect (dir, ind)
+_bfd_elf_link_hash_copy_indirect (bed, dir, ind)
+     struct elf_backend_data *bed;
      struct elf_link_hash_entry *dir, *ind;
 {
+  bfd_signed_vma tmp;
+  bfd_signed_vma lowest_valid = bed->can_refcount;
+
   /* Copy down any references that we may have already seen to the
      symbol which just became indirect.  */
@@ -978 +1472 @@
         | ELF_LINK_NON_GOT_REF));
 
-  /* Copy over the global and procedure linkage table offset entries.
+  if (ind->root.type != bfd_link_hash_indirect)
+    return;
+
+  /* Copy over the global and procedure linkage table refcount entries.
      These may have been already set up by a check_relocs routine.  */
-  if (dir->got.offset == (bfd_vma) -1)
-    {
-      dir->got.offset = ind->got.offset;
-      ind->got.offset = (bfd_vma) -1;
-    }
-  BFD_ASSERT (ind->got.offset == (bfd_vma) -1);
-
-  if (dir->plt.offset == (bfd_vma) -1)
-    {
-      dir->plt.offset = ind->plt.offset;
-      ind->plt.offset = (bfd_vma) -1;
-    }
-  BFD_ASSERT (ind->plt.offset == (bfd_vma) -1);
+  tmp = dir->got.refcount;
+  if (tmp < lowest_valid)
+    {
+      dir->got.refcount = ind->got.refcount;
+      ind->got.refcount = tmp;
+    }
+  else
+    BFD_ASSERT (ind->got.refcount < lowest_valid);
+
+  tmp = dir->plt.refcount;
+  if (tmp < lowest_valid)
+    {
+      dir->plt.refcount = ind->plt.refcount;
+      ind->plt.refcount = tmp;
+    }
+  else
+    BFD_ASSERT (ind->plt.refcount < lowest_valid);
 
   if (dir->dynindx == -1)
@@ -1001 +1502 @@
       ind->dynstr_index = 0;
     }
-  BFD_ASSERT (ind->dynindx == -1);
+  else
+    BFD_ASSERT (ind->dynindx == -1);
 }
 
 void
-_bfd_elf_link_hash_hide_symbol (info, h)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+_bfd_elf_link_hash_hide_symbol (info, h, force_local)
+     struct bfd_link_info *info;
      struct elf_link_hash_entry *h;
-{
+     bfd_boolean force_local;
+{
+  h->plt = elf_hash_table (info)->init_offset;
   h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
-  h->plt.offset = (bfd_vma) -1;
-  if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
-    h->dynindx = -1;
+  if (force_local)
+    {
+      h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
+      if (h->dynindx != -1)
+        {
+          h->dynindx = -1;
+          _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
+                                  h->dynstr_index);
+        }
+    }
 }
 
 /* Initialize an ELF linker hash table.  */
 
-boolean
+bfd_boolean
 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
      struct elf_link_hash_table *table;
      bfd *abfd;
-     struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
-                                                struct bfd_hash_table *,
-                                                const char *));
-{
-  table->dynamic_sections_created = false;
+     struct bfd_hash_entry *(*newfunc)
+       PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
+                const char *));
+{
+  bfd_boolean ret;
+
+  table->dynamic_sections_created = FALSE;
   table->dynobj = NULL;
+  /* Make sure can_refcount is extended to the width and signedness of
+     init_refcount before we subtract one from it.  */
+  table->init_refcount.refcount = get_elf_backend_data (abfd)->can_refcount;
+  table->init_refcount.refcount -= 1;
+  table->init_offset.offset = -(bfd_vma) 1;
   /* The first dynamic symbol is a dummy.  */
   table->dynsymcount = 1;
@@ -1032 +1550 @@
   table->bucketcount = 0;
   table->needed = NULL;
-  table->runpath = NULL;
   table->hgot = NULL;
   table->stab_info = NULL;
+  table->merge_info = NULL;
+  memset (&table->eh_info, 0, sizeof (table->eh_info));
   table->dynlocal = NULL;
-  return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
+  table->runpath = NULL;
+  table->tls_segment = NULL;
+  table->loaded = NULL;
+
+  ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
+  table->root.type = bfd_link_elf_hash_table;
+
+  return ret;
 }
 
@@ -1046 +1572 @@
 {
   struct elf_link_hash_table *ret;
-
-  ret = ((struct elf_link_hash_table *)
-         bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
+  bfd_size_type amt = sizeof (struct elf_link_hash_table);
+
+  ret = (struct elf_link_hash_table *) bfd_malloc (amt);
   if (ret == (struct elf_link_hash_table *) NULL)
     return NULL;
@@ -1054 +1580 @@
   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
     {
-      bfd_release (abfd, ret);
+      free (ret);
       return NULL;
     }
@@ -1094 +1620 @@
      struct bfd_link_info *info;
 {
-  if (info->hash->creator->flavour != bfd_target_elf_flavour)
+  if (! is_elf_hash_table (info))
     return NULL;
   return elf_hash_table (info)->needed;
@@ -1107 +1633 @@
      struct bfd_link_info *info;
 {
-  if (info->hash->creator->flavour != bfd_target_elf_flavour)
+  if (! is_elf_hash_table (info))
     return NULL;
   return elf_hash_table (info)->runpath;
@@ -1129 +1655 @@
    the ELF linker emulation code.  */
 
-boolean
+bfd_boolean
 bfd_elf_get_bfd_needed_list (abfd, pneeded)
      bfd *abfd;
@@ -1137 +1663 @@
   bfd_byte *dynbuf = NULL;
   int elfsec;
-  unsigned long link;
+  unsigned long shlink;
   bfd_byte *extdyn, *extdynend;
   size_t extdynsize;
@@ -1146 +1672 @@
   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
       || bfd_get_format (abfd) != bfd_object)
-    return true;
+    return TRUE;
 
   s = bfd_get_section_by_name (abfd, ".dynamic");
   if (s == NULL || s->_raw_size == 0)
-    return true;
+    return TRUE;
 
   dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
@@ -1164 +1690 @@
     goto error_return;
 
-  link = elf_elfsections (abfd)[elfsec]->sh_link;
+  shlink = elf_elfsections (abfd)[elfsec]->sh_link;
 
   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
@@ -1184 +1710 @@
           const char *string;
           struct bfd_link_needed_list *l;
-
-          string = bfd_elf_string_from_elf_section (abfd, link,
-                                                    dyn.d_un.d_val);
+          unsigned int tagv = dyn.d_un.d_val;
+          bfd_size_type amt;
+
+          string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
           if (string == NULL)
             goto error_return;
 
-          l = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof *l);
+          amt = sizeof *l;
+          l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
           if (l == NULL)
             goto error_return;
@@ -1203 +1731 @@
   free (dynbuf);
 
-  return true;
+  return TRUE;
 
  error_return:
   if (dynbuf != NULL)
     free (dynbuf);
-  return false;
+  return FALSE;
 }
 
@@ -1224 +1752 @@
       bfd_size_type loc;
 
-      loc = _bfd_stringtab_add (ret, "", true, false);
+      loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
       if (loc == (bfd_size_type) -1)
@@ -1240 +1768 @@
 /* Create a new bfd section from an ELF section header.  */
 
-boolean
+bfd_boolean
 bfd_section_from_shdr (abfd, shindex)
      bfd *abfd;
@@ -1248 +1776 @@
   Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
-  char *name;
+  const char *name;
 
   name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
@@ -1256 +1784 @@
     case SHT_NULL:
       /* Inactive section. Throw it away.  */
-      return true;
+      return TRUE;
 
     case SHT_PROGBITS:  /* Normal section with contents.  */
-    case SHT_DYNAMIC:   /* Dynamic linking information.  */
     case SHT_NOBITS:    /* .bss section.  */
     case SHT_HASH:      /* .hash section.  */
     case SHT_NOTE:      /* .note section.  */
+    case SHT_INIT_ARRAY:        /* .init_array section.  */
+    case SHT_FINI_ARRAY:        /* .fini_array section.  */
+    case SHT_PREINIT_ARRAY:     /* .preinit_array section.  */
       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
+
+    case SHT_DYNAMIC:   /* Dynamic linking information.  */
+      if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
+        return FALSE;
+      if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
+        {
+          Elf_Internal_Shdr *dynsymhdr;
+
+          /* The shared libraries distributed with hpux11 have a bogus
+             sh_link field for the ".dynamic" section.  Find the
+             string table for the ".dynsym" section instead.  */
+          if (elf_dynsymtab (abfd) != 0)
+            {
+              dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
+              hdr->sh_link = dynsymhdr->sh_link;
+            }
+          else
+            {
+              unsigned int i, num_sec;
+
+              num_sec = elf_numsections (abfd);
+              for (i = 1; i < num_sec; i++)
+                {
+                  dynsymhdr = elf_elfsections (abfd)[i];
+                  if (dynsymhdr->sh_type == SHT_DYNSYM)
+                    {
+                      hdr->sh_link = dynsymhdr->sh_link;
+                      break;
+                    }
+                }
+            }
+        }
+      break;
 
     case SHT_SYMTAB:            /* A symbol table */
       if (elf_onesymtab (abfd) == shindex)
-        return true;
+        return TRUE;
 
       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
@@ -1285 +1848 @@
           && (abfd->flags & DYNAMIC) != 0
           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
-        return false;
-
-      return true;
+        return FALSE;
+
+      return TRUE;
 
     case SHT_DYNSYM:            /* A dynamic symbol table */
       if (elf_dynsymtab (abfd) == shindex)
-        return true;
+        return TRUE;
 
       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
@@ -1304 +1867 @@
       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
 
+    case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections */
+      if (elf_symtab_shndx (abfd) == shindex)
+        return TRUE;
+
+      /* Get the associated symbol table.  */
+      if (! bfd_section_from_shdr (abfd, hdr->sh_link)
+          || hdr->sh_link != elf_onesymtab (abfd))
+        return FALSE;
+
+      elf_symtab_shndx (abfd) = shindex;
+      elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
+      elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
+      return TRUE;
+
     case SHT_STRTAB:            /* A string table */
       if (hdr->bfd_section != NULL)
-        return true;
+        return TRUE;
       if (ehdr->e_shstrndx == shindex)
         {
           elf_tdata (abfd)->shstrtab_hdr = *hdr;
           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
-          return true;
+          return TRUE;
         }
       {
-        unsigned int i;
-
-        for (i = 1; i < ehdr->e_shnum; i++)
+        unsigned int i, num_sec;
+
+        num_sec = elf_numsections (abfd);
+        for (i = 1; i < num_sec; i++)
           {
             Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
@@ -1322 +1900 @@
               {
                 if (! bfd_section_from_shdr (abfd, i))
-                  return false;
+                  return FALSE;
                 if (elf_onesymtab (abfd) == i)
                   {
@@ -1328 +1906 @@
                     elf_elfsections (abfd)[shindex] =
                       &elf_tdata (abfd)->strtab_hdr;
-                    return true;
+                    return TRUE;
                   }
                 if (elf_dynsymtab (abfd) == i)
@@ -1362 +1940 @@
         asection *target_sect;
         Elf_Internal_Shdr *hdr2;
+        unsigned int num_sec = elf_numsections (abfd);
 
         /* Check for a bogus link to avoid crashing.  */
-        if (hdr->sh_link >= ehdr->e_shnum)
+        if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
+            || hdr->sh_link >= num_sec)
           {
             ((*_bfd_error_handler)
              (_("%s: invalid link %lu for reloc section %s (index %u)"),
-              bfd_get_filename (abfd), hdr->sh_link, name, shindex));
+              bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
             return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
           }
@@ -1382 +1962 @@
             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
           {
-            int scan;
+            unsigned int scan;
             int found;
 
             found = 0;
-            for (scan = 1; scan < ehdr->e_shnum; scan++)
+            for (scan = 1; scan < num_sec; scan++)
               {
                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
@@ -1406 +1986 @@
         if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
-          return false;
+          return FALSE;
 
         /* If this reloc section does not use the main symbol table we
@@ -1418 +1998 @@
 
         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
-          return false;
+          return FALSE;
         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
         if (target_sect == NULL)
-          return false;
+          return FALSE;
 
         if ((target_sect->flags & SEC_RELOC) == 0
@@ -1428 +2008 @@
         else
           {
+            bfd_size_type amt;
             BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
-            hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
+            amt = sizeof (*hdr2);
+            hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
             elf_section_data (target_sect)->rel_hdr2 = hdr2;
           }
@@ -1441 +2023 @@
            its relocations are of the REL or RELA variety.  */
         if (hdr->sh_size != 0)
-          elf_section_data (target_sect)->use_rela_p
-            = (hdr->sh_type == SHT_RELA);
+          target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
         abfd->flags |= HAS_RELOC;
-        return true;
+        return TRUE;
       }
       break;
@@ -1467 +2048 @@
 
     case SHT_SHLIB:
-      return true;
+      return TRUE;
+
+    case SHT_GROUP:
+      /* We need a BFD section for objcopy and relocatable linking,
+         and it's handy to have the signature available as the section
+         name.  */
+      name = group_signature (abfd, hdr);
+      if (name == NULL)
+        return FALSE;
+      if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
+        return FALSE;
+      if (hdr->contents != NULL)
+        {
+          Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
+          unsigned int n_elt = hdr->sh_size / 4;
+          asection *s;
+
+          if (idx->flags & GRP_COMDAT)
+            hdr->bfd_section->flags
+              |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
+
+          while (--n_elt != 0)
+            if ((s = (++idx)->shdr->bfd_section) != NULL
+                && elf_next_in_group (s) != NULL)
+              {
+                elf_next_in_group (hdr->bfd_section) = s;
+                break;
+              }
+        }
+      break;
 
     default:
@@ -1478 +2088 @@
     }
 
-  return true;
+  return TRUE;
+}
+
+/* Return the section for the local symbol specified by ABFD, R_SYMNDX.
+   Return SEC for sections that have no elf section, and NULL on error.  */
+
+asection *
+bfd_section_from_r_symndx (abfd, cache, sec, r_symndx)
+     bfd *abfd;
+     struct sym_sec_cache *cache;
+     asection *sec;
+     unsigned long r_symndx;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  unsigned char esym[sizeof (Elf64_External_Sym)];
+  Elf_External_Sym_Shndx eshndx;
+  Elf_Internal_Sym isym;
+  unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
+
+  if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
+    return cache->sec[ent];
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
+                            &isym, esym, &eshndx) == NULL)
+    return NULL;
+
+  if (cache->abfd != abfd)
+    {
+      memset (cache->indx, -1, sizeof (cache->indx));
+      cache->abfd = abfd;
+    }
+  cache->indx[ent] = r_symndx;
+  cache->sec[ent] = sec;
+  if (isym.st_shndx < SHN_LORESERVE || isym.st_shndx > SHN_HIRESERVE)
+    {
+      asection *s;
+      s = bfd_section_from_elf_index (abfd, isym.st_shndx);
+      if (s != NULL)
+        cache->sec[ent] = s;
+    }
+  return cache->sec[ent];
 }
 
@@ -1489 +2140 @@
      unsigned int index;
 {
-  BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
-  if (index >= elf_elfheader (abfd)->e_shnum)
+  if (index >= elf_numsections (abfd))
     return NULL;
   return elf_elfsections (abfd)[index]->bfd_section;
 }
 
-boolean
+bfd_boolean
 _bfd_elf_new_section_hook (abfd, sec)
      bfd *abfd;
@@ -1502 +2152 @@
   struct bfd_elf_section_data *sdata;
 
-  sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, sizeof (*sdata));
-  if (!sdata)
-    return false;
-  sec->used_by_bfd = (PTR) sdata;
+  sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
+  if (sdata == NULL)
+    {
+      bfd_size_type amt = sizeof (*sdata);
+      sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
+      if (sdata == NULL)
+        return FALSE;
+      sec->used_by_bfd = (PTR) sdata;
+    }
 
   /* Indicate whether or not this section should use RELA relocations.  */
-  sdata->use_rela_p
-    = get_elf_backend_data (abfd)->default_use_rela_p;
-
-  return true;
+  sec->use_rela_p = get_elf_backend_data (abfd)->default_use_rela_p;
+
+  return TRUE;
 }
 
@@ -1536 +2190 @@
  */
 
-boolean
+bfd_boolean
 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
      bfd *abfd;
@@ -1546 +2200 @@
   char *name;
   char namebuf[64];
+  size_t len;
   int split;
 
@@ -1552 +2207 @@
             && (hdr->p_memsz > hdr->p_filesz));
   sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
-  name = bfd_alloc (abfd, strlen (namebuf) + 1);
+  len = strlen (namebuf) + 1;
+  name = bfd_alloc (abfd, (bfd_size_type) len);
   if (!name)
-    return false;
-  strcpy (name, namebuf);
+    return FALSE;
+  memcpy (name, namebuf, len);
   newsect = bfd_make_section (abfd, name);
   if (newsect == NULL)
-    return false;
+    return FALSE;
   newsect->vma = hdr->p_vaddr;
   newsect->lma = hdr->p_paddr;
@@ -1583 +2239 @@
     {
       sprintf (namebuf, "%s%db", typename, index);
-      name = bfd_alloc (abfd, strlen (namebuf) + 1);
+      len = strlen (namebuf) + 1;
+      name = bfd_alloc (abfd, (bfd_size_type) len);
       if (!name)
-        return false;
-      strcpy (name, namebuf);
+        return FALSE;
+      memcpy (name, namebuf, len);
       newsect = bfd_make_section (abfd, name);
       if (newsect == NULL)
-        return false;
+        return FALSE;
       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
       newsect->lma = hdr->p_paddr + hdr->p_filesz;
@@ -1603 +2260 @@
     }
 
-  return true;
-}
-
-boolean
+  return TRUE;
+}
+
+bfd_boolean
 bfd_section_from_phdr (abfd, hdr, index)
      bfd *abfd;
@@ -1630 +2287 @@
     case PT_NOTE:
       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
-        return false;
-      if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
-        return false;
-      return true;
+        return FALSE;
+      if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
+        return FALSE;
+      return TRUE;
 
     case PT_SHLIB:
@@ -1640 +2297 @@
     case PT_PHDR:
       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
+
+    case PT_GNU_EH_FRAME:
+      return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
+                                              "eh_frame_hdr");
 
     default:
@@ -1653 +2314 @@
 
 /* Initialize REL_HDR, the section-header for new section, containing
-   relocations against ASECT.  If USE_RELA_P is true, we use RELA
+   relocations against ASECT.  If USE_RELA_P is TRUE, we use RELA
    relocations; otherwise, we use REL relocations.  */
 
-boolean
+bfd_boolean
 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
      bfd *abfd;
      Elf_Internal_Shdr *rel_hdr;
      asection *asect;
-     boolean use_rela_p;
+     bfd_boolean use_rela_p;
 {
   char *name;
-  struct elf_backend_data *bed;
-
-  bed = get_elf_backend_data (abfd);
-  name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
+
+  name = bfd_alloc (abfd, amt);
   if (name == NULL)
-    return false;
+    return FALSE;
   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
   rel_hdr->sh_name =
-    (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
-                                       true, false);
+    (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
+                                        FALSE);
   if (rel_hdr->sh_name == (unsigned int) -1)
-    return false;
+    return FALSE;
   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
   rel_hdr->sh_entsize = (use_rela_p
@@ -1686 +2347 @@
   rel_hdr->sh_offset = 0;
 
-  return true;
+  return TRUE;
 }
 
@@ -1698 +2359 @@
 {
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
-  boolean *failedptr = (boolean *) failedptrarg;
+  bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
   Elf_Internal_Shdr *this_hdr;
 
@@ -1710 +2371 @@
   this_hdr = &elf_section_data (asect)->this_hdr;
 
-  this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
-                                                          asect->name,
-                                                          true, false);
-  if (this_hdr->sh_name == (unsigned long) -1)
-    {
-      *failedptr = true;
+  this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
+                                                          asect->name, FALSE);
+  if (this_hdr->sh_name == (unsigned int) -1)
+    {
+      *failedptr = TRUE;
       return;
     }
@@ -1767 +2427 @@
       this_hdr->sh_entsize = bed->s->sizeof_rel;
     }
+  else if (strcmp (asect->name, ".init_array") == 0)
+    this_hdr->sh_type = SHT_INIT_ARRAY;
+  else if (strcmp (asect->name, ".fini_array") == 0)
+    this_hdr->sh_type = SHT_FINI_ARRAY;
+  else if (strcmp (asect->name, ".preinit_array") == 0)
+    this_hdr->sh_type = SHT_PREINIT_ARRAY;
   else if (strncmp (asect->name, ".note", 5) == 0)
     this_hdr->sh_type = SHT_NOTE;
@@ -1803 +2469 @@
                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
     }
+  else if ((asect->flags & SEC_GROUP) != 0)
+    {
+      this_hdr->sh_type = SHT_GROUP;
+      this_hdr->sh_entsize = 4;
+    }
   else if ((asect->flags & SEC_ALLOC) != 0
-           && ((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0))
+           && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
+               || (asect->flags & SEC_NEVER_LOAD) != 0))
     this_hdr->sh_type = SHT_NOBITS;
   else
@@ -1815 +2487 @@
   if ((asect->flags & SEC_CODE) != 0)
     this_hdr->sh_flags |= SHF_EXECINSTR;
+  if ((asect->flags & SEC_MERGE) != 0)
+    {
+      this_hdr->sh_flags |= SHF_MERGE;
+      this_hdr->sh_entsize = asect->entsize;
+      if ((asect->flags & SEC_STRINGS) != 0)
+        this_hdr->sh_flags |= SHF_STRINGS;
+    }
+  if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
+    this_hdr->sh_flags |= SHF_GROUP;
+  if ((asect->flags & SEC_THREAD_LOCAL) != 0)
+    {
+      this_hdr->sh_flags |= SHF_TLS;
+      if (asect->_raw_size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
+        {
+          struct bfd_link_order *o;
+
+          this_hdr->sh_size = 0;
+          for (o = asect->link_order_head; o != NULL; o = o->next)
+            if (this_hdr->sh_size < o->offset + o->size)
+              this_hdr->sh_size = o->offset + o->size;
+          if (this_hdr->sh_size)
+            this_hdr->sh_type = SHT_NOBITS;
+        }
+    }
 
   /* Check for processor-specific section types.  */
-  if (bed->elf_backend_fake_sections)
-    (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
+  if (bed->elf_backend_fake_sections
+      && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
+    *failedptr = TRUE;
 
   /* If the section has relocs, set up a section header for the
@@ -1828 +2525 @@
                                     &elf_section_data (asect)->rel_hdr,
                                     asect,
-                                    elf_section_data (asect)->use_rela_p))
-    *failedptr = true;
+                                    asect->use_rela_p))
+    *failedptr = TRUE;
+}
+
+/* Fill in the contents of a SHT_GROUP section.  */
+
+void
+bfd_elf_set_group_contents (abfd, sec, failedptrarg)
+     bfd *abfd;
+     asection *sec;
+     PTR failedptrarg;
+{
+  bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
+  unsigned long symindx;
+  asection *elt, *first;
+  unsigned char *loc;
+  struct bfd_link_order *l;
+  bfd_boolean gas;
+
+  if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
+      || *failedptr)
+    return;
+
+  symindx = 0;
+  if (elf_group_id (sec) != NULL)
+    symindx = elf_group_id (sec)->udata.i;
+
+  if (symindx == 0)
+    {
+      /* If called from the assembler, swap_out_syms will have set up
+         elf_section_syms;  If called for "ld -r", use target_index.  */
+      if (elf_section_syms (abfd) != NULL)
+        symindx = elf_section_syms (abfd)[sec->index]->udata.i;
+      else
+        symindx = sec->target_index;
+    }
+  elf_section_data (sec)->this_hdr.sh_info = symindx;
+
+  /* The contents won't be allocated for "ld -r" or objcopy.  */
+  gas = TRUE;
+  if (sec->contents == NULL)
+    {
+      gas = FALSE;
+      sec->contents = bfd_alloc (abfd, sec->_raw_size);
+
+      /* Arrange for the section to be written out.  */
+      elf_section_data (sec)->this_hdr.contents = sec->contents;
+      if (sec->contents == NULL)
+        {
+          *failedptr = TRUE;
+          return;
+        }
+    }
+
+  loc = sec->contents + sec->_raw_size;
+
+  /* Get the pointer to the first section in the group that gas
+     squirreled away here.  objcopy arranges for this to be set to the
+     start of the input section group.  */
+  first = elt = elf_next_in_group (sec);
+
+  /* First element is a flag word.  Rest of section is elf section
+     indices for all the sections of the group.  Write them backwards
+     just to keep the group in the same order as given in .section
+     directives, not that it matters.  */
+  while (elt != NULL)
+    {
+      asection *s;
+      unsigned int idx;
+
+      loc -= 4;
+      s = elt;
+      if (!gas)
+        s = s->output_section;
+      idx = 0;
+      if (s != NULL)
+        idx = elf_section_data (s)->this_idx;
+      H_PUT_32 (abfd, idx, loc);
+      elt = elf_next_in_group (elt);
+      if (elt == first)
+        break;
+    }
+
+  /* If this is a relocatable link, then the above did nothing because
+     SEC is the output section.  Look through the input sections
+     instead.  */
+  for (l = sec->link_order_head; l != NULL; l = l->next)
+    if (l->type == bfd_indirect_link_order
+        && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
+      do
+        {
+          loc -= 4;
+          H_PUT_32 (abfd,
+                    elf_section_data (elt->output_section)->this_idx, loc);
+          elt = elf_next_in_group (elt);
+          /* During a relocatable link, the lists are circular.  */
+        }
+      while (elt != elf_next_in_group (l->u.indirect.section));
+
+  /* With ld -r, merging SHT_GROUP sections results in wasted space
+     due to allowing for the flag word on each input.  We may well
+     duplicate entries too.  */
+  while ((loc -= 4) > sec->contents)
+    H_PUT_32 (abfd, 0, loc);
+
+  if (loc != sec->contents)
+    abort ();
+
+  H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
 }
 
@@ -1836 +2640 @@
    in here too, while we're at it.  */
 
-static boolean
+static bfd_boolean
 assign_section_numbers (abfd)
      bfd *abfd;
@@ -1842 +2646 @@
   struct elf_obj_tdata *t = elf_tdata (abfd);
   asection *sec;
-  unsigned int section_number;
+  unsigned int section_number, secn;
   Elf_Internal_Shdr **i_shdrp;
+  bfd_size_type amt;
 
   section_number = 1;
 
+  _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
+
   for (sec = abfd->sections; sec; sec = sec->next)
     {
       struct bfd_elf_section_data *d = elf_section_data (sec);
 
+      if (section_number == SHN_LORESERVE)
+        section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
       d->this_idx = section_number++;
+      _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
       if ((sec->flags & SEC_RELOC) == 0)
         d->rel_idx = 0;
       else
-        d->rel_idx = section_number++;
+        {
+          if (section_number == SHN_LORESERVE)
+            section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
+          d->rel_idx = section_number++;
+          _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
+        }
 
       if (d->rel_hdr2)
-        d->rel_idx2 = section_number++;
+        {
+          if (section_number == SHN_LORESERVE)
+            section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
+          d->rel_idx2 = section_number++;
+          _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
+        }
       else
         d->rel_idx2 = 0;
     }
 
+  if (section_number == SHN_LORESERVE)
+    section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
   t->shstrtab_section = section_number++;
+  _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
-  t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
 
   if (bfd_get_symcount (abfd) > 0)
     {
+      if (section_number == SHN_LORESERVE)
+        section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
       t->symtab_section = section_number++;
+      _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
+      if (section_number > SHN_LORESERVE - 2)
+        {
+          if (section_number == SHN_LORESERVE)
+            section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
+          t->symtab_shndx_section = section_number++;
+          t->symtab_shndx_hdr.sh_name
+            = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
+                                                  ".symtab_shndx", FALSE);
+          if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
+            return FALSE;
+        }
+      if (section_number == SHN_LORESERVE)
+        section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
       t->strtab_section = section_number++;
-    }
-
+      _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
+    }
+
+  _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
+  t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
+
+  elf_numsections (abfd) = section_number;
   elf_elfheader (abfd)->e_shnum = section_number;
+  if (section_number > SHN_LORESERVE)
+    elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
 
   /* Set up the list of section header pointers, in agreement with the
      indices.  */
-  i_shdrp = ((Elf_Internal_Shdr **)
-             bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
+  amt = section_number * sizeof (Elf_Internal_Shdr *);
+  i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc (abfd, amt);
   if (i_shdrp == NULL)
-    return false;
-
-  i_shdrp[0] = ((Elf_Internal_Shdr *)
-                bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
+    return FALSE;
+
+  amt = sizeof (Elf_Internal_Shdr);
+  i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd, amt);
   if (i_shdrp[0] == NULL)
     {
       bfd_release (abfd, i_shdrp);
-      return false;
-    }
-  memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
+      return FALSE;
+    }
 
   elf_elfsections (abfd) = i_shdrp;
@@ -1897 +2741 @@
     {
       i_shdrp[t->symtab_section] = &t->symtab_hdr;
+      if (elf_numsections (abfd) > SHN_LORESERVE)
+        {
+          i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
+          t->symtab_shndx_hdr.sh_link = t->symtab_section;
+        }
       i_shdrp[t->strtab_section] = &t->strtab_hdr;
       t->symtab_hdr.sh_link = t->strtab_section;
@@ -1965 +2814 @@
 
               len = strlen (sec->name);
-              alc = (char *) bfd_malloc (len - 2);
+              alc = (char *) bfd_malloc ((bfd_size_type) (len - 2));
               if (alc == NULL)
-                return false;
-              strncpy (alc, sec->name, len - 3);
+                return FALSE;
+              memcpy (alc, sec->name, len - 3);
               alc[len - 3] = '\0';
               s = bfd_get_section_by_name (abfd, alc);
@@ -1977 +2826 @@
 
                   /* This is a .stab section.  */
-                  elf_section_data (s)->this_hdr.sh_entsize =
-                    4 + 2 * bfd_get_arch_size (abfd) / 8;
+                  if (elf_section_data (s)->this_hdr.sh_entsize == 0)
+                    elf_section_data (s)->this_hdr.sh_entsize
+                      = 4 + 2 * bfd_get_arch_size (abfd) / 8;
                 }
             }
@@ -2003 +2853 @@
             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
           break;
-        }
-    }
-
-  return true;
+
+        case SHT_GROUP:
+          d->this_hdr.sh_link = t->symtab_section;
+        }
+    }
+
+  for (secn = 1; secn < section_number; ++secn)
+    if (i_shdrp[secn] == NULL)
+      i_shdrp[secn] = i_shdrp[0];
+    else
+      i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
+                                                       i_shdrp[secn]->sh_name);
+  return TRUE;
 }
 
@@ -2027 +2886 @@
 }
 
-static boolean
+static bfd_boolean
 elf_map_symbols (abfd)
      bfd *abfd;
 {
-  int symcount = bfd_get_symcount (abfd);
+  unsigned int symcount = bfd_get_symcount (abfd);
   asymbol **syms = bfd_get_outsymbols (abfd);
   asymbol **sect_syms;
-  int num_locals = 0;
-  int num_globals = 0;
-  int num_locals2 = 0;
-  int num_globals2 = 0;
+  unsigned int num_locals = 0;
+  unsigned int num_globals = 0;
+  unsigned int num_locals2 = 0;
+  unsigned int num_globals2 = 0;
   int max_index = 0;
-  int num_sections = 0;
-  int idx;
+  unsigned int idx;
   asection *asect;
   asymbol **new_syms;
-  asymbol *sym;
+  bfd_size_type amt;
 
 #ifdef DEBUG
@@ -2050 +2908 @@
 #endif
 
-  /* Add a section symbol for each BFD section.  FIXME: Is this really
-     necessary?  */
   for (asect = abfd->sections; asect; asect = asect->next)
     {
@@ -2059 +2915 @@
 
   max_index++;
-  sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
+  amt = max_index * sizeof (asymbol *);
+  sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
   if (sect_syms == NULL)
-    return false;
+    return FALSE;
   elf_section_syms (abfd) = sect_syms;
-
+  elf_num_section_syms (abfd) = max_index;
+
+  /* Init sect_syms entries for any section symbols we have already
+     decided to output.  */
   for (idx = 0; idx < symcount; idx++)
     {
-      sym = syms[idx];
+      asymbol *sym = syms[idx];
 
       if ((sym->flags & BSF_SECTION_SYM) != 0
@@ -2084 +2944 @@
                   sec = sec->output_section;
 
-                  /* Empty sections in the input files may have had a section
-                     symbol created for them.  (See the comment near the end of
-                     _bfd_generic_link_output_symbols in linker.c).  If the linker
-                     script discards such sections then we will reach this point.
-                     Since we know that we cannot avoid this case, we detect it
-                     and skip the abort and the assignment to the sect_syms array.
-                     To reproduce this particular case try running the linker
-                     testsuite test ld-scripts/weak.exp for an ELF port that uses
-                     the generic linker.  */
+                  /* Empty sections in the input files may have had a
+                     section symbol created for them.  (See the comment
+                     near the end of _bfd_generic_link_output_symbols in
+                     linker.c).  If the linker script discards such
+                     sections then we will reach this point.  Since we know
+                     that we cannot avoid this case, we detect it and skip
+                     the abort and the assignment to the sect_syms array.
+                     To reproduce this particular case try running the
+                     linker testsuite test ld-scripts/weak.exp for an ELF
+                     port that uses the generic linker.  */
                   if (sec->owner == NULL)
                     continue;
@@ -2103 +2964 @@
     }
 
-  for (asect = abfd->sections; asect; asect = asect->next)
-    {
-      if (sect_syms[asect->index] != NULL)
-        continue;
-
-      sym = bfd_make_empty_symbol (abfd);
-      if (sym == NULL)
-        return false;
-      sym->the_bfd = abfd;
-      sym->name = asect->name;
-      sym->value = 0;
-      /* Set the flags to 0 to indicate that this one was newly added.  */
-      sym->flags = 0;
-      sym->section = asect;
-      sect_syms[asect->index] = sym;
-      num_sections++;
-#ifdef DEBUG
-      fprintf (stderr,
- _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
-               asect->name, (long) asect->vma, asect->index, (long) asect);
-#endif
-    }
-
   /* Classify all of the symbols.  */
   for (idx = 0; idx < symcount; idx++)
@@ -2134 +2972 @@
         num_globals++;
     }
+
+  /* We will be adding a section symbol for each BFD section.  Most normal
+     sections will already have a section symbol in outsymbols, but
+     eg. SHT_GROUP sections will not, and we need the section symbol mapped
+     at least in that case.  */
   for (asect = abfd->sections; asect; asect = asect->next)
     {
-      if (sect_syms[asect->index] != NULL
-          && sect_syms[asect->index]->flags == 0)
-        {
-          sect_syms[asect->index]->flags = BSF_SECTION_SYM;
-          if (!sym_is_global (abfd, sect_syms[asect->index]))
+      if (sect_syms[asect->index] == NULL)
+        {
+          if (!sym_is_global (abfd, asect->symbol))
             num_locals++;
           else
             num_globals++;
-          sect_syms[asect->index]->flags = 0;
         }
     }
 
   /* Now sort the symbols so the local symbols are first.  */
-  new_syms = ((asymbol **)
-              bfd_alloc (abfd,
-                         (num_locals + num_globals) * sizeof (asymbol *)));
+  amt = (num_locals + num_globals) * sizeof (asymbol *);
+  new_syms = (asymbol **) bfd_alloc (abfd, amt);
+
   if (new_syms == NULL)
-    return false;
+    return FALSE;
 
   for (idx = 0; idx < symcount; idx++)
     {
       asymbol *sym = syms[idx];
-      int i;
+      unsigned int i;
 
       if (!sym_is_global (abfd, sym))
@@ -2169 +3009 @@
   for (asect = abfd->sections; asect; asect = asect->next)
     {
-      if (sect_syms[asect->index] != NULL
-          && sect_syms[asect->index]->flags == 0)
-        {
-          asymbol *sym = sect_syms[asect->index];
-          int i;
-
-          sym->flags = BSF_SECTION_SYM;
+      if (sect_syms[asect->index] == NULL)
+        {
+          asymbol *sym = asect->symbol;
+          unsigned int i;
+
+          sect_syms[asect->index] = sym;
           if (!sym_is_global (abfd, sym))
             i = num_locals2++;
@@ -2189 +3028 @@
   elf_num_locals (abfd) = num_locals;
   elf_num_globals (abfd) = num_globals;
-  return true;
+  return TRUE;
 }
 
@@ -2195 +3034 @@
    ELF data structure.  */
 
-static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
+static INLINE file_ptr align_file_position
+  PARAMS ((file_ptr, int));
 static INLINE file_ptr
 align_file_position (off, align)
@@ -2211 +3051 @@
      Elf_Internal_Shdr *i_shdrp;
      file_ptr offset;
-     boolean align;
+     bfd_boolean align;
 {
   if (align)
@@ -2233 +3073 @@
    is not NULL, this is being called by the ELF backend linker.  */
 
-boolean
+bfd_boolean
 _bfd_elf_compute_section_file_positions (abfd, link_info)
      bfd *abfd;
@@ -2239 +3079 @@
 {
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
-  boolean failed;
+  bfd_boolean failed;
   struct bfd_strtab_hash *strtab;
   Elf_Internal_Shdr *shstrtab_hdr;
 
   if (abfd->output_has_begun)
-    return true;
+    return TRUE;
 
   /* Do any elf backend specific processing first.  */
@@ -2251 +3091 @@
 
   if (! prep_headers (abfd))
-    return false;
+    return FALSE;
 
   /* Post process the headers if necessary.  */
@@ -2257 +3097 @@
     (*bed->elf_backend_post_process_headers) (abfd, link_info);
 
-  failed = false;
+  failed = FALSE;
   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
   if (failed)
-    return false;
+    return FALSE;
 
   if (!assign_section_numbers (abfd))
-    return false;
+    return FALSE;
 
   /* The backend linker builds symbol table information itself.  */
@@ -2272 +3112 @@
 
       if (! swap_out_syms (abfd, &strtab, relocatable_p))
-        return false;
+        return FALSE;
+    }
+
+  if (link_info == NULL)
+    {
+      bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
+      if (failed)
+        return FALSE;
     }
 
@@ -2280 +3127 @@
   shstrtab_hdr->sh_flags = 0;
   shstrtab_hdr->sh_addr = 0;
-  shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
+  shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
   shstrtab_hdr->sh_entsize = 0;
   shstrtab_hdr->sh_link = 0;
@@ -2288 +3135 @@
 
   if (!assign_file_positions_except_relocs (abfd))
-    return false;
+    return FALSE;
 
   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
@@ -2298 +3145 @@
 
       hdr = &elf_tdata (abfd)->symtab_hdr;
-      off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+      off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
+
+      hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+      if (hdr->sh_size != 0)
+        off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
 
       hdr = &elf_tdata (abfd)->strtab_hdr;
-      off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+      off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
 
       elf_tdata (abfd)->next_file_pos = off;
@@ -2309 +3160 @@
       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
           || ! _bfd_stringtab_emit (abfd, strtab))
-        return false;
+        return FALSE;
       _bfd_stringtab_free (strtab);
     }
 
-  abfd->output_has_begun = true;
-
-  return true;
+  abfd->output_has_begun = TRUE;
+
+  return TRUE;
 }
 
@@ -2326 +3177 @@
      unsigned int from;
      unsigned int to;
-     boolean phdr;
+     bfd_boolean phdr;
 {
   struct elf_segment_map *m;
   unsigned int i;
   asection **hdrpp;
-
-  m = ((struct elf_segment_map *)
-       bfd_zalloc (abfd,
-                   (sizeof (struct elf_segment_map)
-                    + (to - from - 1) * sizeof (asection *))));
+  bfd_size_type amt;
+
+  amt = sizeof (struct elf_segment_map);
+  amt += (to - from - 1) * sizeof (asection *);
+  m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
   if (m == NULL)
     return NULL;
@@ -2356 +3207 @@
 /* Set up a mapping from BFD sections to program segments.  */
 
-static boolean
+static bfd_boolean
 map_sections_to_segments (abfd)
      bfd *abfd;
@@ -2371 +3222 @@
   bfd_vma maxpagesize;
   asection **hdrpp;
-  boolean phdr_in_segment = true;
-  boolean writable;
-  asection *dynsec;
+  bfd_boolean phdr_in_segment = TRUE;
+  bfd_boolean writable;
+  int tls_count = 0;
+  asection *first_tls = NULL;
+  asection *dynsec, *eh_frame_hdr;
+  bfd_size_type amt;
 
   if (elf_tdata (abfd)->segment_map != NULL)
-    return true;
+    return TRUE;
 
   if (bfd_count_sections (abfd) == 0)
-    return true;
+    return TRUE;
 
   /* Select the allocated sections, and sort them.  */
 
-  sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
-                                       * sizeof (asection *));
+  amt = bfd_count_sections (abfd) * sizeof (asection *);
+  sections = (asection **) bfd_malloc (amt);
   if (sections == NULL)
     goto error_return;
@@ -2413 +3267 @@
   if (s != NULL && (s->flags & SEC_LOAD) != 0)
     {
-      m = ((struct elf_segment_map *)
-           bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
+      amt = sizeof (struct elf_segment_map);
+      m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
       if (m == NULL)
         goto error_return;
@@ -2427 +3281 @@
       pm = &m->next;
 
-      m = ((struct elf_segment_map *)
-           bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
+      amt = sizeof (struct elf_segment_map);
+      m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
       if (m == NULL)
         goto error_return;
@@ -2446 +3300 @@
   phdr_index = 0;
   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
-  writable = false;
+  writable = FALSE;
   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
   if (dynsec != NULL
@@ -2466 +3320 @@
           || sections[0]->lma < phdr_size
           || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
-        phdr_in_segment = false;
+        phdr_in_segment = FALSE;
     }
 
@@ -2472 +3326 @@
     {
       asection *hdr;
-      boolean new_segment;
+      bfd_boolean new_segment;
 
       hdr = *hdrpp;
@@ -2483 +3337 @@
           /* If we don't have a segment yet, then we don't need a new
              one (we build the last one after this loop).  */
-          new_segment = false;
+          new_segment = FALSE;
         }
       else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
@@ -2490 +3344 @@
              virtual address and the load address, then we need a new
              segment.  */
-          new_segment = true;
+          new_segment = TRUE;
         }
       else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
@@ -2497 +3351 @@
           /* If putting this section in this segment would force us to
              skip a page in the segment, then we need a new segment.  */
-          new_segment = true;
+          new_segment = TRUE;
         }
       else if ((last_hdr->flags & SEC_LOAD) == 0
@@ -2504 +3358 @@
           /* We don't want to put a loadable section after a
              nonloadable section in the same segment.  */
-          new_segment = true;
+          new_segment = TRUE;
         }
       else if ((abfd->flags & D_PAGED) == 0)
@@ -2511 +3365 @@
              don't require the sections to be correctly aligned in the
              file, then there is no other reason for a new segment.  */
-          new_segment = false;
+          new_segment = FALSE;
         }
       else if (! writable
                && (hdr->flags & SEC_READONLY) == 0
-               && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
-                   == hdr->lma))
+               && (((last_hdr->lma + last_hdr->_raw_size - 1)
+                    & ~(maxpagesize - 1))
+                   != (hdr->lma & ~(maxpagesize - 1))))
         {
           /* We don't want to put a writable section in a read only
@@ -2525 +3380 @@
              page as the previous section is when the previous section
              ends precisely on a page boundary.  */
-          new_segment = true;
+          new_segment = TRUE;
         }
       else
         {
           /* Otherwise, we can use the same segment.  */
-          new_segment = false;
+          new_segment = FALSE;
         }
 
@@ -2536 +3391 @@
         {
           if ((hdr->flags & SEC_READONLY) == 0)
-            writable = true;
+            writable = TRUE;
           last_hdr = hdr;
           continue;
@@ -2552 +3407 @@
 
       if ((hdr->flags & SEC_READONLY) == 0)
-        writable = true;
+        writable = TRUE;
       else
-        writable = false;
+        writable = FALSE;
 
       last_hdr = hdr;
       phdr_index = i;
-      phdr_in_segment = false;
+      phdr_in_segment = FALSE;
     }
 
@@ -2575 +3430 @@
   if (dynsec != NULL)
     {
-      m = ((struct elf_segment_map *)
-           bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
+      amt = sizeof (struct elf_segment_map);
+      m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
       if (m == NULL)
         goto error_return;
@@ -2598 +3453 @@
           && strncmp (s->name, ".note", 5) == 0)
         {
-          m = ((struct elf_segment_map *)
-               bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
+          amt = sizeof (struct elf_segment_map);
+          m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
           if (m == NULL)
             goto error_return;
@@ -2610 +3465 @@
           pm = &m->next;
         }
+      if (s->flags & SEC_THREAD_LOCAL)
+        {
+          if (! tls_count)
+            first_tls = s;
+          tls_count++;
+        }
+    }
+
+  /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
+  if (tls_count > 0)
+    {
+      int i;
+
+      amt = sizeof (struct elf_segment_map);
+      amt += (tls_count - 1) * sizeof (asection *);
+      m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+      if (m == NULL)
+        goto error_return;
+      m->next = NULL;
+      m->p_type = PT_TLS;
+      m->count = tls_count;
+      /* Mandated PF_R.  */
+      m->p_flags = PF_R;
+      m->p_flags_valid = 1;
+      for (i = 0; i < tls_count; ++i)
+        {
+          BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
+          m->sections[i] = first_tls;
+          first_tls = first_tls->next;
+        }
+
+      *pm = m;
+      pm = &m->next;
+    }
+
+  /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
+     segment.  */
+  eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
+  if (eh_frame_hdr != NULL
+      && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
+    {
+      amt = sizeof (struct elf_segment_map);
+      m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
+      if (m == NULL)
+        goto error_return;
+      m->next = NULL;
+      m->p_type = PT_GNU_EH_FRAME;
+      m->count = 1;
+      m->sections[0] = eh_frame_hdr->output_section;
+
+      *pm = m;
+      pm = &m->next;
     }
 
@@ -2616 +3523 @@
 
   elf_tdata (abfd)->segment_map = mfirst;
-  return true;
+  return TRUE;
 
  error_return:
   if (sections != NULL)
     free (sections);
-  return false;
+  return FALSE;
 }
 
@@ -2633 +3540 @@
   const asection *sec1 = *(const asection **) arg1;
   const asection *sec2 = *(const asection **) arg2;
+  bfd_size_type size1, size2;
 
   /* Sort by LMA first, since this is the address used to
@@ -2650 +3558 @@
   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
 
-#define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
+#define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
 
   if (TOEND (sec1))
     {
       if (TOEND (sec2))
-        return sec1->target_index - sec2->target_index;
+        {
+          /* If the indicies are the same, do not return 0
+             here, but continue to try the next comparison.  */
+          if (sec1->target_index - sec2->target_index != 0)
+            return sec1->target_index - sec2->target_index;
+        }
       else
         return 1;
     }
-
-  if (TOEND (sec2))
+  else if (TOEND (sec2))
     return -1;
 
 #undef TOEND
 
-  /* Sort by size, to put zero sized sections before others at the
-     same address.  */
-
-  if (sec1->_raw_size < sec2->_raw_size)
+  /* Sort by size, to put zero sized sections
+     before others at the same address.  */
+
+  size1 = (sec1->flags & SEC_LOAD) ? sec1->_raw_size : 0;
+  size2 = (sec2->flags & SEC_LOAD) ? sec2->_raw_size : 0;
+
+  if (size1 < size2)
     return -1;
-  if (sec1->_raw_size > sec2->_raw_size)
+  if (size1 > size2)
     return 1;
 
@@ -2680 +3595 @@
    the file header, and writes out the program headers.  */
 
-static boolean
+static bfd_boolean
 assign_file_positions_for_segments (abfd)
      bfd *abfd;
@@ -2693 +3608 @@
   bfd_vma phdrs_vaddr, phdrs_paddr;
   Elf_Internal_Phdr *p;
+  bfd_size_type amt;
 
   if (elf_tdata (abfd)->segment_map == NULL)
     {
       if (! map_sections_to_segments (abfd))
-        return false;
+        return FALSE;
+    }
+  else
+    {
+      /* The placement algorithm assumes that non allocated sections are
+         not in PT_LOAD segments.  We ensure this here by removing such
+         sections from the segment map.  */
+      for (m = elf_tdata (abfd)->segment_map;
+           m != NULL;
+           m = m->next)
+        {
+          unsigned int new_count;
+          unsigned int i;
+
+          if (m->p_type != PT_LOAD)
+            continue;
+
+          new_count = 0;
+          for (i = 0; i < m->count; i ++)
+            {
+              if ((m->sections[i]->flags & SEC_ALLOC) != 0)
+                {
+                  if (i != new_count)
+                    m->sections[new_count] = m->sections[i];
+
+                  new_count ++;
+                }
+            }
+
+          if (new_count != m->count)
+            m->count = new_count;
+        }
     }
 
@@ -2703 +3650 @@
     {
       if (! (*bed->elf_backend_modify_segment_map) (abfd))
-        return false;
+        return FALSE;
     }
 
@@ -2715 +3662 @@
 
   if (count == 0)
-    return true;
+    return TRUE;
 
   /* If we already counted the number of program segments, make sure
@@ -2727 +3674 @@
         bfd_get_filename (abfd), alloc, count));
       bfd_set_error (bfd_error_bad_value);
-      return false;
+      return FALSE;
     }
 
@@ -2733 +3680 @@
     alloc = count;
 
-  phdrs = ((Elf_Internal_Phdr *)
-           bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
+  amt = alloc * sizeof (Elf_Internal_Phdr);
+  phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
   if (phdrs == NULL)
-    return false;
+    return FALSE;
 
   off = bed->s->sizeof_ehdr;
@@ -2754 +3701 @@
 
       /* If elf_segment_map is not from map_sections_to_segments, the
-         sections may not be correctly ordered.  */
-      if (m->count > 0)
+         sections may not be correctly ordered.  NOTE: sorting should
+         not be done to the PT_NOTE section of a corefile, which may
+         contain several pseudo-sections artificially created by bfd.
+         Sorting these pseudo-sections breaks things badly.  */
+      if (m->count > 1
+          && !(elf_elfheader (abfd)->e_type == ET_CORE
+               && m->p_type == PT_NOTE))
         qsort (m->sections, (size_t) m->count, sizeof (asection *),
                elf_sort_sections);
@@ -2823 +3775 @@
               if (p->p_vaddr < (bfd_vma) off)
                 {
-                  _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
-                                      bfd_get_filename (abfd));
+                  (*_bfd_error_handler)
+                    (_("%s: Not enough room for program headers, try linking with -N"),
+                     bfd_get_filename (abfd));
                   bfd_set_error (bfd_error_bad_value);
-                  return false;
+                  return FALSE;
                 }
 
@@ -2907 +3860 @@
           /* The section may have artificial alignment forced by a
              link script.  Notice this case by the gap between the
-             cumulative phdr vma and the section's vma.  */
-          if (p->p_vaddr + p->p_memsz < sec->vma)
+             cumulative phdr lma and the section's lma.  */
+          if (p->p_paddr + p->p_memsz < sec->lma)
             {
-              bfd_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
+              bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
 
               p->p_memsz += adjust;
-              off += adjust;
-              voff += adjust;
-              if ((flags & SEC_LOAD) != 0)
+              if (p->p_type == PT_LOAD
+                  || (p->p_type == PT_NOTE
+                      && bfd_get_format (abfd) == bfd_core))
+                {
+                  off += adjust;
+                  voff += adjust;
+                }
+              if ((flags & SEC_LOAD) != 0
+                  || (flags & SEC_THREAD_LOCAL) != 0)
                 p->p_filesz += adjust;
             }
@@ -2948 +3907 @@
                   if (i == 0)
                     {
-                      (* _bfd_error_handler)
-                        (_("Error: First section in segment (%s) starts at 0x%x"),
-                         bfd_section_name (abfd, sec), sec->lma);
-                      (* _bfd_error_handler)
-                        (_("       whereas segment starts at 0x%x"),
-                         p->p_paddr);
-
-                      return false;
+                      (* _bfd_error_handler) (_("\
+Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
+                                              bfd_section_name (abfd, sec),
+                                              sec->lma,
+                                              p->p_paddr);
+                      return FALSE;
                     }
                   p->p_memsz += adjust;
@@ -2974 +3931 @@
                 off += sec->_raw_size;
 
-              if ((flags & SEC_ALLOC) != 0)
+              if ((flags & SEC_ALLOC) != 0
+                  && ((flags & SEC_LOAD) != 0
+                      || (flags & SEC_THREAD_LOCAL) == 0))
                 voff += sec->_raw_size;
             }
@@ -3001 +3960 @@
           else
             {
+              if ((sec->flags & SEC_LOAD) != 0
+                  || (sec->flags & SEC_THREAD_LOCAL) == 0
+                  || p->p_type == PT_TLS)
               p->p_memsz += sec->_raw_size;
 
               if ((flags & SEC_LOAD) != 0)
                 p->p_filesz += sec->_raw_size;
+
+              if (p->p_type == PT_TLS
+                  && sec->_raw_size == 0
+                  && (sec->flags & SEC_HAS_CONTENTS) == 0)
+                {
+                  struct bfd_link_order *o;
+                  bfd_vma tbss_size = 0;
+
+                  for (o = sec->link_order_head; o != NULL; o = o->next)
+                    if (tbss_size < o->offset + o->size)
+                      tbss_size = o->offset + o->size;
+
+                  p->p_memsz += tbss_size;
+                }
 
               if (align > p->p_align
@@ -3062 +4038 @@
 
   /* Write out the program headers.  */
-  if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
+  if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
       || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
-    return false;
-
-  return true;
+    return FALSE;
+
+  return TRUE;
 }
 
@@ -3123 +4099 @@
     }
 
+  if (elf_tdata (abfd)->eh_frame_hdr)
+    {
+      /* We need a PT_GNU_EH_FRAME segment.  */
+      ++segs;
+    }
+
   for (s = abfd->sections; s != NULL; s = s->next)
     {
@@ -3130 +4112 @@
           /* We need a PT_NOTE segment.  */
           ++segs;
+        }
+    }
+
+  for (s = abfd->sections; s != NULL; s = s->next)
+    {
+      if (s->flags & SEC_THREAD_LOCAL)
+        {
+          /* We need a PT_TLS segment.  */
+          ++segs;
+          break;
         }
     }
@@ -3159 +4151 @@
    We also don't set the positions of the .symtab and .strtab here.  */
 
-static boolean
+static bfd_boolean
 assign_file_positions_except_relocs (abfd)
      bfd *abfd;
@@ -3166 +4158 @@
   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
+  unsigned int num_sec = elf_numsections (abfd);
   file_ptr off;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
@@ -3181 +4174 @@
          not creating a program header, and that the actual order of
          the sections in the file is unimportant.  */
-      for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
+      for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
         {
           Elf_Internal_Shdr *hdr;
 
           hdr = *hdrpp;
-          if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
-            {
-              hdr->sh_offset = -1;
-              continue;
-            }
-          if (i == tdata->symtab_section
+          if (hdr->sh_type == SHT_REL
+              || hdr->sh_type == SHT_RELA
+              || i == tdata->symtab_section
+              || i == tdata->symtab_shndx_section
               || i == tdata->strtab_section)
             {
               hdr->sh_offset = -1;
-              continue;
             }
-
-          off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+          else
+            off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
+
+          if (i == SHN_LORESERVE - 1)
+            {
+              i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
+              hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
+            }
         }
     }
@@ -3209 +4205 @@
          assignment of sections to segments.  */
       if (! assign_file_positions_for_segments (abfd))
-        return false;
+        return FALSE;
 
       /* Assign file positions for the other sections.  */
 
       off = elf_tdata (abfd)->next_file_pos;
-      for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
+      for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
         {
           Elf_Internal_Shdr *hdr;
@@ -3235 +4231 @@
                 off += (hdr->sh_addr - off) % hdr->sh_addralign;
               off = _bfd_elf_assign_file_position_for_section (hdr, off,
-                                                               false);
+                                                               FALSE);
             }
           else if (hdr->sh_type == SHT_REL
                    || hdr->sh_type == SHT_RELA
                    || hdr == i_shdrpp[tdata->symtab_section]
+                   || hdr == i_shdrpp[tdata->symtab_shndx_section]
                    || hdr == i_shdrpp[tdata->strtab_section])
             hdr->sh_offset = -1;
           else
-            off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
+            off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
+
+          if (i == SHN_LORESERVE - 1)
+            {
+              i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
+              hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
+            }
         }
     }
@@ -3254 +4257 @@
   elf_tdata (abfd)->next_file_pos = off;
 
-  return true;
-}
-
-static boolean
+  return TRUE;
+}
+
+static bfd_boolean
 prep_headers (abfd)
      bfd *abfd;
@@ -3264 +4267 @@
   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
-  int count;
-  struct bfd_strtab_hash *shstrtab;
+  struct elf_strtab_hash *shstrtab;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
 
@@ -3271 +4273 @@
   i_shdrp = elf_elfsections (abfd);
 
-  shstrtab = _bfd_elf_stringtab_init ();
+  shstrtab = _bfd_elf_strtab_init ();
   if (shstrtab == NULL)
-    return false;
+    return FALSE;
 
   elf_shstrtab (abfd) = shstrtab;
@@ -3286 +4288 @@
     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
-
-  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NONE;
-  i_ehdrp->e_ident[EI_ABIVERSION] = 0;
-
-  for (count = EI_PAD; count < EI_NIDENT; count++)
-    i_ehdrp->e_ident[count] = 0;
 
   if ((abfd->flags & DYNAMIC) != 0)
@@ -3307 +4303 @@
       i_ehdrp->e_machine = EM_NONE;
       break;
-    case bfd_arch_sparc:
-      if (bfd_get_arch_size (abfd) == 64)
-        i_ehdrp->e_machine = EM_SPARCV9;
+
+      /* There used to be a long list of cases here, each one setting
+         e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
+         in the corresponding bfd definition.  To avoid duplication,
+         the switch was removed.  Machines that need special handling
+         can generally do it in elf_backend_final_write_processing(),
+         unless they need the information earlier than the final write.
+         Such need can generally be supplied by replacing the tests for
+         e_machine with the conditions used to determine it.  */
+    default:
+      if (get_elf_backend_data (abfd) != NULL)
+        i_ehdrp->e_machine = get_elf_backend_data (abfd)->elf_machine_code;
       else
-        i_ehdrp->e_machine = EM_SPARC;
-      break;
-    case bfd_arch_i370:
-      i_ehdrp->e_machine = EM_S370;
-      break;
-    case bfd_arch_i386:
-      if (bfd_get_arch_size (abfd) == 64)
-        i_ehdrp->e_machine = EM_X86_64;
-      else
-        i_ehdrp->e_machine = EM_386;
-      break;
-    case bfd_arch_ia64:
-      i_ehdrp->e_machine = EM_IA_64;
-      break;
-    case bfd_arch_m68hc11:
-      i_ehdrp->e_machine = EM_68HC11;
-      break;
-    case bfd_arch_m68hc12:
-      i_ehdrp->e_machine = EM_68HC12;
-      break;
-    case bfd_arch_m68k:
-      i_ehdrp->e_machine = EM_68K;
-      break;
-    case bfd_arch_m88k:
-      i_ehdrp->e_machine = EM_88K;
-      break;
-    case bfd_arch_i860:
-      i_ehdrp->e_machine = EM_860;
-      break;
-    case bfd_arch_i960:
-      i_ehdrp->e_machine = EM_960;
-      break;
-    case bfd_arch_mips: /* MIPS Rxxxx */
-      i_ehdrp->e_machine = EM_MIPS;     /* only MIPS R3000 */
-      break;
-    case bfd_arch_hppa:
-      i_ehdrp->e_machine = EM_PARISC;
-      break;
-    case bfd_arch_powerpc:
-      i_ehdrp->e_machine = EM_PPC;
-      break;
-    case bfd_arch_alpha:
-      i_ehdrp->e_machine = EM_ALPHA;
-      break;
-    case bfd_arch_sh:
-      i_ehdrp->e_machine = EM_SH;
-      break;
-    case bfd_arch_d10v:
-      i_ehdrp->e_machine = EM_CYGNUS_D10V;
-      break;
-    case bfd_arch_d30v:
-      i_ehdrp->e_machine = EM_CYGNUS_D30V;
-      break;
-    case bfd_arch_fr30:
-      i_ehdrp->e_machine = EM_CYGNUS_FR30;
-      break;
-    case bfd_arch_mcore:
-      i_ehdrp->e_machine = EM_MCORE;
-      break;
-    case bfd_arch_avr:
-      i_ehdrp->e_machine = EM_AVR;
-      break;
-    case bfd_arch_v850:
-      switch (bfd_get_mach (abfd))
-        {
-        default:
-        case 0:               i_ehdrp->e_machine = EM_CYGNUS_V850; break;
-        }
-      break;
-    case bfd_arch_arc:
-      i_ehdrp->e_machine = EM_CYGNUS_ARC;
-      break;
-    case bfd_arch_arm:
-      i_ehdrp->e_machine = EM_ARM;
-      break;
-    case bfd_arch_m32r:
-      i_ehdrp->e_machine = EM_CYGNUS_M32R;
-      break;
-    case bfd_arch_mn10200:
-      i_ehdrp->e_machine = EM_CYGNUS_MN10200;
-      break;
-    case bfd_arch_mn10300:
-      i_ehdrp->e_machine = EM_CYGNUS_MN10300;
-      break;
-    case bfd_arch_pj:
-      i_ehdrp->e_machine = EM_PJ;
-      break;
-    case bfd_arch_cris:
-      i_ehdrp->e_machine = EM_CRIS;
-      break;
-      /* Also note that EM_M32, AT&T WE32100 is unknown to bfd.  */
-    default:
-      i_ehdrp->e_machine = EM_NONE;
-    }
+        i_ehdrp->e_machine = EM_NONE;
+      }
+
   i_ehdrp->e_version = bed->s->ev_current;
   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
@@ -3439 +4353 @@
 
   elf_tdata (abfd)->symtab_hdr.sh_name =
-    (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
+    (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
   elf_tdata (abfd)->strtab_hdr.sh_name =
-    (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
+    (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
   elf_tdata (abfd)->shstrtab_hdr.sh_name =
-    (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
+    (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
-    return false;
-
-  return true;
+    return FALSE;
+
+  return TRUE;
 }
 
@@ -3460 +4374 @@
 {
   file_ptr off;
-  unsigned int i;
+  unsigned int i, num_sec;
   Elf_Internal_Shdr **shdrpp;
 
   off = elf_tdata (abfd)->next_file_pos;
 
-  for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
-       i < elf_elfheader (abfd)->e_shnum;
-       i++, shdrpp++)
+  num_sec = elf_numsections (abfd);
+  for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
     {
       Elf_Internal_Shdr *shdrp;
@@ -3474 +4387 @@
       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
           && shdrp->sh_offset == -1)
-        off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
+        off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
     }
 
@@ -3480 +4393 @@
 }
 
-boolean
+bfd_boolean
 _bfd_elf_write_object_contents (abfd)
      bfd *abfd;
@@ -3487 +4400 @@
   Elf_Internal_Ehdr *i_ehdrp;
   Elf_Internal_Shdr **i_shdrp;
-  boolean failed;
-  unsigned int count;
+  bfd_boolean failed;
+  unsigned int count, num_sec;
 
   if (! abfd->output_has_begun
       && ! _bfd_elf_compute_section_file_positions
              (abfd, (struct bfd_link_info *) NULL))
-    return false;
+    return FALSE;
 
   i_shdrp = elf_elfsections (abfd);
   i_ehdrp = elf_elfheader (abfd);
 
-  failed = false;
+  failed = FALSE;
   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
   if (failed)
-    return false;
+    return FALSE;
 
   _bfd_elf_assign_file_positions_for_relocs (abfd);
 
   /* After writing the headers, we need to write the sections too...  */
-  for (count = 1; count < i_ehdrp->e_shnum; count++)
+  num_sec = elf_numsections (abfd);
+  for (count = 1; count < num_sec; count++)
     {
       if (bed->elf_backend_section_processing)
@@ -3512 +4426 @@
       if (i_shdrp[count]->contents)
         {
+          bfd_size_type amt = i_shdrp[count]->sh_size;
+
           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
-              || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
-                             1, abfd)
-                  != i_shdrp[count]->sh_size))
-            return false;
-        }
+              || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
+            return FALSE;
+        }
+      if (count == SHN_LORESERVE - 1)
+        count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
     }
 
   /* Write out the section header names.  */
   if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
-      || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
-    return false;
+      || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
+    return FALSE;
 
   if (bed->elf_backend_final_write_processing)
@@ -3532 +4448 @@
 }
 
-boolean
+bfd_boolean
 _bfd_elf_write_corefile_contents (abfd)
      bfd *abfd;
@@ -3547 +4463 @@
      struct sec *asect;
 {
-  struct elf_backend_data *bed = get_elf_backend_data (abfd);
-  Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
+  struct elf_backend_data *bed;
   int index;
-  Elf_Internal_Shdr *hdr;
-  int maxindex = elf_elfheader (abfd)->e_shnum;
-
-  for (index = 0; index < maxindex; index++)
-    {
-      hdr = i_shdrp[index];
-      if (hdr->bfd_section == asect)
-        return index;
-    }
-
+
+  if (elf_section_data (asect) != NULL
+      && elf_section_data (asect)->this_idx != 0)
+    return elf_section_data (asect)->this_idx;
+
+  if (bfd_is_abs_section (asect))
+    index = SHN_ABS;
+  else if (bfd_is_com_section (asect))
+    index = SHN_COMMON;
+  else if (bfd_is_und_section (asect))
+    index = SHN_UNDEF;
+  else
+    {
+      Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
+      int maxindex = elf_numsections (abfd);
+
+      for (index = 1; index < maxindex; index++)
+        {
+          Elf_Internal_Shdr *hdr = i_shdrp[index];
+
+          if (hdr != NULL && hdr->bfd_section == asect)
+            return index;
+        }
+      index = -1;
+    }
+
+  bed = get_elf_backend_data (abfd);
   if (bed->elf_backend_section_from_bfd_section)
     {
-      for (index = 0; index < maxindex; index++)
-        {
-          int retval;
-
-          hdr = i_shdrp[index];
-          retval = index;
-          if ((*bed->elf_backend_section_from_bfd_section)
-              (abfd, hdr, asect, &retval))
-            return retval;
-        }
-    }
-
-  if (bfd_is_abs_section (asect))
-    return SHN_ABS;
-  if (bfd_is_com_section (asect))
-    return SHN_COMMON;
-  if (bfd_is_und_section (asect))
-    return SHN_UNDEF;
-
-  bfd_set_error (bfd_error_nonrepresentable_section);
-
-  return -1;
+      int retval = index;
+
+      if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
+        return retval;
+    }
+
+  if (index == -1)
+    bfd_set_error (bfd_error_nonrepresentable_section);
+
+  return index;
 }
 
@@ -3613 +4533 @@
       else
         indx = asym_ptr->section->index;
-      if (elf_section_syms (abfd)[indx])
+      if (indx < elf_num_section_syms (abfd)
+          && elf_section_syms (abfd)[indx] != NULL)
         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
     }
@@ -3625 +4546 @@
       (*_bfd_error_handler)
         (_("%s: symbol `%s' required but not present"),
-         bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
+         bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
       bfd_set_error (bfd_error_no_symbols);
       return -1;
@@ -3633 +4554 @@
   {
     fprintf (stderr,
-             _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
+             "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
              (long) asym_ptr, asym_ptr->name, idx, flags,
              elf_symbol_flags (flags));
@@ -3645 +4566 @@
 /* Copy private BFD data.  This copies any program header information.  */
 
-static boolean
+static bfd_boolean
 copy_private_bfd_data (ibfd, obfd)
      bfd *ibfd;
      bfd *obfd;
 {
-  Elf_Internal_Ehdr *       iehdr;
-  struct elf_segment_map *  map;
-  struct elf_segment_map *  map_first;
-  struct elf_segment_map ** pointer_to_map;
-  Elf_Internal_Phdr *       segment;
-  asection *                section;
-  unsigned int              i;
-  unsigned int              num_segments;
-  boolean                   phdr_included = false;
-  bfd_vma                   maxpagesize;
-  struct elf_segment_map *  phdr_adjust_seg = NULL;
-  unsigned int              phdr_adjust_num = 0;
+  Elf_Internal_Ehdr *iehdr;
+  struct elf_segment_map *map;
+  struct elf_segment_map *map_first;
+  struct elf_segment_map **pointer_to_map;
+  Elf_Internal_Phdr *segment;
+  asection *section;
+  unsigned int i;
+  unsigned int num_segments;
+  bfd_boolean phdr_included = FALSE;
+  bfd_vma maxpagesize;
+  struct elf_segment_map *phdr_adjust_seg = NULL;
+  unsigned int phdr_adjust_num = 0;
+  struct elf_backend_data *bed;
 
   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
-    return true;
+    return TRUE;
 
   if (elf_tdata (ibfd)->phdr == NULL)
-    return true;
-
+    return TRUE;
+
+  bed = get_elf_backend_data (ibfd);
   iehdr = elf_elfheader (ibfd);
 
@@ -3679 +4602 @@
 
   /* Returns the end address of the segment + 1.  */
-#define SEGMENT_END(segment, start)                     \
-  (start + (segment->p_memsz > segment->p_filesz        \
-   ? segment->p_memsz : segment->p_filesz))
-
-  /* Returns true if the given section is contained within
+#define SEGMENT_END(segment, start)                                     \
+  (start + (segment->p_memsz > segment->p_filesz                        \
+            ? segment->p_memsz : segment->p_filesz))
+
+#define SECTION_SIZE(section, segment)                                  \
+  (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
+    != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
+   ? section->_raw_size : 0)
+
+  /* Returns TRUE if the given section is contained within
      the given segment.  VMA addresses are compared.  */
-#define IS_CONTAINED_BY_VMA(section, segment)           \
-  (section->vma >= segment->p_vaddr                     \
-   && (section->vma + section->_raw_size)               \
-   <= (SEGMENT_END (segment, segment->p_vaddr)))
-
-  /* Returns true if the given section is contained within
+#define IS_CONTAINED_BY_VMA(section, segment)                           \
+  (section->vma >= segment->p_vaddr                                     \
+   && (section->vma + SECTION_SIZE (section, segment)                   \
+       <= (SEGMENT_END (segment, segment->p_vaddr))))
+
+  /* Returns TRUE if the given section is contained within
      the given segment.  LMA addresses are compared.  */
-#define IS_CONTAINED_BY_LMA(section, segment, base)     \
-    (section->lma >= base                               \
-     && (section->lma + section->_raw_size)             \
-     <= SEGMENT_END (segment, base))
+#define IS_CONTAINED_BY_LMA(section, segment, base)                     \
+  (section->lma >= base                                                 \
+   && (section->lma + SECTION_SIZE (section, segment)                   \
+       <= SEGMENT_END (segment, base)))
 
   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
-#define IS_COREFILE_NOTE(p, s)                          \
-            (p->p_type == PT_NOTE                       \
-             && bfd_get_format (ibfd) == bfd_core       \
-             && s->vma == 0 && s->lma == 0              \
-             && (bfd_vma) s->filepos >= p->p_offset     \
-             && (bfd_vma) s->filepos + s->_raw_size     \
-             <= p->p_offset + p->p_filesz)
+#define IS_COREFILE_NOTE(p, s)                                          \
+  (p->p_type == PT_NOTE                                                 \
+   && bfd_get_format (ibfd) == bfd_core                                 \
+   && s->vma == 0 && s->lma == 0                                        \
+   && (bfd_vma) s->filepos >= p->p_offset                               \
+   && ((bfd_vma) s->filepos + s->_raw_size                              \
+       <= p->p_offset + p->p_filesz))
 
   /* The complicated case when p_vaddr is 0 is to handle the Solaris
      linker, which generates a PT_INTERP section with p_vaddr and
      p_memsz set to 0.  */
-#define IS_SOLARIS_PT_INTERP(p, s)                      \
-            (   p->p_vaddr == 0                         \
-             && p->p_filesz > 0                         \
-             && (s->flags & SEC_HAS_CONTENTS) != 0      \
-             && s->_raw_size > 0                        \
-             && (bfd_vma) s->filepos >= p->p_offset     \
-             && ((bfd_vma) s->filepos + s->_raw_size    \
-                     <= p->p_offset + p->p_filesz))
+#define IS_SOLARIS_PT_INTERP(p, s)                                      \
+  (p->p_vaddr == 0                                                      \
+   && p->p_paddr == 0                                                   \
+   && p->p_memsz == 0                                                   \
+   && p->p_filesz > 0                                                   \
+   && (s->flags & SEC_HAS_CONTENTS) != 0                                \
+   && s->_raw_size > 0                                                  \
+   && (bfd_vma) s->filepos >= p->p_offset                               \
+   && ((bfd_vma) s->filepos + s->_raw_size                              \
+       <= p->p_offset + p->p_filesz))
 
   /* Decide if the given section should be included in the given segment.
      A section will be included if:
-       1. It is within the address space of the segment,
+       1. It is within the address space of the segment -- we use the LMA
+          if that is set for the segment and the VMA otherwise,
        2. It is an allocated segment,
        3. There is an output section associated with it,
-       4. The section has not already been allocated to a previous segment.  */
-#define INCLUDE_SECTION_IN_SEGMENT(section, segment)    \
-  ((((IS_CONTAINED_BY_VMA (section, segment)            \
-      || IS_SOLARIS_PT_INTERP (segment, section))       \
-     && (section->flags & SEC_ALLOC) != 0)              \
-    || IS_COREFILE_NOTE (segment, section))             \
-   && section->output_section != NULL                   \
-   && section->segment_mark == false)
-
-  /* Returns true iff seg1 starts after the end of seg2.  */
-#define SEGMENT_AFTER_SEGMENT(seg1, seg2)               \
-    (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
-
-  /* Returns true iff seg1 and seg2 overlap.  */
-#define SEGMENT_OVERLAPS(seg1, seg2)                    \
-  (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
+       4. The section has not already been allocated to a previous segment.
+       5. PT_TLS segment includes only SHF_TLS sections.
+       6. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.  */
+#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
+  ((((segment->p_paddr                                                  \
+      ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
+      : IS_CONTAINED_BY_VMA (section, segment))                         \
+     && (section->flags & SEC_ALLOC) != 0)                              \
+    || IS_COREFILE_NOTE (segment, section))                             \
+   && section->output_section != NULL                                   \
+   && (segment->p_type != PT_TLS                                        \
+       || (section->flags & SEC_THREAD_LOCAL))                          \
+   && (segment->p_type == PT_LOAD                                       \
+       || segment->p_type == PT_TLS                                     \
+       || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
+   && ! section->segment_mark)
+
+  /* Returns TRUE iff seg1 starts after the end of seg2.  */
+#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
+  (seg1->field >= SEGMENT_END (seg2, seg2->field))
+
+  /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
+     their VMA address ranges and their LMA address ranges overlap.
+     It is possible to have overlapping VMA ranges without overlapping LMA
+     ranges.  RedBoot images for example can have both .data and .bss mapped
+     to the same VMA range, but with the .data section mapped to a different
+     LMA.  */
+#define SEGMENT_OVERLAPS(seg1, seg2)                                    \
+  (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
+        || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
+   && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
+        || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
 
   /* Initialise the segment mark field.  */
   for (section = ibfd->sections; section != NULL; section = section->next)
-    section->segment_mark = false;
+    section->segment_mark = FALSE;
 
   /* Scan through the segments specified in the program header
      of the input BFD.  For this first scan we look for overlaps
-     in the loadable segments.  These can be created by wierd
-     parameters to objcopy.  */
+     in the loadable segments.  These can be created by weird
+     parameters to objcopy.  Also, fix some solaris weirdness.  */
   for (i = 0, segment = elf_tdata (ibfd)->phdr;
        i < num_segments;
@@ -3754 +4701 @@
       unsigned int j;
       Elf_Internal_Phdr *segment2;
+
+      if (segment->p_type == PT_INTERP)
+        for (section = ibfd->sections; section; section = section->next)
+          if (IS_SOLARIS_PT_INTERP (segment, section))
+            {
+              /* Mininal change so that the normal section to segment
+                 assigment code will work.  */
+              segment->p_vaddr = section->vma;
+              break;
+            }
 
       if (segment->p_type != PT_LOAD)
@@ -3820 +4777 @@
       bfd_vma       suggested_lma;
       unsigned int  j;
+      bfd_size_type amt;
 
       if (segment->p_type == PT_NULL)
@@ -3825 +4783 @@
 
       /* Compute how many sections might be placed into this segment.  */
-      section_count = 0;
-      for (section = ibfd->sections; section != NULL; section = section->next)
-        if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
+      for (section = ibfd->sections, section_count = 0;
+           section != NULL;
+           section = section->next)
+        if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
           ++section_count;
 
-      /* Allocate a segment map big enough to contain all of the
-         sections we have selected.  */
-      map = ((struct elf_segment_map *)
-           bfd_alloc (obfd,
-                      (sizeof (struct elf_segment_map)
-                       + ((size_t) section_count - 1) * sizeof (asection *))));
+      /* Allocate a segment map big enough to contain
+         all of the sections we have selected.  */
+      amt = sizeof (struct elf_segment_map);
+      amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
+      map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
       if (map == NULL)
-        return false;
+        return FALSE;
 
       /* Initialise the fields of the segment map.  Default to
@@ -3864 +4822 @@
 
           if (segment->p_type == PT_LOAD && map->includes_phdrs)
-            phdr_included = true;
+            phdr_included = TRUE;
         }
 
@@ -3871 +4829 @@
           /* Special segments, such as the PT_PHDR segment, may contain
              no sections, but ordinary, loadable segments should contain
-             something.  */
+             something.  They are allowed by the ELF spec however, so only
+             a warning is produced.  */
           if (segment->p_type == PT_LOAD)
-              _bfd_error_handler
-                (_("%s: warning: Empty loadable segment detected\n"),
-                 bfd_get_filename (ibfd));
+            (*_bfd_error_handler)
+              (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
+               bfd_archive_filename (ibfd));
 
           map->count = 0;
@@ -3903 +4862 @@
             have to be created to contain the other sections.
 
-         4. The sections have been moved, but not be the same amount.
+         4. The sections have been moved, but not by the same amount.
             In this case we can change the segment's LMA to match the LMA
             of the first section and we will have to create a new segment
@@ -3912 +4871 @@
          to a segment, they are removed from this array.  */
 
-      sections = (asection **) bfd_malloc
-        (sizeof (asection *) * section_count);
+      /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
+         to work around this long long bug.  */
+      amt = section_count * sizeof (asection *);
+      sections = (asection **) bfd_malloc (amt);
       if (sections == NULL)
-        return false;
+        return FALSE;
 
       /* Step One: Scan for segment vs section LMA conflicts.
@@ -3931 +4892 @@
            section = section->next)
         {
-          if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
+          if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
             {
               output_section = section->output_section;
@@ -3939 +4900 @@
               /* The Solaris native linker always sets p_paddr to 0.
                  We try to catch that case here, and set it to the
-                 correct value.  */
+                 correct value.  Note - some backends require that
+                 p_paddr be left as zero.  */
               if (segment->p_paddr == 0
                   && segment->p_vaddr != 0
+                  && (! bed->want_p_paddr_set_to_zero)
                   && isec == 0
                   && output_section->lma != 0
@@ -3949 +4912 @@
                                                  : 0)
                                               + (map->includes_phdrs
-                                                 ? iehdr->e_phnum * iehdr->e_phentsize
+                                                 ? (iehdr->e_phnum
+                                                    * iehdr->e_phentsize)
                                                  : 0))))
                 map->p_paddr = segment->p_vaddr;
@@ -3956 +4920 @@
                  LMA address of the output section.  */
               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
-                  || IS_COREFILE_NOTE (segment, section))
+                  || IS_COREFILE_NOTE (segment, section)
+                  || (bed->want_p_paddr_set_to_zero &&
+                      IS_CONTAINED_BY_VMA (output_section, segment))
+                )
                 {
                   if (matching_lma == 0)
@@ -4025 +4992 @@
 
       /* Step Three: Loop over the sections again, this time assigning
-         those that fit to the current segment and remvoing them from the
+         those that fit to the current segment and removing them from the
          sections array; but making sure not to leave large gaps.  Once all
          possible sections have been assigned to the current segment it is
@@ -4074 +5041 @@
                          and the start of this section is more than
                          maxpagesize then we need to start a new segment.  */
-                      if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
-                          < BFD_ALIGN (output_section->lma, maxpagesize))
-                          || ((prev_sec->lma + prev_sec->_raw_size) > output_section->lma))
+                      if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
+                                      maxpagesize)
+                           < BFD_ALIGN (output_section->lma, maxpagesize))
+                          || ((prev_sec->lma + prev_sec->_raw_size)
+                              > output_section->lma))
                         {
                           if (suggested_lma == 0)
@@ -4088 +5057 @@
                   ++isec;
                   sections[j] = NULL;
-                  section->segment_mark = true;
+                  section->segment_mark = TRUE;
                 }
               else if (suggested_lma == 0)
@@ -4105 +5074 @@
                  segments.  Create a new segment here, initialise it
                  and carry on looping.  */
-              map = ((struct elf_segment_map *)
-                     bfd_alloc (obfd,
-                                (sizeof (struct elf_segment_map)
-                                 + ((size_t) section_count - 1)
-                                 * sizeof (asection *))));
+              amt = sizeof (struct elf_segment_map);
+              amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
+              map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
               if (map == NULL)
-                return false;
+                {
+                  free (sections);
+                  return FALSE;
+                }
 
               /* Initialise the fields of the segment map.  Set the physical
@@ -4139 +5109 @@
       break;
   if (map == NULL)
-    {
-      for (map = map_first; map != NULL; map = map->next)
-        map->p_paddr_valid = 0;
-    }
+    for (map = map_first; map != NULL; map = map->next)
+      map->p_paddr_valid = 0;
 
   elf_tdata (obfd)->segment_map = map_first;
 
   /* If we had to estimate the number of program headers that were
-     going to be needed, then check our estimate know and adjust
+     going to be needed, then check our estimate now and adjust
      the offset if necessary.  */
   if (phdr_adjust_seg != NULL)
@@ -4187 +5155 @@
 
 #undef SEGMENT_END
+#undef SECTION_SIZE
 #undef IS_CONTAINED_BY_VMA
 #undef IS_CONTAINED_BY_LMA
@@ -4194 +5163 @@
 #undef SEGMENT_AFTER_SEGMENT
 #undef SEGMENT_OVERLAPS
-  return true;
+  return TRUE;
 }
 
@@ -4200 +5169 @@
    field, and sometimes the info field.  */
 
-boolean
+bfd_boolean
 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
      bfd *ibfd;
@@ -4211 +5180 @@
   if (ibfd->xvec->flavour != bfd_target_elf_flavour
       || obfd->xvec->flavour != bfd_target_elf_flavour)
-    return true;
-
-  /* Copy over private BFD data if it has not already been copied.
-     This must be done here, rather than in the copy_private_bfd_data
-     entry point, because the latter is called after the section
-     contents have been set, which means that the program headers have
-     already been worked out.  */
-  if (elf_tdata (obfd)->segment_map == NULL
-      && elf_tdata (ibfd)->phdr != NULL)
-    {
-      asection *s;
-
-      /* Only set up the segments if there are no more SEC_ALLOC
-         sections.  FIXME: This won't do the right thing if objcopy is
-         used to remove the last SEC_ALLOC section, since objcopy
-         won't call this routine in that case.  */
-      for (s = isec->next; s != NULL; s = s->next)
-        if ((s->flags & SEC_ALLOC) != 0)
-          break;
-      if (s == NULL)
-        {
-          if (! copy_private_bfd_data (ibfd, obfd))
-            return false;
-        }
+    return TRUE;
+
+  if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
+    {
+        asection *s;
+
+        /* Only set up the segments if there are no more SEC_ALLOC
+           sections.  FIXME: This won't do the right thing if objcopy is
+           used to remove the last SEC_ALLOC section, since objcopy
+           won't call this routine in that case.  */
+        for (s = isec->next; s != NULL; s = s->next)
+          if ((s->flags & SEC_ALLOC) != 0)
+            break;
+        if (s == NULL)
+          {
+            if (! copy_private_bfd_data (ibfd, obfd))
+              return FALSE;
+          }
     }
 
@@ -4248 +5211 @@
     ohdr->sh_info = ihdr->sh_info;
 
-  elf_section_data (osec)->use_rela_p
-    = elf_section_data (isec)->use_rela_p;
-
-  return true;
+  /* Set things up for objcopy.  The output SHT_GROUP section will
+     have its elf_next_in_group pointing back to the input group
+     members.  */
+  elf_next_in_group (osec) = elf_next_in_group (isec);
+  elf_group_name (osec) = elf_group_name (isec);
+
+  osec->use_rela_p = isec->use_rela_p;
+
+  return TRUE;
 }
 
@@ -4260 +5228 @@
    swap_out_syms function.  */
 
-#define MAP_ONESYMTAB (SHN_LORESERVE - 1)
-#define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
-#define MAP_STRTAB (SHN_LORESERVE - 3)
-#define MAP_SHSTRTAB (SHN_LORESERVE - 4)
-
-boolean
+#define MAP_ONESYMTAB (SHN_HIOS + 1)
+#define MAP_DYNSYMTAB (SHN_HIOS + 2)
+#define MAP_STRTAB    (SHN_HIOS + 3)
+#define MAP_SHSTRTAB  (SHN_HIOS + 4)
+#define MAP_SYM_SHNDX (SHN_HIOS + 5)
+
+bfd_boolean
 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
      bfd *ibfd;
@@ -4276 +5245 @@
   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
-    return true;
+    return TRUE;
 
   isym = elf_symbol_from (ibfd, isymarg);
@@ -4296 +5265 @@
       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
         shndx = MAP_SHSTRTAB;
+      else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
+        shndx = MAP_SYM_SHNDX;
       osym->internal_elf_sym.st_shndx = shndx;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Swap out the symbols.  */
 
-static boolean
+static bfd_boolean
 swap_out_syms (abfd, sttp, relocatable_p)
      bfd *abfd;
@@ -4310 +5281 @@
      int relocatable_p;
 {
-  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  struct elf_backend_data *bed;
+  int symcount;
+  asymbol **syms;
+  struct bfd_strtab_hash *stt;
+  Elf_Internal_Shdr *symtab_hdr;
+  Elf_Internal_Shdr *symtab_shndx_hdr;
+  Elf_Internal_Shdr *symstrtab_hdr;
+  char *outbound_syms;
+  char *outbound_shndx;
+  int idx;
+  bfd_size_type amt;
 
   if (!elf_map_symbols (abfd))
-    return false;
+    return FALSE;
 
   /* Dump out the symtabs.  */
+  stt = _bfd_elf_stringtab_init ();
+  if (stt == NULL)
+    return FALSE;
+
+  bed = get_elf_backend_data (abfd);
+  symcount = bfd_get_symcount (abfd);
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  symtab_hdr->sh_type = SHT_SYMTAB;
+  symtab_hdr->sh_entsize = bed->s->sizeof_sym;
+  symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
+  symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
+  symtab_hdr->sh_addralign = bed->s->file_align;
+
+  symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
+  symstrtab_hdr->sh_type = SHT_STRTAB;
+
+  amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
+  outbound_syms = bfd_alloc (abfd, amt);
+  if (outbound_syms == NULL)
+    {
+      _bfd_stringtab_free (stt);
+      return FALSE;
+    }
+  symtab_hdr->contents = (PTR) outbound_syms;
+
+  outbound_shndx = NULL;
+  symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+  if (symtab_shndx_hdr->sh_name != 0)
+    {
+      amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
+      outbound_shndx = bfd_zalloc (abfd, amt);
+      if (outbound_shndx == NULL)
+        {
+          _bfd_stringtab_free (stt);
+          return FALSE;
+        }
+
+      symtab_shndx_hdr->contents = outbound_shndx;
+      symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
+      symtab_shndx_hdr->sh_size = amt;
+      symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
+      symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
+    }
+
+  /* Now generate the data (for "contents").  */
   {
-    int symcount = bfd_get_symcount (abfd);
-    asymbol **syms = bfd_get_outsymbols (abfd);
-    struct bfd_strtab_hash *stt;
-    Elf_Internal_Shdr *symtab_hdr;
-    Elf_Internal_Shdr *symstrtab_hdr;
-    char *outbound_syms;
-    int idx;
-
-    stt = _bfd_elf_stringtab_init ();
-    if (stt == NULL)
-      return false;
-
-    symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
-    symtab_hdr->sh_type = SHT_SYMTAB;
-    symtab_hdr->sh_entsize = bed->s->sizeof_sym;
-    symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
-    symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
-    symtab_hdr->sh_addralign = bed->s->file_align;
-
-    symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
-    symstrtab_hdr->sh_type = SHT_STRTAB;
-
-    outbound_syms = bfd_alloc (abfd,
-                               (1 + symcount) * bed->s->sizeof_sym);
-    if (outbound_syms == NULL)
-      return false;
-    symtab_hdr->contents = (PTR) outbound_syms;
-
-    /* now generate the data (for "contents") */
-    {
-      /* Fill in zeroth symbol and swap it out.  */
+    /* Fill in zeroth symbol and swap it out.  */
+    Elf_Internal_Sym sym;
+    sym.st_name = 0;
+    sym.st_value = 0;
+    sym.st_size = 0;
+    sym.st_info = 0;
+    sym.st_other = 0;
+    sym.st_shndx = SHN_UNDEF;
+    bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
+    outbound_syms += bed->s->sizeof_sym;
+    if (outbound_shndx != NULL)
+      outbound_shndx += sizeof (Elf_External_Sym_Shndx);
+  }
+
+  syms = bfd_get_outsymbols (abfd);
+  for (idx = 0; idx < symcount; idx++)
+    {
       Elf_Internal_Sym sym;
-      sym.st_name = 0;
-      sym.st_value = 0;
-      sym.st_size = 0;
-      sym.st_info = 0;
-      sym.st_other = 0;
-      sym.st_shndx = SHN_UNDEF;
-      bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
+      bfd_vma value = syms[idx]->value;
+      elf_symbol_type *type_ptr;
+      flagword flags = syms[idx]->flags;
+      int type;
+
+      if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
+        {
+          /* Local section symbols have no name.  */
+          sym.st_name = 0;
+        }
+      else
+        {
+          sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
+                                                            syms[idx]->name,
+                                                            TRUE, FALSE);
+          if (sym.st_name == (unsigned long) -1)
+            {
+              _bfd_stringtab_free (stt);
+              return FALSE;
+            }
+        }
+
+      type_ptr = elf_symbol_from (abfd, syms[idx]);
+
+      if ((flags & BSF_SECTION_SYM) == 0
+          && bfd_is_com_section (syms[idx]->section))
+        {
+          /* ELF common symbols put the alignment into the `value' field,
+             and the size into the `size' field.  This is backwards from
+             how BFD handles it, so reverse it here.  */
+          sym.st_size = value;
+          if (type_ptr == NULL
+              || type_ptr->internal_elf_sym.st_value == 0)
+            sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
+          else
+            sym.st_value = type_ptr->internal_elf_sym.st_value;
+          sym.st_shndx = _bfd_elf_section_from_bfd_section
+            (abfd, syms[idx]->section);
+        }
+      else
+        {
+          asection *sec = syms[idx]->section;
+          int shndx;
+
+          if (sec->output_section)
+            {
+              value += sec->output_offset;
+              sec = sec->output_section;
+            }
+
+          /* Don't add in the section vma for relocatable output.  */
+          if (! relocatable_p)
+            value += sec->vma;
+          sym.st_value = value;
+          sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
+
+          if (bfd_is_abs_section (sec)
+              && type_ptr != NULL
+              && type_ptr->internal_elf_sym.st_shndx != 0)
+            {
+              /* This symbol is in a real ELF section which we did
+                 not create as a BFD section.  Undo the mapping done
+                 by copy_private_symbol_data.  */
+              shndx = type_ptr->internal_elf_sym.st_shndx;
+              switch (shndx)
+                {
+                case MAP_ONESYMTAB:
+                  shndx = elf_onesymtab (abfd);
+                  break;
+                case MAP_DYNSYMTAB:
+                  shndx = elf_dynsymtab (abfd);
+                  break;
+                case MAP_STRTAB:
+                  shndx = elf_tdata (abfd)->strtab_section;
+                  break;
+                case MAP_SHSTRTAB:
+                  shndx = elf_tdata (abfd)->shstrtab_section;
+                  break;
+                case MAP_SYM_SHNDX:
+                  shndx = elf_tdata (abfd)->symtab_shndx_section;
+                  break;
+                default:
+                  break;
+                }
+            }
+          else
+            {
+              shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
+
+              if (shndx == -1)
+                {
+                  asection *sec2;
+
+                  /* Writing this would be a hell of a lot easier if
+                     we had some decent documentation on bfd, and
+                     knew what to expect of the library, and what to
+                     demand of applications.  For example, it
+                     appears that `objcopy' might not set the
+                     section of a symbol to be a section that is
+                     actually in the output file.  */
+                  sec2 = bfd_get_section_by_name (abfd, sec->name);
+                  if (sec2 == NULL)
+                    {
+                      _bfd_error_handler (_("\
+Unable to find equivalent output section for symbol '%s' from section '%s'"),
+                                          syms[idx]->name ? syms[idx]->name : "<Local sym>",
+                                          sec->name);
+                      bfd_set_error (bfd_error_invalid_operation);
+                      _bfd_stringtab_free (stt);
+                      return FALSE;
+                    }
+
+                  shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
+                  BFD_ASSERT (shndx != -1);
+                }
+            }
+
+          sym.st_shndx = shndx;
+        }
+
+      if ((flags & BSF_THREAD_LOCAL) != 0)
+        type = STT_TLS;
+      else if ((flags & BSF_FUNCTION) != 0)
+        type = STT_FUNC;
+      else if ((flags & BSF_OBJECT) != 0)
+        type = STT_OBJECT;
+      else
+        type = STT_NOTYPE;
+
+      if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
+        type = STT_TLS;
+
+      /* Processor-specific types.  */
+      if (type_ptr != NULL
+          && bed->elf_backend_get_symbol_type)
+        type = ((*bed->elf_backend_get_symbol_type)
+                (&type_ptr->internal_elf_sym, type));
+
+      if (flags & BSF_SECTION_SYM)
+        {
+          if (flags & BSF_GLOBAL)
+            sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
+          else
+            sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
+        }
+      else if (bfd_is_com_section (syms[idx]->section))
+        sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
+      else if (bfd_is_und_section (syms[idx]->section))
+        sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
+                                    ? STB_WEAK
+                                    : STB_GLOBAL),
+                                   type);
+      else if (flags & BSF_FILE)
+        sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
+      else
+        {
+          int bind = STB_LOCAL;
+
+          if (flags & BSF_LOCAL)
+            bind = STB_LOCAL;
+          else if (flags & BSF_WEAK)
+            bind = STB_WEAK;
+          else if (flags & BSF_GLOBAL)
+            bind = STB_GLOBAL;
+
+          sym.st_info = ELF_ST_INFO (bind, type);
+        }
+
+      if (type_ptr != NULL)
+        sym.st_other = type_ptr->internal_elf_sym.st_other;
+      else
+        sym.st_other = 0;
+
+      bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
       outbound_syms += bed->s->sizeof_sym;
-    }
-    for (idx = 0; idx < symcount; idx++)
-      {
-        Elf_Internal_Sym sym;
-        bfd_vma value = syms[idx]->value;
-        elf_symbol_type *type_ptr;
-        flagword flags = syms[idx]->flags;
-        int type;
-
-        if ((flags & BSF_SECTION_SYM) != 0)
-          {
-            /* Section symbols have no name.  */
-            sym.st_name = 0;
-          }
-        else
-          {
-            sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
-                                                              syms[idx]->name,
-                                                              true, false);
-            if (sym.st_name == (unsigned long) -1)
-              return false;
-          }
-
-        type_ptr = elf_symbol_from (abfd, syms[idx]);
-
-        if ((flags & BSF_SECTION_SYM) == 0
-            && bfd_is_com_section (syms[idx]->section))
-          {
-            /* ELF common symbols put the alignment into the `value' field,
-               and the size into the `size' field.  This is backwards from
-               how BFD handles it, so reverse it here.  */
-            sym.st_size = value;
-            if (type_ptr == NULL
-                || type_ptr->internal_elf_sym.st_value == 0)
-              sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
-            else
-              sym.st_value = type_ptr->internal_elf_sym.st_value;
-            sym.st_shndx = _bfd_elf_section_from_bfd_section
-              (abfd, syms[idx]->section);
-          }
-        else
-          {
-            asection *sec = syms[idx]->section;
-            int shndx;
-
-            if (sec->output_section)
-              {
-                value += sec->output_offset;
-                sec = sec->output_section;
-              }
-            /* Don't add in the section vma for relocatable output.  */
-            if (! relocatable_p)
-              value += sec->vma;
-            sym.st_value = value;
-            sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
-
-            if (bfd_is_abs_section (sec)
-                && type_ptr != NULL
-                && type_ptr->internal_elf_sym.st_shndx != 0)
-              {
-                /* This symbol is in a real ELF section which we did
-                   not create as a BFD section.  Undo the mapping done
-                   by copy_private_symbol_data.  */
-                shndx = type_ptr->internal_elf_sym.st_shndx;
-                switch (shndx)
-                  {
-                  case MAP_ONESYMTAB:
-                    shndx = elf_onesymtab (abfd);
-                    break;
-                  case MAP_DYNSYMTAB:
-                    shndx = elf_dynsymtab (abfd);
-                    break;
-                  case MAP_STRTAB:
-                    shndx = elf_tdata (abfd)->strtab_section;
-                    break;
-                  case MAP_SHSTRTAB:
-                    shndx = elf_tdata (abfd)->shstrtab_section;
-                    break;
-                  default:
-                    break;
-                  }
-              }
-            else
-              {
-                shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
-
-                if (shndx == -1)
-                  {
-                    asection *sec2;
-
-                    /* Writing this would be a hell of a lot easier if
-                       we had some decent documentation on bfd, and
-                       knew what to expect of the library, and what to
-                       demand of applications.  For example, it
-                       appears that `objcopy' might not set the
-                       section of a symbol to be a section that is
-                       actually in the output file.  */
-                    sec2 = bfd_get_section_by_name (abfd, sec->name);
-                    BFD_ASSERT (sec2 != 0);
-                    shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
-                    BFD_ASSERT (shndx != -1);
-                  }
-              }
-
-            sym.st_shndx = shndx;
-          }
-
-        if ((flags & BSF_FUNCTION) != 0)
-          type = STT_FUNC;
-        else if ((flags & BSF_OBJECT) != 0)
-          type = STT_OBJECT;
-        else
-          type = STT_NOTYPE;
-
-        /* Processor-specific types */
-        if (type_ptr != NULL
-            && bed->elf_backend_get_symbol_type)
-          type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
-
-        if (flags & BSF_SECTION_SYM)
-          sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
-        else if (bfd_is_com_section (syms[idx]->section))
-          sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
-        else if (bfd_is_und_section (syms[idx]->section))
-          sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
-                                      ? STB_WEAK
-                                      : STB_GLOBAL),
-                                     type);
-        else if (flags & BSF_FILE)
-          sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
-        else
-          {
-            int bind = STB_LOCAL;
-
-            if (flags & BSF_LOCAL)
-              bind = STB_LOCAL;
-            else if (flags & BSF_WEAK)
-              bind = STB_WEAK;
-            else if (flags & BSF_GLOBAL)
-              bind = STB_GLOBAL;
-
-            sym.st_info = ELF_ST_INFO (bind, type);
-          }
-
-        if (type_ptr != NULL)
-          sym.st_other = type_ptr->internal_elf_sym.st_other;
-        else
-          sym.st_other = 0;
-
-        bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
-        outbound_syms += bed->s->sizeof_sym;
-      }
-
-    *sttp = stt;
-    symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
-    symstrtab_hdr->sh_type = SHT_STRTAB;
-
-    symstrtab_hdr->sh_flags = 0;
-    symstrtab_hdr->sh_addr = 0;
-    symstrtab_hdr->sh_entsize = 0;
-    symstrtab_hdr->sh_link = 0;
-    symstrtab_hdr->sh_info = 0;
-    symstrtab_hdr->sh_addralign = 1;
-  }
-
-  return true;
+      if (outbound_shndx != NULL)
+        outbound_shndx += sizeof (Elf_External_Sym_Shndx);
+    }
+
+  *sttp = stt;
+  symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
+  symstrtab_hdr->sh_type = SHT_STRTAB;
+
+  symstrtab_hdr->sh_flags = 0;
+  symstrtab_hdr->sh_addr = 0;
+  symstrtab_hdr->sh_entsize = 0;
+  symstrtab_hdr->sh_link = 0;
+  symstrtab_hdr->sh_info = 0;
+  symstrtab_hdr->sh_addralign = 1;
+
+  return TRUE;
 }
 
@@ -4540 +5569 @@
 
   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
-  symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
+  symtab_size = (symcount + 1) * (sizeof (asymbol *));
+  if (symcount > 0)
+    symtab_size -= sizeof (asymbol *);
 
   return symtab_size;
@@ -4560 +5591 @@
 
   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
-  symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
+  symtab_size = (symcount + 1) * (sizeof (asymbol *));
+  if (symcount > 0)
+    symtab_size -= sizeof (asymbol *);
 
   return symtab_size;
@@ -4584 +5617 @@
   arelent *tblptr;
   unsigned int i;
-
-  if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd,
-                                                           section,
-                                                           symbols,
-                                                           false))
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+
+  if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
     return -1;
 
@@ -4605 +5636 @@
      asymbol **alocation;
 {
-  long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table
-    (abfd, alocation, false);
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  long symcount = bed->s->slurp_symbol_table (abfd, alocation, FALSE);
 
   if (symcount >= 0)
@@ -4618 +5649 @@
      asymbol **alocation;
 {
-  return get_elf_backend_data (abfd)->s->slurp_symbol_table
-    (abfd, alocation, true);
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  long symcount = bed->s->slurp_symbol_table (abfd, alocation, TRUE);
+
+  if (symcount >= 0)
+    bfd_get_dynamic_symcount (abfd) = symcount;
+  return symcount;
 }
 
@@ -4666 +5701 @@
      asymbol **syms;
 {
-  boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
+  bfd_boolean (*slurp_relocs)
+    PARAMS ((bfd *, asection *, asymbol **, bfd_boolean));
   asection *s;
   long ret;
@@ -4687 +5723 @@
           long count, i;
 
-          if (! (*slurp_relocs) (abfd, s, syms, true))
+          if (! (*slurp_relocs) (abfd, s, syms, TRUE))
             return -1;
           count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
@@ -4705 +5741 @@
 /* Read in the version information.  */
 
-boolean
+bfd_boolean
 _bfd_elf_slurp_version_tables (abfd)
      bfd *abfd;
 {
   bfd_byte *contents = NULL;
+  bfd_size_type amt;
 
   if (elf_dynverdef (abfd) != 0)
@@ -4727 +5764 @@
         goto error_return;
       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
-          || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
+          || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
         goto error_return;
 
@@ -4746 +5783 @@
         }
 
-      elf_tdata (abfd)->verdef =
-        ((Elf_Internal_Verdef *)
-         bfd_zalloc (abfd, maxidx * sizeof (Elf_Internal_Verdef)));
+      amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
+      elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) bfd_zalloc (abfd, amt);
       if (elf_tdata (abfd)->verdef == NULL)
         goto error_return;
@@ -4769 +5805 @@
           iverdef->vd_bfd = abfd;
 
-          iverdef->vd_auxptr = ((Elf_Internal_Verdaux *)
-                                bfd_alloc (abfd,
-                                           (iverdef->vd_cnt
-                                            * sizeof (Elf_Internal_Verdaux))));
+          amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
+          iverdef->vd_auxptr = (Elf_Internal_Verdaux *) bfd_alloc (abfd, amt);
           if (iverdef->vd_auxptr == NULL)
             goto error_return;
@@ -4822 +5856 @@
       hdr = &elf_tdata (abfd)->dynverref_hdr;
 
+      amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
       elf_tdata (abfd)->verref =
-        ((Elf_Internal_Verneed *)
-         bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed)));
+        (Elf_Internal_Verneed *) bfd_zalloc (abfd, amt);
       if (elf_tdata (abfd)->verref == NULL)
         goto error_return;
@@ -4834 +5868 @@
         goto error_return;
       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
-          || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
+          || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
         goto error_return;
 
@@ -4855 +5889 @@
             goto error_return;
 
-          iverneed->vn_auxptr =
-            ((Elf_Internal_Vernaux *)
-             bfd_alloc (abfd,
-                        iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux)));
+          amt = iverneed->vn_cnt;
+          amt *= sizeof (Elf_Internal_Vernaux);
+          iverneed->vn_auxptr = (Elf_Internal_Vernaux *) bfd_alloc (abfd, amt);
 
           evernaux = ((Elf_External_Vernaux *)
@@ -4895 +5928 @@
     }
 
-  return true;
+  return TRUE;
 
  error_return:
-  if (contents == NULL)
+  if (contents != NULL)
     free (contents);
-  return false;
+  return FALSE;
 }
 
@@ -4909 +5942 @@
 {
   elf_symbol_type *newsym;
-
-  newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
+  bfd_size_type amt = sizeof (elf_symbol_type);
+
+  newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
   if (!newsym)
     return NULL;
@@ -4933 +5967 @@
    override it.  */
 
-boolean
+bfd_boolean
 _bfd_elf_is_local_label_name (abfd, name)
      bfd *abfd ATTRIBUTE_UNUSED;
@@ -4940 +5974 @@
   /* Normal local symbols start with ``.L''.  */
   if (name[0] == '.' && name[1] == 'L')
-    return true;
+    return TRUE;
 
   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
      DWARF debugging symbols starting with ``..''.  */
   if (name[0] == '.' && name[1] == '.')
-    return true;
+    return TRUE;
 
   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
@@ -4954 +5988 @@
      we treat such symbols as local.  */
   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
-    return true;
-
-  return false;
+    return TRUE;
+
+  return FALSE;
 }
 
@@ -4968 +6002 @@
 }
 
-boolean
+bfd_boolean
 _bfd_elf_set_arch_mach (abfd, arch, machine)
      bfd *abfd;
@@ -4979 +6013 @@
       && arch != bfd_arch_unknown
       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
-    return false;
+    return FALSE;
 
   return bfd_default_set_arch_mach (abfd, arch, machine);
@@ -4987 +6021 @@
    for error reporting.  */
 
-static boolean
+static bfd_boolean
 elf_find_function (abfd, section, symbols, offset,
                    filename_ptr, functionname_ptr)
@@ -5036 +6070 @@
 
   if (func == NULL)
-    return false;
+    return FALSE;
 
   if (filename_ptr)
@@ -5043 +6077 @@
     *functionname_ptr = bfd_asymbol_name (func);
 
-  return true;
+  return TRUE;
 }
 
@@ -5049 +6083 @@
    for error reporting.  */
 
-boolean
+bfd_boolean
 _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
                             filename_ptr, functionname_ptr, line_ptr)
@@ -5060 +6094 @@
      unsigned int *line_ptr;
 {
-  boolean found;
+  bfd_boolean found;
 
   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
@@ -5071 +6105 @@
                            functionname_ptr);
 
-      return true;
+      return TRUE;
     }
 
@@ -5084 +6118 @@
                            functionname_ptr);
 
-      return true;
+      return TRUE;
     }
 
@@ -5091 +6125 @@
                                              functionname_ptr, line_ptr,
                                              &elf_tdata (abfd)->line_info))
-    return false;
-  if (found)
-    return true;
+    return FALSE;
+  if (found && (*functionname_ptr || *line_ptr))
+    return TRUE;
 
   if (symbols == NULL)
-    return false;
+    return FALSE;
 
   if (! elf_find_function (abfd, section, symbols, offset,
                            filename_ptr, functionname_ptr))
-    return false;
+    return FALSE;
 
   *line_ptr = 0;
-  return true;
+  return TRUE;
 }
 
@@ -5109 +6143 @@
 _bfd_elf_sizeof_headers (abfd, reloc)
      bfd *abfd;
-     boolean reloc;
+     bfd_boolean reloc;
 {
   int ret;
@@ -5119 +6153 @@
 }
 
-boolean
+bfd_boolean
 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -5128 +6162 @@
 {
   Elf_Internal_Shdr *hdr;
+  bfd_signed_vma pos;
 
   if (! abfd->output_has_begun
-      && ! _bfd_elf_compute_section_file_positions
-      (abfd, (struct bfd_link_info *) NULL))
-    return false;
+      && ! (_bfd_elf_compute_section_file_positions
+            (abfd, (struct bfd_link_info *) NULL)))
+    return FALSE;
 
   hdr = &elf_section_data (section)->this_hdr;
-
-  if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
-    return false;
-  if (bfd_write (location, 1, count, abfd) != count)
-    return false;
-
-  return true;
+  pos = hdr->sh_offset + offset;
+  if (bfd_seek (abfd, pos, SEEK_SET) != 0
+      || bfd_bwrite (location, count, abfd) != count)
+    return FALSE;
+
+  return TRUE;
 }
 
@@ -5153 +6187 @@
 }
 
-#if 0
-void
-_bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
-     bfd *abfd;
-     arelent *cache_ptr;
-     Elf_Internal_Rel *dst;
-{
-  abort ();
-}
-#endif
-
 /* Try to convert a non-ELF reloc into an ELF one.  */
 
-boolean
+bfd_boolean
 _bfd_elf_validate_reloc (abfd, areloc)
      bfd *abfd;
@@ -5252 +6275 @@
     }
 
-  return true;
+  return TRUE;
 
  fail:
   (*_bfd_error_handler)
     (_("%s: unsupported relocation type %s"),
-     bfd_get_filename (abfd), areloc->howto->name);
+     bfd_archive_filename (abfd), areloc->howto->name);
   bfd_set_error (bfd_error_bad_value);
-  return false;
-}
-
-boolean
+  return FALSE;
+}
+
+bfd_boolean
 _bfd_elf_close_and_cleanup (abfd)
      bfd *abfd;
@@ -5269 +6292 @@
     {
       if (elf_shstrtab (abfd) != NULL)
-        _bfd_stringtab_free (elf_shstrtab (abfd));
+        _bfd_elf_strtab_free (elf_shstrtab (abfd));
     }
 
@@ -5303 +6326 @@
 #endif
 
-/* Define offsetof for those systems which lack it.  */
-
-#ifndef offsetof
-# define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
-#endif
-
 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
 
@@ -5324 +6341 @@
    overwrite it.  */
 
-static boolean
+static bfd_boolean
 elfcore_maybe_make_sect (abfd, name, sect)
      bfd *abfd;
@@ -5333 +6350 @@
 
   if (bfd_get_section_by_name (abfd, name) != NULL)
-    return true;
+    return TRUE;
 
   sect2 = bfd_make_section (abfd, name);
   if (sect2 == NULL)
-    return false;
+    return FALSE;
 
   sect2->_raw_size = sect->_raw_size;
@@ -5343 +6360 @@
   sect2->flags = sect->flags;
   sect2->alignment_power = sect->alignment_power;
-  return true;
+  return TRUE;
+}
+
+/* Create a pseudosection containing SIZE bytes at FILEPOS.  This
+   actually creates up to two pseudosections:
+   - For the single-threaded case, a section named NAME, unless
+     such a section already exists.
+   - For the multi-threaded case, a section named "NAME/PID", where
+     PID is elfcore_make_pid (abfd).
+   Both pseudosections have identical contents. */
+bfd_boolean
+_bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
+     bfd *abfd;
+     char *name;
+     size_t size;
+     ufile_ptr filepos;
+{
+  char buf[100];
+  char *threaded_name;
+  size_t len;
+  asection *sect;
+
+  /* Build the section name.  */
+
+  sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
+  len = strlen (buf) + 1;
+  threaded_name = bfd_alloc (abfd, (bfd_size_type) len);
+  if (threaded_name == NULL)
+    return FALSE;
+  memcpy (threaded_name, buf, len);
+
+  sect = bfd_make_section (abfd, threaded_name);
+  if (sect == NULL)
+    return FALSE;
+  sect->_raw_size = size;
+  sect->filepos = filepos;
+  sect->flags = SEC_HAS_CONTENTS;
+  sect->alignment_power = 2;
+
+  return elfcore_maybe_make_sect (abfd, name, sect);
 }
 
@@ -5353 +6409 @@
 
 #if defined (HAVE_PRSTATUS_T)
-static boolean
+static bfd_boolean elfcore_grok_prstatus
+  PARAMS ((bfd *, Elf_Internal_Note *));
+
+static bfd_boolean
 elfcore_grok_prstatus (abfd, note)
      bfd *abfd;
      Elf_Internal_Note *note;
 {
-  char buf[100];
-  char *name;
-  asection *sect;
-  int raw_size;
+  size_t raw_size;
   int offset;
 
@@ -5372 +6428 @@
       memcpy (&prstat, note->descdata, sizeof (prstat));
 
-      elf_tdata (abfd)->core_signal = prstat.pr_cursig;
+      /* Do not overwrite the core signal if it
+         has already been set by another thread.  */
+      if (elf_tdata (abfd)->core_signal == 0)
+        elf_tdata (abfd)->core_signal = prstat.pr_cursig;
       elf_tdata (abfd)->core_pid = prstat.pr_pid;
 
@@ -5395 +6454 @@
       memcpy (&prstat, note->descdata, sizeof (prstat));
 
-      elf_tdata (abfd)->core_signal = prstat.pr_cursig;
+      /* Do not overwrite the core signal if it
+         has already been set by another thread.  */
+      if (elf_tdata (abfd)->core_signal == 0)
+        elf_tdata (abfd)->core_signal = prstat.pr_cursig;
       elf_tdata (abfd)->core_pid = prstat.pr_pid;
 
@@ -5413 +6475 @@
       /* Fail - we don't know how to handle any other
          note size (ie. data object type).  */
-      return true;
-    }
-
-  /* Make a ".reg/999" section.  */
-
-  sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
-  name = bfd_alloc (abfd, strlen (buf) + 1);
-  if (name == NULL)
-    return false;
-  strcpy (name, buf);
-
-  sect = bfd_make_section (abfd, name);
-  if (sect == NULL)
-    return false;
-
-  sect->_raw_size = raw_size;
-  sect->filepos = note->descpos + offset;
-
-  sect->flags = SEC_HAS_CONTENTS;
-  sect->alignment_power = 2;
-
-  if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
-    return false;
-
-  return true;
+      return TRUE;
+    }
+
+  /* Make a ".reg/999" section and a ".reg" section.  */
+  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
+                                          raw_size, note->descpos + offset);
 }
 #endif /* defined (HAVE_PRSTATUS_T) */
 
-/* Create a pseudosection containing the exact contents of NOTE.  This
-   actually creates up to two pseudosections:
-   - For the single-threaded case, a section named NAME, unless
-     such a section already exists.
-   - For the multi-threaded case, a section named "NAME/PID", where
-     PID is elfcore_make_pid (abfd).
-   Both pseudosections have identical contents: the contents of NOTE.  */
-
-static boolean
+/* Create a pseudosection containing the exact contents of NOTE.  */
+static bfd_boolean
 elfcore_make_note_pseudosection (abfd, name, note)
      bfd *abfd;
@@ -5455 +6491 @@
      Elf_Internal_Note *note;
 {
-  char buf[100];
-  char *threaded_name;
-  asection *sect;
-
-  /* Build the section name.  */
-
-  sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
-  threaded_name = bfd_alloc (abfd, strlen (buf) + 1);
-  if (threaded_name == NULL)
-    return false;
-  strcpy (threaded_name, buf);
-
-  sect = bfd_make_section (abfd, threaded_name);
-  if (sect == NULL)
-    return false;
-  sect->_raw_size = note->descsz;
-  sect->filepos = note->descpos;
-  sect->flags = SEC_HAS_CONTENTS;
-  sect->alignment_power = 2;
-
-  if (! elfcore_maybe_make_sect (abfd, name, sect))
-    return false;
-
-  return true;
+  return _bfd_elfcore_make_pseudosection (abfd, name,
+                                          note->descsz, note->descpos);
 }
 
@@ -5485 +6499 @@
    data structure apart.  */
 
-static boolean
+static bfd_boolean
 elfcore_grok_prfpreg (abfd, note)
      bfd *abfd;
@@ -5497 +6511 @@
    literally.  */
 
-static boolean
+static bfd_boolean
 elfcore_grok_prxfpreg (abfd, note)
      bfd *abfd;
@@ -5519 +6533 @@
 #endif
 
-#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
-
 /* return a malloc'ed copy of a string at START which is at
    most MAX bytes long, possibly without a terminating '\0'.
    the copy will always have a terminating '\0'.  */
 
-static char*
-elfcore_strndup (abfd, start, max)
+char *
+_bfd_elfcore_strndup (abfd, start, max)
      bfd *abfd;
      char *start;
-     int max;
-{
-  char *dup;
+     size_t max;
+{
+  char *dups;
   char *end = memchr (start, '\0', max);
-  int len;
+  size_t len;
 
   if (end == NULL)
@@ -5540 +6552 @@
     len = end - start;
 
-  dup = bfd_alloc (abfd, len + 1);
-  if (dup == NULL)
+  dups = bfd_alloc (abfd, (bfd_size_type) len + 1);
+  if (dups == NULL)
     return NULL;
 
-  memcpy (dup, start, len);
-  dup[len] = '\0';
-
-  return dup;
-}
-
-static boolean
+  memcpy (dups, start, len);
+  dups[len] = '\0';
+
+  return dups;
+}
+
+#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
+static bfd_boolean elfcore_grok_psinfo
+  PARAMS ((bfd *, Elf_Internal_Note *));
+
+static bfd_boolean
 elfcore_grok_psinfo (abfd, note)
      bfd *abfd;
@@ -5562 +6578 @@
 
       elf_tdata (abfd)->core_program
-        = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
+        = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
+                                sizeof (psinfo.pr_fname));
 
       elf_tdata (abfd)->core_command
-        = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
+        = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
+                                sizeof (psinfo.pr_psargs));
     }
 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
@@ -5576 +6594 @@
 
       elf_tdata (abfd)->core_program
-        = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
+        = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
+                                sizeof (psinfo.pr_fname));
 
       elf_tdata (abfd)->core_command
-        = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
+        = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
+                                sizeof (psinfo.pr_psargs));
     }
 #endif
@@ -5587 +6607 @@
       /* Fail - we don't know how to handle any other
          note size (ie. data object type).  */
-      return true;
+      return TRUE;
     }
 
@@ -5602 +6622 @@
   }
 
-  return true;
+  return TRUE;
 }
 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
 
 #if defined (HAVE_PSTATUS_T)
-static boolean
+static bfd_boolean elfcore_grok_pstatus
+  PARAMS ((bfd *, Elf_Internal_Note *));
+
+static bfd_boolean
 elfcore_grok_pstatus (abfd, note)
      bfd *abfd;
@@ -5639 +6662 @@
      NT_LWPSTATUS note, presumably.  */
 
-  return true;
+  return TRUE;
 }
 #endif /* defined (HAVE_PSTATUS_T) */
 
 #if defined (HAVE_LWPSTATUS_T)
-static boolean
+static bfd_boolean elfcore_grok_lwpstatus
+  PARAMS ((bfd *, Elf_Internal_Note *));
+
+static bfd_boolean
 elfcore_grok_lwpstatus (abfd, note)
      bfd *abfd;
@@ -5652 +6678 @@
   char buf[100];
   char *name;
+  size_t len;
   asection *sect;
 
@@ -5659 +6686 @@
 #endif
       )
-    return true;
+    return TRUE;
 
   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
@@ -5669 +6696 @@
 
   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
-  name = bfd_alloc (abfd, strlen (buf) + 1);
+  len = strlen (buf) + 1;
+  name = bfd_alloc (abfd, (bfd_size_type) len);
   if (name == NULL)
-    return false;
-  strcpy (name, buf);
+    return FALSE;
+  memcpy (name, buf, len);
 
   sect = bfd_make_section (abfd, name);
   if (sect == NULL)
-    return false;
+    return FALSE;
 
 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
@@ -5693 +6721 @@
 
   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
-    return false;
+    return FALSE;
 
   /* Make a ".reg2/999" section */
 
   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
-  name = bfd_alloc (abfd, strlen (buf) + 1);
+  len = strlen (buf) + 1;
+  name = bfd_alloc (abfd, (bfd_size_type) len);
   if (name == NULL)
-    return false;
-  strcpy (name, buf);
+    return FALSE;
+  memcpy (name, buf, len);
 
   sect = bfd_make_section (abfd, name);
   if (sect == NULL)
-    return false;
+    return FALSE;
 
 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
@@ -5721 +6750 @@
   sect->alignment_power = 2;
 
-  if (!elfcore_maybe_make_sect (abfd, ".reg2", sect))
-    return false;
-
-  return true;
+  return elfcore_maybe_make_sect (abfd, ".reg2", sect);
 }
 #endif /* defined (HAVE_LWPSTATUS_T) */
 
 #if defined (HAVE_WIN32_PSTATUS_T)
-static boolean
+static bfd_boolean
 elfcore_grok_win32pstatus (abfd, note)
      bfd *abfd;
@@ -5736 +6762 @@
   char buf[30];
   char *name;
+  size_t len;
   asection *sect;
   win32_pstatus_t pstatus;
 
   if (note->descsz < sizeof (pstatus))
-    return true;
-
-  memcpy (&pstatus, note->descdata, note->descsz);
+    return TRUE;
+
+  memcpy (&pstatus, note->descdata, sizeof (pstatus));
 
   switch (pstatus.data_type)
@@ -5756 +6783 @@
       sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
 
-      name = bfd_alloc (abfd, strlen (buf) + 1);
+      len = strlen (buf) + 1;
+      name = bfd_alloc (abfd, (bfd_size_type) len);
       if (name == NULL)
-        return false;
-
-      strcpy (name, buf);
+        return FALSE;
+
+      memcpy (name, buf, len);
 
       sect = bfd_make_section (abfd, name);
       if (sect == NULL)
-        return false;
+        return FALSE;
 
       sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
-      sect->filepos = note->descpos + offsetof (struct win32_pstatus,
-                                                data.thread_info.thread_context);
+      sect->filepos = (note->descpos
+                       + offsetof (struct win32_pstatus,
+                                   data.thread_info.thread_context));
       sect->flags = SEC_HAS_CONTENTS;
       sect->alignment_power = 2;
@@ -5774 +6803 @@
       if (pstatus.data.thread_info.is_active_thread)
         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
-          return false;
+          return FALSE;
       break;
 
@@ -5781 +6810 @@
       sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
 
-      name = bfd_alloc (abfd, strlen (buf) + 1);
+      len = strlen (buf) + 1;
+      name = bfd_alloc (abfd, (bfd_size_type) len);
       if (name == NULL)
-        return false;
-
-      strcpy (name, buf);
+        return FALSE;
+
+      memcpy (name, buf, len);
 
       sect = bfd_make_section (abfd, name);
 
       if (sect == NULL)
-        return false;
+        return FALSE;
 
       sect->_raw_size = note->descsz;
@@ -5799 +6829 @@
 
     default:
-      return true;
-    }
-
-  return true;
+      return TRUE;
+    }
+
+  return TRUE;
 }
 #endif /* HAVE_WIN32_PSTATUS_T */
 
-static boolean
+static bfd_boolean
 elfcore_grok_note (abfd, note)
      bfd *abfd;
      Elf_Internal_Note *note;
 {
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+
   switch (note->type)
     {
     default:
-      return true;
-
+      return TRUE;
+
+    case NT_PRSTATUS:
+      if (bed->elf_backend_grok_prstatus)
+        if ((*bed->elf_backend_grok_prstatus) (abfd, note))
+          return TRUE;
 #if defined (HAVE_PRSTATUS_T)
-    case NT_PRSTATUS:
       return elfcore_grok_prstatus (abfd, note);
+#else
+      return TRUE;
 #endif
 
@@ -5840 +6877 @@
 
     case NT_PRXFPREG:           /* Linux SSE extension */
-      if (note->namesz == 5
-          && ! strcmp (note->namedata, "LINUX"))
+      if (note->namesz == 6
+          && strcmp (note->namedata, "LINUX") == 0)
         return elfcore_grok_prxfpreg (abfd, note);
       else
-        return true;
-
-#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
+        return TRUE;
+
     case NT_PRPSINFO:
     case NT_PSINFO:
+      if (bed->elf_backend_grok_psinfo)
+        if ((*bed->elf_backend_grok_psinfo) (abfd, note))
+          return TRUE;
+#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
       return elfcore_grok_psinfo (abfd, note);
+#else
+      return TRUE;
 #endif
     }
 }
 
-static boolean
+static bfd_boolean
+elfcore_netbsd_get_lwpid (note, lwpidp)
+     Elf_Internal_Note *note;
+     int *lwpidp;
+{
+  char *cp;
+
+  cp = strchr (note->namedata, '@');
+  if (cp != NULL)
+    {
+      *lwpidp = atoi(cp + 1);
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static bfd_boolean
+elfcore_grok_netbsd_procinfo (abfd, note)
+     bfd *abfd;
+     Elf_Internal_Note *note;
+{
+
+  /* Signal number at offset 0x08. */
+  elf_tdata (abfd)->core_signal
+    = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
+
+  /* Process ID at offset 0x50. */
+  elf_tdata (abfd)->core_pid
+    = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
+
+  /* Command name at 0x7c (max 32 bytes, including nul). */
+  elf_tdata (abfd)->core_command
+    = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
+
+  return TRUE;
+}
+
+static bfd_boolean
+elfcore_grok_netbsd_note (abfd, note)
+     bfd *abfd;
+     Elf_Internal_Note *note;
+{
+  int lwp;
+
+  if (elfcore_netbsd_get_lwpid (note, &lwp))
+    elf_tdata (abfd)->core_lwpid = lwp;
+
+  if (note->type == NT_NETBSDCORE_PROCINFO)
+    {
+      /* NetBSD-specific core "procinfo".  Note that we expect to
+         find this note before any of the others, which is fine,
+         since the kernel writes this note out first when it
+         creates a core file.  */
+
+      return elfcore_grok_netbsd_procinfo (abfd, note);
+    }
+
+  /* As of Jan 2002 there are no other machine-independent notes
+     defined for NetBSD core files.  If the note type is less
+     than the start of the machine-dependent note types, we don't
+     understand it.  */
+
+  if (note->type < NT_NETBSDCORE_FIRSTMACH)
+    return TRUE;
+
+
+  switch (bfd_get_arch (abfd))
+    {
+    /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
+       PT_GETFPREGS == mach+2.  */
+
+    case bfd_arch_alpha:
+    case bfd_arch_sparc:
+      switch (note->type)
+        {
+        case NT_NETBSDCORE_FIRSTMACH+0:
+          return elfcore_make_note_pseudosection (abfd, ".reg", note);
+
+        case NT_NETBSDCORE_FIRSTMACH+2:
+          return elfcore_make_note_pseudosection (abfd, ".reg2", note);
+
+        default:
+          return TRUE;
+        }
+
+    /* On all other arch's, PT_GETREGS == mach+1 and
+       PT_GETFPREGS == mach+3.  */
+
+    default:
+      switch (note->type)
+        {
+        case NT_NETBSDCORE_FIRSTMACH+1:
+          return elfcore_make_note_pseudosection (abfd, ".reg", note);
+
+        case NT_NETBSDCORE_FIRSTMACH+3:
+          return elfcore_make_note_pseudosection (abfd, ".reg2", note);
+
+        default:
+          return TRUE;
+        }
+    }
+    /* NOTREACHED */
+}
+
+static bfd_boolean
+elfcore_grok_nto_status (abfd, note, tid)
+     bfd *abfd;
+     Elf_Internal_Note *note;
+     pid_t *tid;
+{
+  void *ddata = note->descdata;
+  char buf[100];
+  char *name;
+  asection *sect;
+
+  /* nto_procfs_status 'pid' field is at offset 0.  */
+  elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
+
+  /* nto_procfs_status 'tid' field is at offset 4.  */
+  elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
+
+  /* nto_procfs_status 'what' field is at offset 14.  */
+  elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, (bfd_byte *) ddata + 14);
+
+  /* Pass tid back.  */
+  *tid = elf_tdata (abfd)->core_lwpid;
+
+  /* Make a ".qnx_core_status/%d" section.  */
+  sprintf (buf, ".qnx_core_status/%d", *tid);
+
+  name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
+  if (name == NULL)
+    return FALSE;
+  strcpy (name, buf);
+
+  sect = bfd_make_section (abfd, name);
+  if (sect == NULL)
+    return FALSE;
+
+  sect->_raw_size       = note->descsz;
+  sect->filepos         = note->descpos;
+  sect->flags           = SEC_HAS_CONTENTS;
+  sect->alignment_power = 2;
+
+  return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
+}
+
+static bfd_boolean
+elfcore_grok_nto_gregs (abfd, note, tid)
+     bfd *abfd;
+     Elf_Internal_Note *note;
+     pid_t tid;
+{
+  char buf[100];
+  char *name;
+  asection *sect;
+
+  /* Make a ".reg/%d" section.  */
+  sprintf (buf, ".reg/%d", tid);
+
+  name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
+  if (name == NULL)
+    return FALSE;
+  strcpy (name, buf);
+
+  sect = bfd_make_section (abfd, name);
+  if (sect == NULL)
+    return FALSE;
+
+  sect->_raw_size       = note->descsz;
+  sect->filepos         = note->descpos;
+  sect->flags           = SEC_HAS_CONTENTS;
+  sect->alignment_power = 2;
+
+  return elfcore_maybe_make_sect (abfd, ".reg", sect);
+}
+
+#define BFD_QNT_CORE_INFO       7
+#define BFD_QNT_CORE_STATUS     8
+#define BFD_QNT_CORE_GREG       9
+#define BFD_QNT_CORE_FPREG      10
+
+static bfd_boolean
+elfcore_grok_nto_note (abfd, note)
+     bfd *abfd;
+     Elf_Internal_Note *note;
+{
+  /* Every GREG section has a STATUS section before it.  Store the
+     tid from the previous call to pass down to the next gregs
+     function.  */
+  static pid_t tid = 1;
+
+  switch (note->type)
+    {
+    case BFD_QNT_CORE_INFO:   return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
+    case BFD_QNT_CORE_STATUS: return elfcore_grok_nto_status (abfd, note, &tid);
+    case BFD_QNT_CORE_GREG:   return elfcore_grok_nto_gregs (abfd, note, tid);
+    case BFD_QNT_CORE_FPREG:  return elfcore_grok_prfpreg (abfd, note);
+    default:                  return TRUE;
+    }
+}
+
+/* Function: elfcore_write_note
+
+   Inputs:
+     buffer to hold note
+     name of note
+     type of note
+     data for note
+     size of data for note
+
+   Return:
+   End of buffer containing note.  */
+
+char *
+elfcore_write_note (abfd, buf, bufsiz, name, type, input, size)
+     bfd  *abfd;
+     char *buf;
+     int  *bufsiz;
+     const char *name;
+     int  type;
+     const PTR input;
+     int  size;
+{
+  Elf_External_Note *xnp;
+  size_t namesz;
+  size_t pad;
+  size_t newspace;
+  char *p, *dest;
+
+  namesz = 0;
+  pad = 0;
+  if (name != NULL)
+    {
+      struct elf_backend_data *bed;
+
+      namesz = strlen (name) + 1;
+      bed = get_elf_backend_data (abfd);
+      pad = -namesz & (bed->s->file_align - 1);
+    }
+
+  newspace = sizeof (Elf_External_Note) - 1 + namesz + pad + size;
+
+  p = realloc (buf, *bufsiz + newspace);
+  dest = p + *bufsiz;
+  *bufsiz += newspace;
+  xnp = (Elf_External_Note *) dest;
+  H_PUT_32 (abfd, namesz, xnp->namesz);
+  H_PUT_32 (abfd, size, xnp->descsz);
+  H_PUT_32 (abfd, type, xnp->type);
+  dest = xnp->name;
+  if (name != NULL)
+    {
+      memcpy (dest, name, namesz);
+      dest += namesz;
+      while (pad != 0)
+        {
+          *dest++ = '\0';
+          --pad;
+        }
+    }
+  memcpy (dest, input, size);
+  return p;
+}
+
+#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
+char *
+elfcore_write_prpsinfo (abfd, buf, bufsiz, fname, psargs)
+     bfd  *abfd;
+     char *buf;
+     int  *bufsiz;
+     const char *fname;
+     const char *psargs;
+{
+  int note_type;
+  char *note_name = "CORE";
+
+#if defined (HAVE_PSINFO_T)
+  psinfo_t  data;
+  note_type = NT_PSINFO;
+#else
+  prpsinfo_t data;
+  note_type = NT_PRPSINFO;
+#endif
+
+  memset (&data, 0, sizeof (data));
+  strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
+  strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
+  return elfcore_write_note (abfd, buf, bufsiz,
+                             note_name, note_type, &data, sizeof (data));
+}
+#endif  /* PSINFO_T or PRPSINFO_T */
+
+#if defined (HAVE_PRSTATUS_T)
+char *
+elfcore_write_prstatus (abfd, buf, bufsiz, pid, cursig, gregs)
+     bfd *abfd;
+     char *buf;
+     int *bufsiz;
+     long pid;
+     int cursig;
+     const PTR gregs;
+{
+  prstatus_t prstat;
+  char *note_name = "CORE";
+
+  memset (&prstat, 0, sizeof (prstat));
+  prstat.pr_pid = pid;
+  prstat.pr_cursig = cursig;
+  memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
+  return elfcore_write_note (abfd, buf, bufsiz,
+                             note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
+}
+#endif /* HAVE_PRSTATUS_T */
+
+#if defined (HAVE_LWPSTATUS_T)
+char *
+elfcore_write_lwpstatus (abfd, buf, bufsiz, pid, cursig, gregs)
+     bfd *abfd;
+     char *buf;
+     int *bufsiz;
+     long pid;
+     int cursig;
+     const PTR gregs;
+{
+  lwpstatus_t lwpstat;
+  char *note_name = "CORE";
+
+  memset (&lwpstat, 0, sizeof (lwpstat));
+  lwpstat.pr_lwpid  = pid >> 16;
+  lwpstat.pr_cursig = cursig;
+#if defined (HAVE_LWPSTATUS_T_PR_REG)
+  memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
+#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
+#if !defined(gregs)
+  memcpy (lwpstat.pr_context.uc_mcontext.gregs,
+          gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
+#else
+  memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
+          gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
+#endif
+#endif
+  return elfcore_write_note (abfd, buf, bufsiz, note_name,
+                             NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
+}
+#endif /* HAVE_LWPSTATUS_T */
+
+#if defined (HAVE_PSTATUS_T)
+char *
+elfcore_write_pstatus (abfd, buf, bufsiz, pid, cursig, gregs)
+     bfd *abfd;
+     char *buf;
+     int *bufsiz;
+     long pid;
+     int cursig;
+     const PTR gregs;
+{
+  pstatus_t pstat;
+  char *note_name = "CORE";
+
+  memset (&pstat, 0, sizeof (pstat));
+  pstat.pr_pid = pid & 0xffff;
+  buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
+                            NT_PSTATUS, &pstat, sizeof (pstat));
+  return buf;
+}
+#endif /* HAVE_PSTATUS_T */
+
+char *
+elfcore_write_prfpreg (abfd, buf, bufsiz, fpregs, size)
+     bfd  *abfd;
+     char *buf;
+     int  *bufsiz;
+     const PTR fpregs;
+     int size;
+{
+  char *note_name = "CORE";
+  return elfcore_write_note (abfd, buf, bufsiz,
+                             note_name, NT_FPREGSET, fpregs, size);
+}
+
+char *
+elfcore_write_prxfpreg (abfd, buf, bufsiz, xfpregs, size)
+     bfd  *abfd;
+     char *buf;
+     int  *bufsiz;
+     const PTR xfpregs;
+     int size;
+{
+  char *note_name = "LINUX";
+  return elfcore_write_note (abfd, buf, bufsiz,
+                             note_name, NT_PRXFPREG, xfpregs, size);
+}
+
+static bfd_boolean
 elfcore_read_notes (abfd, offset, size)
      bfd *abfd;
-     bfd_vma offset;
-     bfd_vma size;
+     file_ptr offset;
+     bfd_size_type size;
 {
   char *buf;
@@ -5864 +7300 @@
 
   if (size <= 0)
-    return true;
-
-  if (bfd_seek (abfd, offset, SEEK_SET) == -1)
-    return false;
-
-  buf = bfd_malloc ((size_t) size);
+    return TRUE;
+
+  if (bfd_seek (abfd, offset, SEEK_SET) != 0)
+    return FALSE;
+
+  buf = bfd_malloc (size);
   if (buf == NULL)
-    return false;
-
-  if (bfd_read (buf, size, 1, abfd) != size)
+    return FALSE;
+
+  if (bfd_bread (buf, size, abfd) != size)
     {
     error:
       free (buf);
-      return false;
+      return FALSE;
     }
 
@@ -5887 +7323 @@
       Elf_Internal_Note in;
 
-      in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
-
-      in.namesz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->namesz);
+      in.type = H_GET_32 (abfd, xnp->type);
+
+      in.namesz = H_GET_32 (abfd, xnp->namesz);
       in.namedata = xnp->name;
 
-      in.descsz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->descsz);
+      in.descsz = H_GET_32 (abfd, xnp->descsz);
       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
       in.descpos = offset + (in.descdata - buf);
 
-      if (! elfcore_grok_note (abfd, &in))
-        goto error;
+      if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
+        {
+          if (! elfcore_grok_netbsd_note (abfd, &in))
+            goto error;
+        }
+      else if (strncmp (in.namedata, "QNX", 3) == 0)
+        {
+          if (! elfcore_grok_nto_note (abfd, &in))
+            goto error;
+        }
+      else
+        {
+          if (! elfcore_grok_note (abfd, &in))
+            goto error;
+        }
 
       p = in.descdata + BFD_ALIGN (in.descsz, 4);
@@ -5903 +7352 @@
 
   free (buf);
-  return true;
-}
-
-/* FIXME: This function is now unnecessary.  Callers can just call
-   bfd_section_from_phdr directly.  */
-
-boolean
-_bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
-     bfd *abfd;
-     Elf_Internal_Phdr* phdr;
-     int sec_num;
-{
-  if (! bfd_section_from_phdr (abfd, phdr, sec_num))
-    return false;
-
-  return true;
+  return TRUE;
 }
 
@@ -5938 +7372 @@
     }
 
-  return (elf_elfheader (abfd)->e_phnum
-          * sizeof (Elf_Internal_Phdr));
+  return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
 }
 
@@ -5969 +7402 @@
   return num_phdrs;
 }
+
+void
+_bfd_elf_sprintf_vma (abfd, buf, value)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     char *buf;
+     bfd_vma value;
+{
+#ifdef BFD64
+  Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
+
+  i_ehdrp = elf_elfheader (abfd);
+  if (i_ehdrp == NULL)
+    sprintf_vma (buf, value);
+  else
+    {
+      if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
+        {
+#if BFD_HOST_64BIT_LONG
+          sprintf (buf, "%016lx", value);
+#else
+          sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
+                   _bfd_int64_low (value));
+#endif
+        }
+      else
+        sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
+    }
+#else
+  sprintf_vma (buf, value);
+#endif
+}
+
+void
+_bfd_elf_fprintf_vma (abfd, stream, value)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     PTR stream;
+     bfd_vma value;
+{
+#ifdef BFD64
+  Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
+
+  i_ehdrp = elf_elfheader (abfd);
+  if (i_ehdrp == NULL)
+    fprintf_vma ((FILE *) stream, value);
+  else
+    {
+      if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
+        {
+#if BFD_HOST_64BIT_LONG
+          fprintf ((FILE *) stream, "%016lx", value);
+#else
+          fprintf ((FILE *) stream, "%08lx%08lx",
+                   _bfd_int64_high (value), _bfd_int64_low (value));
+#endif
+        }
+      else
+        fprintf ((FILE *) stream, "%08lx",
+                 (unsigned long) (value & 0xffffffff));
+    }
+#else
+  fprintf_vma ((FILE *) stream, value);
+#endif
+}
+
+enum elf_reloc_type_class
+_bfd_elf_reloc_type_class (rela)
+     const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED;
+{
+  return reloc_class_normal;
+}
+
+/* For RELA architectures, return the relocation value for a
+   relocation against a local symbol.  */
+
+bfd_vma
+_bfd_elf_rela_local_sym (abfd, sym, sec, rel)
+     bfd *abfd;
+     Elf_Internal_Sym *sym;
+     asection *sec;
+     Elf_Internal_Rela *rel;
+{
+  bfd_vma relocation;
+
+  relocation = (sec->output_section->vma
+                + sec->output_offset
+                + sym->st_value);
+  if ((sec->flags & SEC_MERGE)
+      && ELF_ST_TYPE (sym->st_info) == STT_SECTION
+      && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
+    {
+      asection *msec;
+
+      msec = sec;
+      rel->r_addend =
+        _bfd_merged_section_offset (abfd, &msec,
+                                    elf_section_data (sec)->sec_info,
+                                    sym->st_value + rel->r_addend,
+                                    (bfd_vma) 0)
+        - relocation;
+      rel->r_addend += msec->output_section->vma + msec->output_offset;
+    }
+  return relocation;
+}
+
+bfd_vma
+_bfd_elf_rel_local_sym (abfd, sym, psec, addend)
+     bfd *abfd;
+     Elf_Internal_Sym *sym;
+     asection **psec;
+     bfd_vma addend;
+{
+  asection *sec = *psec;
+
+  if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
+    return sym->st_value + addend;
+
+  return _bfd_merged_section_offset (abfd, psec,
+                                     elf_section_data (sec)->sec_info,
+                                     sym->st_value + addend, (bfd_vma) 0);
+}
+
+bfd_vma
+_bfd_elf_section_offset (abfd, info, sec, offset)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     bfd_vma offset;
+{
+  struct bfd_elf_section_data *sec_data;
+
+  sec_data = elf_section_data (sec);
+  switch (sec->sec_info_type)
+    {
+    case ELF_INFO_TYPE_STABS:
+      return _bfd_stab_section_offset (abfd,
+                                       &elf_hash_table (info)->merge_info,
+                                       sec, &sec_data->sec_info, offset);
+    case ELF_INFO_TYPE_EH_FRAME:
+      return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);
+    default:
+      return offset;
+    }
+}