bfd/elfcode.h

   1 /* ELF executable support for BFD.
   2    Copyright 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
   3
   4    Written by Fred Fish @ Cygnus Support, from information published
   5    in "UNIX System V Release 4, Programmers Guide: ANSI C and
   6    Programming Support Tools".  Sufficient support for gdb.
   7
   8    Rewritten by Mark Eichin @ Cygnus Support, from information
   9    published in "System V Application Binary Interface", chapters 4
  10    and 5, as well as the various "Processor Supplement" documents
  11    derived from it. Added support for assembler and other object file
  12    utilities.  Further work done by Ken Raeburn (Cygnus Support), Michael
  13    Meissner (Open Software Foundation), and Peter Hoogenboom (University
  14    of Utah) to finish and extend this.
  15
  16 This file is part of BFD, the Binary File Descriptor library.
  17
  18 This program is free software; you can redistribute it and/or modify
  19 it under the terms of the GNU General Public License as published by
  20 the Free Software Foundation; either version 2 of the License, or
  21 (at your option) any later version.
  22
  23 This program is distributed in the hope that it will be useful,
  24 but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 GNU General Public License for more details.
  27
  28 You should have received a copy of the GNU General Public License
  29 along with this program; if not, write to the Free Software
  30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  31
  32 /* Problems and other issues to resolve.
  33
  34    (1)  BFD expects there to be some fixed number of "sections" in
  35         the object file.  I.E. there is a "section_count" variable in the
  36         bfd structure which contains the number of sections.  However, ELF
  37         supports multiple "views" of a file.  In particular, with current
  38         implementations, executable files typically have two tables, a
  39         program header table and a section header table, both of which
  40         partition the executable.
  41
  42         In ELF-speak, the "linking view" of the file uses the section header
  43         table to access "sections" within the file, and the "execution view"
  44         uses the program header table to access "segments" within the file.
  45         "Segments" typically may contain all the data from one or more
  46         "sections".
  47
  48         Note that the section header table is optional in ELF executables,
  49         but it is this information that is most useful to gdb.  If the
  50         section header table is missing, then gdb should probably try
  51         to make do with the program header table.  (FIXME)
  52
  53    (2)  The code in this file is compiled twice, once in 32-bit mode and
  54         once in 64-bit mode.  More of it should be made size-independent
  55         and moved into elf.c.
  56
  57    (3)  ELF section symbols are handled rather sloppily now.  This should
  58         be cleaned up, and ELF section symbols reconciled with BFD section
  59         symbols.
  60
  61    (4)  We need a published spec for 64-bit ELF.  We've got some stuff here
  62         that we're using for SPARC V9 64-bit chips, but don't assume that
  63         it's cast in stone.
  64  */
  65
  66 #include <string.h>             /* For strrchr and friends */
  67 #include "bfd.h"
  68 #include "sysdep.h"
  69 #include "bfdlink.h"
  70 #include "libbfd.h"
  71 #include "libelf.h"
  72
  73 /* Renaming structures, typedefs, macros and functions to be size-specific.  */
  74 #define Elf_External_Ehdr       NAME(Elf,External_Ehdr)
  75 #define Elf_External_Sym        NAME(Elf,External_Sym)
  76 #define Elf_External_Shdr       NAME(Elf,External_Shdr)
  77 #define Elf_External_Phdr       NAME(Elf,External_Phdr)
  78 #define Elf_External_Rel        NAME(Elf,External_Rel)
  79 #define Elf_External_Rela       NAME(Elf,External_Rela)
  80 #define Elf_External_Dyn        NAME(Elf,External_Dyn)
  81
  82 #define elf_core_file_failing_command   NAME(bfd_elf,core_file_failing_command)
  83 #define elf_core_file_failing_signal    NAME(bfd_elf,core_file_failing_signal)
  84 #define elf_core_file_matches_executable_p \
  85   NAME(bfd_elf,core_file_matches_executable_p)
  86 #define elf_object_p                    NAME(bfd_elf,object_p)
  87 #define elf_core_file_p                 NAME(bfd_elf,core_file_p)
  88 #define elf_get_symtab_upper_bound      NAME(bfd_elf,get_symtab_upper_bound)
  89 #define elf_get_dynamic_symtab_upper_bound \
  90   NAME(bfd_elf,get_dynamic_symtab_upper_bound)
  91 #define elf_swap_reloc_in               NAME(bfd_elf,swap_reloc_in)
  92 #define elf_swap_reloca_in              NAME(bfd_elf,swap_reloca_in)
  93 #define elf_swap_reloc_out              NAME(bfd_elf,swap_reloc_out)
  94 #define elf_swap_reloca_out             NAME(bfd_elf,swap_reloca_out)
  95 #define elf_swap_symbol_in              NAME(bfd_elf,swap_symbol_in)
  96 #define elf_swap_symbol_out             NAME(bfd_elf,swap_symbol_out)
  97 #define elf_swap_dyn_in                 NAME(bfd_elf,swap_dyn_in)
  98 #define elf_swap_dyn_out                NAME(bfd_elf,swap_dyn_out)
  99 #define elf_get_reloc_upper_bound       NAME(bfd_elf,get_reloc_upper_bound)
 100 #define elf_canonicalize_reloc          NAME(bfd_elf,canonicalize_reloc)
 101 #define elf_get_symtab                  NAME(bfd_elf,get_symtab)
 102 #define elf_canonicalize_dynamic_symtab \
 103   NAME(bfd_elf,canonicalize_dynamic_symtab)
 104 #define elf_make_empty_symbol           NAME(bfd_elf,make_empty_symbol)
 105 #define elf_get_symbol_info             NAME(bfd_elf,get_symbol_info)
 106 #define elf_get_lineno                  NAME(bfd_elf,get_lineno)
 107 #define elf_set_arch_mach               NAME(bfd_elf,set_arch_mach)
 108 #define elf_find_nearest_line           NAME(bfd_elf,find_nearest_line)
 109 #define elf_sizeof_headers              NAME(bfd_elf,sizeof_headers)
 110 #define elf_set_section_contents        NAME(bfd_elf,set_section_contents)
 111 #define elf_no_info_to_howto            NAME(bfd_elf,no_info_to_howto)
 112 #define elf_no_info_to_howto_rel        NAME(bfd_elf,no_info_to_howto_rel)
 113 #define elf_new_section_hook            NAME(bfd_elf,new_section_hook)
 114 #define write_relocs                    NAME(bfd_elf,_write_relocs)
 115 #define elf_find_section                NAME(bfd_elf,find_section)
 116 #define elf_bfd_link_add_symbols        NAME(bfd_elf,bfd_link_add_symbols)
 117 #define elf_add_dynamic_entry           NAME(bfd_elf,add_dynamic_entry)
 118 #define elf_link_create_dynamic_sections \
 119   NAME(bfd_elf,link_create_dynamic_sections)
 120 #define elf_link_record_dynamic_symbol  \
 121   NAME(bfd_elf,link_record_dynamic_symbol)
 122 #define elf_bfd_final_link              NAME(bfd_elf,bfd_final_link)
 123
 124 #if ARCH_SIZE == 64
 125 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
 126 #define ELF_R_SYM(X)    ELF64_R_SYM(X)
 127 #define ELF_R_TYPE(X)   ELF64_R_TYPE(X)
 128 #define ELFCLASS        ELFCLASS64
 129 #define FILE_ALIGN      8
 130 #define LOG_FILE_ALIGN  3
 131 #endif
 132 #if ARCH_SIZE == 32
 133 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
 134 #define ELF_R_SYM(X)    ELF32_R_SYM(X)
 135 #define ELF_R_TYPE(X)   ELF32_R_TYPE(X)
 136 #define ELFCLASS        ELFCLASS32
 137 #define FILE_ALIGN      4
 138 #define LOG_FILE_ALIGN  2
 139 #endif
 140
 141 /* Forward declarations of static functions */
 142
 143 static struct bfd_strtab_hash *elf_stringtab_init PARAMS ((void));
 144 static asection *section_from_elf_index PARAMS ((bfd *, unsigned int));
 145
 146 static int elf_section_from_bfd_section PARAMS ((bfd *, struct sec *));
 147
 148 static long elf_slurp_symbol_table PARAMS ((bfd *, asymbol **, boolean));
 149
 150 static boolean elf_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
 151
 152 static int elf_symbol_from_bfd_symbol PARAMS ((bfd *,
 153                                              struct symbol_cache_entry **));
 154
 155 static boolean elf_compute_section_file_positions
 156   PARAMS ((bfd *, struct bfd_link_info *));
 157 static boolean prep_headers PARAMS ((bfd *));
 158 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
 159 static boolean assign_section_numbers PARAMS ((bfd *));
 160 static file_ptr align_file_position PARAMS ((file_ptr));
 161 static file_ptr assign_file_position_for_section
 162   PARAMS ((Elf_Internal_Shdr *, file_ptr, boolean));
 163 static boolean assign_file_positions_except_relocs PARAMS ((bfd *, boolean));
 164 static int elf_sort_hdrs PARAMS ((const PTR, const PTR));
 165 static void assign_file_positions_for_relocs PARAMS ((bfd *));
 166 static bfd_size_type get_program_header_size PARAMS ((bfd *));
 167 static file_ptr map_program_segments
 168   PARAMS ((bfd *, file_ptr, Elf_Internal_Shdr *, bfd_size_type));
 169
 170 static boolean elf_map_symbols PARAMS ((bfd *));
 171 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **));
 172
 173 static boolean bfd_section_from_shdr PARAMS ((bfd *, unsigned int shindex));
 174
 175 #ifdef DEBUG
 176 static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
 177 static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
 178 #endif
 179
 180 #define elf_string_from_elf_strtab(abfd,strindex) \
 181      elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
 182 \f
 183 /* Structure swapping routines */
 184
 185 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
 186    can be handled by explicitly specifying 32 bits or "the long type".  */
 187 #if ARCH_SIZE == 64
 188 #define put_word        bfd_h_put_64
 189 #define get_word        bfd_h_get_64
 190 #endif
 191 #if ARCH_SIZE == 32
 192 #define put_word        bfd_h_put_32
 193 #define get_word        bfd_h_get_32
 194 #endif
 195
 196 /* Translate an ELF symbol in external format into an ELF symbol in internal
 197    format. */
 198
 199 void
 200 elf_swap_symbol_in (abfd, src, dst)
 201      bfd *abfd;
 202      Elf_External_Sym *src;
 203      Elf_Internal_Sym *dst;
 204 {
 205   dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
 206   dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
 207   dst->st_size = get_word (abfd, (bfd_byte *) src->st_size);
 208   dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info);
 209   dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other);
 210   dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx);
 211 }
 212
 213 /* Translate an ELF symbol in internal format into an ELF symbol in external
 214    format. */
 215
 216 void
 217 elf_swap_symbol_out (abfd, src, dst)
 218      bfd *abfd;
 219      Elf_Internal_Sym *src;
 220      Elf_External_Sym *dst;
 221 {
 222   bfd_h_put_32 (abfd, src->st_name, dst->st_name);
 223   put_word (abfd, src->st_value, dst->st_value);
 224   put_word (abfd, src->st_size, dst->st_size);
 225   bfd_h_put_8 (abfd, src->st_info, dst->st_info);
 226   bfd_h_put_8 (abfd, src->st_other, dst->st_other);
 227   bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx);
 228 }
 229
 230
 231 /* Translate an ELF file header in external format into an ELF file header in
 232    internal format. */
 233
 234 static void
 235 elf_swap_ehdr_in (abfd, src, dst)
 236      bfd *abfd;
 237      Elf_External_Ehdr *src;
 238      Elf_Internal_Ehdr *dst;
 239 {
 240   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 241   dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
 242   dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine);
 243   dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version);
 244   dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry);
 245   dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff);
 246   dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff);
 247   dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags);
 248   dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize);
 249   dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize);
 250   dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum);
 251   dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize);
 252   dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum);
 253   dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx);
 254 }
 255
 256 /* Translate an ELF file header in internal format into an ELF file header in
 257    external format. */
 258
 259 static void
 260 elf_swap_ehdr_out (abfd, src, dst)
 261      bfd *abfd;
 262      Elf_Internal_Ehdr *src;
 263      Elf_External_Ehdr *dst;
 264 {
 265   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 266   /* note that all elements of dst are *arrays of unsigned char* already... */
 267   bfd_h_put_16 (abfd, src->e_type, dst->e_type);
 268   bfd_h_put_16 (abfd, src->e_machine, dst->e_machine);
 269   bfd_h_put_32 (abfd, src->e_version, dst->e_version);
 270   put_word (abfd, src->e_entry, dst->e_entry);
 271   put_word (abfd, src->e_phoff, dst->e_phoff);
 272   put_word (abfd, src->e_shoff, dst->e_shoff);
 273   bfd_h_put_32 (abfd, src->e_flags, dst->e_flags);
 274   bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize);
 275   bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize);
 276   bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum);
 277   bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize);
 278   bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum);
 279   bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx);
 280 }
 281
 282
 283 /* Translate an ELF section header table entry in external format into an
 284    ELF section header table entry in internal format. */
 285
 286 static void
 287 elf_swap_shdr_in (abfd, src, dst)
 288      bfd *abfd;
 289      Elf_External_Shdr *src;
 290      Elf_Internal_Shdr *dst;
 291 {
 292   dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
 293   dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
 294   dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags);
 295   dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr);
 296   dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset);
 297   dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size);
 298   dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link);
 299   dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
 300   dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
 301   dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
 302   dst->bfd_section = NULL;
 303   dst->contents = NULL;
 304 }
 305
 306 /* Translate an ELF section header table entry in internal format into an
 307    ELF section header table entry in external format. */
 308
 309 static void
 310 elf_swap_shdr_out (abfd, src, dst)
 311      bfd *abfd;
 312      Elf_Internal_Shdr *src;
 313      Elf_External_Shdr *dst;
 314 {
 315   /* note that all elements of dst are *arrays of unsigned char* already... */
 316   bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
 317   bfd_h_put_32 (abfd, src->sh_type, dst->sh_type);
 318   put_word (abfd, src->sh_flags, dst->sh_flags);
 319   put_word (abfd, src->sh_addr, dst->sh_addr);
 320   put_word (abfd, src->sh_offset, dst->sh_offset);
 321   put_word (abfd, src->sh_size, dst->sh_size);
 322   bfd_h_put_32 (abfd, src->sh_link, dst->sh_link);
 323   bfd_h_put_32 (abfd, src->sh_info, dst->sh_info);
 324   put_word (abfd, src->sh_addralign, dst->sh_addralign);
 325   put_word (abfd, src->sh_entsize, dst->sh_entsize);
 326 }
 327
 328
 329 /* Translate an ELF program header table entry in external format into an
 330    ELF program header table entry in internal format. */
 331
 332 static void
 333 elf_swap_phdr_in (abfd, src, dst)
 334      bfd *abfd;
 335      Elf_External_Phdr *src;
 336      Elf_Internal_Phdr *dst;
 337 {
 338   dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
 339   dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
 340   dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset);
 341   dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr);
 342   dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr);
 343   dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz);
 344   dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz);
 345   dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
 346 }
 347
 348 static void
 349 elf_swap_phdr_out (abfd, src, dst)
 350      bfd *abfd;
 351      Elf_Internal_Phdr *src;
 352      Elf_External_Phdr *dst;
 353 {
 354   /* note that all elements of dst are *arrays of unsigned char* already... */
 355   bfd_h_put_32 (abfd, src->p_type, dst->p_type);
 356   put_word (abfd, src->p_offset, dst->p_offset);
 357   put_word (abfd, src->p_vaddr, dst->p_vaddr);
 358   put_word (abfd, src->p_paddr, dst->p_paddr);
 359   put_word (abfd, src->p_filesz, dst->p_filesz);
 360   put_word (abfd, src->p_memsz, dst->p_memsz);
 361   bfd_h_put_32 (abfd, src->p_flags, dst->p_flags);
 362   put_word (abfd, src->p_align, dst->p_align);
 363 }
 364
 365 /* Translate an ELF reloc from external format to internal format. */
 366 INLINE void
 367 elf_swap_reloc_in (abfd, src, dst)
 368      bfd *abfd;
 369      Elf_External_Rel *src;
 370      Elf_Internal_Rel *dst;
 371 {
 372   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
 373   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
 374 }
 375
 376 INLINE void
 377 elf_swap_reloca_in (abfd, src, dst)
 378      bfd *abfd;
 379      Elf_External_Rela *src;
 380      Elf_Internal_Rela *dst;
 381 {
 382   dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
 383   dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
 384   dst->r_addend = get_word (abfd, (bfd_byte *) src->r_addend);
 385 }
 386
 387 /* Translate an ELF reloc from internal format to external format. */
 388 INLINE void
 389 elf_swap_reloc_out (abfd, src, dst)
 390      bfd *abfd;
 391      Elf_Internal_Rel *src;
 392      Elf_External_Rel *dst;
 393 {
 394   put_word (abfd, src->r_offset, dst->r_offset);
 395   put_word (abfd, src->r_info, dst->r_info);
 396 }
 397
 398 INLINE void
 399 elf_swap_reloca_out (abfd, src, dst)
 400      bfd *abfd;
 401      Elf_Internal_Rela *src;
 402      Elf_External_Rela *dst;
 403 {
 404   put_word (abfd, src->r_offset, dst->r_offset);
 405   put_word (abfd, src->r_info, dst->r_info);
 406   put_word (abfd, src->r_addend, dst->r_addend);
 407 }
 408
 409 INLINE void
 410 elf_swap_dyn_in (abfd, src, dst)
 411      bfd *abfd;
 412      const Elf_External_Dyn *src;
 413      Elf_Internal_Dyn *dst;
 414 {
 415   dst->d_tag = get_word (abfd, src->d_tag);
 416   dst->d_un.d_val = get_word (abfd, src->d_un.d_val);
 417 }
 418
 419 INLINE void
 420 elf_swap_dyn_out (abfd, src, dst)
 421      bfd *abfd;
 422      const Elf_Internal_Dyn *src;
 423      Elf_External_Dyn *dst;
 424 {
 425   put_word (abfd, src->d_tag, dst->d_tag);
 426   put_word (abfd, src->d_un.d_val, dst->d_un.d_val);
 427 }
 428 \f
 429 /* Allocate an ELF string table--force the first byte to be zero.  */
 430
 431 static struct bfd_strtab_hash *
 432 elf_stringtab_init ()
 433 {
 434   struct bfd_strtab_hash *ret;
 435
 436   ret = _bfd_stringtab_init ();
 437   if (ret != NULL)
 438     {
 439       bfd_size_type loc;
 440
 441       loc = _bfd_stringtab_add (ret, "", true, false);
 442       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
 443       if (loc == (bfd_size_type) -1)
 444         {
 445           _bfd_stringtab_free (ret);
 446           ret = NULL;
 447         }
 448     }
 449   return ret;
 450 }
 451 \f
 452 /* ELF .o/exec file reading */
 453
 454 /* Create a new bfd section from an ELF section header. */
 455
 456 static boolean
 457 bfd_section_from_shdr (abfd, shindex)
 458      bfd *abfd;
 459      unsigned int shindex;
 460 {
 461   Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
 462   Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
 463   char *name;
 464
 465   name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
 466
 467   switch (hdr->sh_type)
 468     {
 469     case SHT_NULL:
 470       /* Inactive section. Throw it away.  */
 471       return true;
 472
 473     case SHT_PROGBITS:  /* Normal section with contents.  */
 474     case SHT_DYNAMIC:   /* Dynamic linking information.  */
 475     case SHT_NOBITS:    /* .bss section.  */
 476     case SHT_HASH:      /* .hash section.  */
 477       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
 478
 479     case SHT_SYMTAB:            /* A symbol table */
 480       if (elf_onesymtab (abfd) == shindex)
 481         return true;
 482
 483       BFD_ASSERT (hdr->sh_entsize == sizeof (Elf_External_Sym));
 484       BFD_ASSERT (elf_onesymtab (abfd) == 0);
 485       elf_onesymtab (abfd) = shindex;
 486       elf_tdata (abfd)->symtab_hdr = *hdr;
 487       elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_hdr;
 488       abfd->flags |= HAS_SYMS;
 489
 490       /* Sometimes a shared object will map in the symbol table.  If
 491          SHF_ALLOC is set, and this is a shared object, then we also
 492          treat this section as a BFD section.  We can not base the
 493          decision purely on SHF_ALLOC, because that flag is sometimes
 494          set in a relocateable object file, which would confuse the
 495          linker.  */
 496       if ((hdr->sh_flags & SHF_ALLOC) != 0
 497           && (abfd->flags & DYNAMIC) != 0
 498           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
 499         return false;
 500
 501       return true;
 502
 503     case SHT_DYNSYM:            /* A dynamic symbol table */
 504       if (elf_dynsymtab (abfd) == shindex)
 505         return true;
 506
 507       BFD_ASSERT (hdr->sh_entsize == sizeof (Elf_External_Sym));
 508       BFD_ASSERT (elf_dynsymtab (abfd) == 0);
 509       elf_dynsymtab (abfd) = shindex;
 510       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
 511       elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->dynsymtab_hdr;
 512       abfd->flags |= HAS_SYMS;
 513
 514       /* Besides being a symbol table, we also treat this as a regular
 515          section, so that objcopy can handle it.  */
 516       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
 517
 518     case SHT_STRTAB:            /* A string table */
 519       if (hdr->bfd_section != NULL)
 520         return true;
 521       if (ehdr->e_shstrndx == shindex)
 522         {
 523           elf_tdata (abfd)->shstrtab_hdr = *hdr;
 524           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
 525           return true;
 526         }
 527       {
 528         unsigned int i;
 529
 530         for (i = 1; i < ehdr->e_shnum; i++)
 531           {
 532             Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
 533             if (hdr2->sh_link == shindex)
 534               {
 535                 if (! bfd_section_from_shdr (abfd, i))
 536                   return false;
 537                 if (elf_onesymtab (abfd) == i)
 538                   {
 539                     elf_tdata (abfd)->strtab_hdr = *hdr;
 540                     elf_elfsections (abfd)[shindex] =
 541                       &elf_tdata (abfd)->strtab_hdr;
 542                     return true;
 543                   }
 544                 if (elf_dynsymtab (abfd) == i)
 545                   {
 546                     elf_tdata (abfd)->dynstrtab_hdr = *hdr;
 547                     elf_elfsections (abfd)[shindex] =
 548                       &elf_tdata (abfd)->dynstrtab_hdr;
 549                     /* We also treat this as a regular section, so
 550                        that objcopy can handle it.  */
 551                     break;
 552                   }
 553 #if 0 /* Not handling other string tables specially right now.  */
 554                 hdr2 = elf_elfsections (abfd)[i];       /* in case it moved */
 555                 /* We have a strtab for some random other section.  */
 556                 newsect = (asection *) hdr2->bfd_section;
 557                 if (!newsect)
 558                   break;
 559                 hdr->bfd_section = newsect;
 560                 hdr2 = &elf_section_data (newsect)->str_hdr;
 561                 *hdr2 = *hdr;
 562                 elf_elfsections (abfd)[shindex] = hdr2;
 563 #endif
 564               }
 565           }
 566       }
 567
 568       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
 569
 570     case SHT_REL:
 571     case SHT_RELA:
 572       /* *These* do a lot of work -- but build no sections!  */
 573       {
 574         asection *target_sect;
 575         Elf_Internal_Shdr *hdr2;
 576         int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
 577
 578         /* Get the symbol table.  */
 579         if (! bfd_section_from_shdr (abfd, hdr->sh_link))
 580           return false;
 581
 582         /* If this reloc section does not use the main symbol table we
 583            don't treat it as a reloc section.  BFD can't adequately
 584            represent such a section, so at least for now, we don't
 585            try.  We just present it as a normal section.  */
 586         if (hdr->sh_link != elf_onesymtab (abfd))
 587           return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
 588
 589         /* Don't allow REL relocations on a machine that uses RELA and
 590            vice versa.  */
 591         /* @@ Actually, the generic ABI does suggest that both might be
 592            used in one file.  But the four ABI Processor Supplements I
 593            have access to right now all specify that only one is used on
 594            each of those architectures.  It's conceivable that, e.g., a
 595            bunch of absolute 32-bit relocs might be more compact in REL
 596            form even on a RELA machine...  */
 597         BFD_ASSERT (use_rela_p
 598                     ? (hdr->sh_type == SHT_RELA
 599                        && hdr->sh_entsize == sizeof (Elf_External_Rela))
 600                     : (hdr->sh_type == SHT_REL
 601                        && hdr->sh_entsize == sizeof (Elf_External_Rel)));
 602
 603         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
 604           return false;
 605         target_sect = section_from_elf_index (abfd, hdr->sh_info);
 606         if (target_sect == NULL)
 607           return false;
 608
 609         hdr2 = &elf_section_data (target_sect)->rel_hdr;
 610         *hdr2 = *hdr;
 611         elf_elfsections (abfd)[shindex] = hdr2;
 612         target_sect->reloc_count = hdr->sh_size / hdr->sh_entsize;
 613         target_sect->flags |= SEC_RELOC;
 614         target_sect->relocation = NULL;
 615         target_sect->rel_filepos = hdr->sh_offset;
 616         abfd->flags |= HAS_RELOC;
 617         return true;
 618       }
 619       break;
 620
 621     case SHT_NOTE:
 622 #if 0
 623       fprintf (stderr, "Note Sections not yet supported.\n");
 624       BFD_FAIL ();
 625 #endif
 626       break;
 627
 628     case SHT_SHLIB:
 629 #if 0
 630       fprintf (stderr, "SHLIB Sections not supported (and non conforming.)\n");
 631 #endif
 632       return true;
 633
 634     default:
 635       /* Check for any processor-specific section types.  */
 636       {
 637         struct elf_backend_data *bed = get_elf_backend_data (abfd);
 638
 639         if (bed->elf_backend_section_from_shdr)
 640           (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
 641       }
 642       break;
 643     }
 644
 645   return true;
 646 }
 647
 648 boolean
 649 elf_new_section_hook (abfd, sec)
 650      bfd *abfd
 651       ;
 652      asection *sec;
 653 {
 654   struct bfd_elf_section_data *sdata;
 655
 656   sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata));
 657   if (!sdata)
 658     {
 659       bfd_set_error (bfd_error_no_memory);
 660       return false;
 661     }
 662   sec->used_by_bfd = (PTR) sdata;
 663   memset (sdata, 0, sizeof (*sdata));
 664   return true;
 665 }
 666
 667 /* Create a new bfd section from an ELF program header.
 668
 669    Since program segments have no names, we generate a synthetic name
 670    of the form segment<NUM>, where NUM is generally the index in the
 671    program header table.  For segments that are split (see below) we
 672    generate the names segment<NUM>a and segment<NUM>b.
 673
 674    Note that some program segments may have a file size that is different than
 675    (less than) the memory size.  All this means is that at execution the
 676    system must allocate the amount of memory specified by the memory size,
 677    but only initialize it with the first "file size" bytes read from the
 678    file.  This would occur for example, with program segments consisting
 679    of combined data+bss.
 680
 681    To handle the above situation, this routine generates TWO bfd sections
 682    for the single program segment.  The first has the length specified by
 683    the file size of the segment, and the second has the length specified
 684    by the difference between the two sizes.  In effect, the segment is split
 685    into it's initialized and uninitialized parts.
 686
 687  */
 688
 689 static boolean
 690 bfd_section_from_phdr (abfd, hdr, index)
 691      bfd *abfd;
 692      Elf_Internal_Phdr *hdr;
 693      int index;
 694 {
 695   asection *newsect;
 696   char *name;
 697   char namebuf[64];
 698   int split;
 699
 700   split = ((hdr->p_memsz > 0) &&
 701            (hdr->p_filesz > 0) &&
 702            (hdr->p_memsz > hdr->p_filesz));
 703   sprintf (namebuf, split ? "segment%da" : "segment%d", index);
 704   name = bfd_alloc (abfd, strlen (namebuf) + 1);
 705   if (!name)
 706     {
 707       bfd_set_error (bfd_error_no_memory);
 708       return false;
 709     }
 710   strcpy (name, namebuf);
 711   newsect = bfd_make_section (abfd, name);
 712   if (newsect == NULL)
 713     return false;
 714   newsect->vma = hdr->p_vaddr;
 715   newsect->_raw_size = hdr->p_filesz;
 716   newsect->filepos = hdr->p_offset;
 717   newsect->flags |= SEC_HAS_CONTENTS;
 718   if (hdr->p_type == PT_LOAD)
 719     {
 720       newsect->flags |= SEC_ALLOC;
 721       newsect->flags |= SEC_LOAD;
 722       if (hdr->p_flags & PF_X)
 723         {
 724           /* FIXME: all we known is that it has execute PERMISSION,
 725              may be data. */
 726           newsect->flags |= SEC_CODE;
 727         }
 728     }
 729   if (!(hdr->p_flags & PF_W))
 730     {
 731       newsect->flags |= SEC_READONLY;
 732     }
 733
 734   if (split)
 735     {
 736       sprintf (namebuf, "segment%db", index);
 737       name = bfd_alloc (abfd, strlen (namebuf) + 1);
 738       if (!name)
 739         {
 740           bfd_set_error (bfd_error_no_memory);
 741           return false;
 742         }
 743       strcpy (name, namebuf);
 744       newsect = bfd_make_section (abfd, name);
 745       if (newsect == NULL)
 746         return false;
 747       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
 748       newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
 749       if (hdr->p_type == PT_LOAD)
 750         {
 751           newsect->flags |= SEC_ALLOC;
 752           if (hdr->p_flags & PF_X)
 753             newsect->flags |= SEC_CODE;
 754         }
 755       if (!(hdr->p_flags & PF_W))
 756         newsect->flags |= SEC_READONLY;
 757     }
 758
 759   return true;
 760 }
 761
 762 /* Begin processing a given object.
 763
 764    First we validate the file by reading in the ELF header and checking
 765    the magic number.  */
 766
 767 static INLINE boolean
 768 elf_file_p (x_ehdrp)
 769      Elf_External_Ehdr *x_ehdrp;
 770 {
 771   return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
 772           && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
 773           && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
 774           && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
 775 }
 776
 777 /* Check to see if the file associated with ABFD matches the target vector
 778    that ABFD points to.
 779
 780    Note that we may be called several times with the same ABFD, but different
 781    target vectors, most of which will not match.  We have to avoid leaving
 782    any side effects in ABFD, or any data it points to (like tdata), if the
 783    file does not match the target vector.  */
 784
 785 const bfd_target *
 786 elf_object_p (abfd)
 787      bfd *abfd;
 788 {
 789   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 790   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 791   Elf_External_Shdr x_shdr;     /* Section header table entry, external form */
 792   Elf_Internal_Shdr *i_shdrp = NULL; /* Section header table, internal form */
 793   unsigned int shindex;
 794   char *shstrtab;               /* Internal copy of section header stringtab */
 795   struct elf_backend_data *ebd;
 796   struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
 797   struct elf_obj_tdata *new_tdata = NULL;
 798
 799   /* Read in the ELF header in external format.  */
 800
 801   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
 802     {
 803       if (bfd_get_error () != bfd_error_system_call)
 804         goto got_wrong_format_error;
 805       else
 806         goto got_no_match;
 807     }
 808
 809   /* Now check to see if we have a valid ELF file, and one that BFD can
 810      make use of.  The magic number must match, the address size ('class')
 811      and byte-swapping must match our XVEC entry, and it must have a
 812      section header table (FIXME: See comments re sections at top of this
 813      file). */
 814
 815   if ((elf_file_p (&x_ehdr) == false) ||
 816       (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) ||
 817       (x_ehdr.e_ident[EI_CLASS] != ELFCLASS))
 818     goto got_wrong_format_error;
 819
 820   /* Check that file's byte order matches xvec's */
 821   switch (x_ehdr.e_ident[EI_DATA])
 822     {
 823     case ELFDATA2MSB:           /* Big-endian */
 824       if (!abfd->xvec->header_byteorder_big_p)
 825         goto got_wrong_format_error;
 826       break;
 827     case ELFDATA2LSB:           /* Little-endian */
 828       if (abfd->xvec->header_byteorder_big_p)
 829         goto got_wrong_format_error;
 830       break;
 831     case ELFDATANONE:           /* No data encoding specified */
 832     default:                    /* Unknown data encoding specified */
 833       goto got_wrong_format_error;
 834     }
 835
 836   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
 837      the tdata pointer in the bfd.  */
 838
 839   new_tdata = ((struct elf_obj_tdata *)
 840                bfd_zalloc (abfd, sizeof (struct elf_obj_tdata)));
 841   if (new_tdata == NULL)
 842     goto got_no_memory_error;
 843   elf_tdata (abfd) = new_tdata;
 844
 845   /* Now that we know the byte order, swap in the rest of the header */
 846   i_ehdrp = elf_elfheader (abfd);
 847   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 848 #if DEBUG & 1
 849   elf_debug_file (i_ehdrp);
 850 #endif
 851
 852   /* If there is no section header table, we're hosed. */
 853   if (i_ehdrp->e_shoff == 0)
 854     goto got_wrong_format_error;
 855
 856   /* As a simple sanity check, verify that the what BFD thinks is the
 857      size of each section header table entry actually matches the size
 858      recorded in the file. */
 859   if (i_ehdrp->e_shentsize != sizeof (x_shdr))
 860     goto got_wrong_format_error;
 861
 862   ebd = get_elf_backend_data (abfd);
 863
 864   /* Check that the ELF e_machine field matches what this particular
 865      BFD format expects.  */
 866   if (ebd->elf_machine_code != i_ehdrp->e_machine)
 867     {
 868       const bfd_target * const *target_ptr;
 869
 870       if (ebd->elf_machine_code != EM_NONE)
 871         goto got_wrong_format_error;
 872
 873       /* This is the generic ELF target.  Let it match any ELF target
 874          for which we do not have a specific backend.  */
 875       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 876         {
 877           struct elf_backend_data *back;
 878
 879           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 880             continue;
 881           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 882           if (back->elf_machine_code == i_ehdrp->e_machine)
 883             {
 884               /* target_ptr is an ELF backend which matches this
 885                  object file, so reject the generic ELF target.  */
 886               goto got_wrong_format_error;
 887             }
 888         }
 889     }
 890
 891   if (i_ehdrp->e_type == ET_EXEC)
 892     abfd->flags |= EXEC_P;
 893   else if (i_ehdrp->e_type == ET_DYN)
 894     abfd->flags |= DYNAMIC;
 895
 896   if (i_ehdrp->e_phnum > 0)
 897     abfd->flags |= D_PAGED;
 898
 899   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 900     goto got_no_match;
 901
 902   /* Remember the entry point specified in the ELF file header. */
 903   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 904
 905   /* Allocate space for a copy of the section header table in
 906      internal form, seek to the section header table in the file,
 907      read it in, and convert it to internal form.  */
 908   i_shdrp = ((Elf_Internal_Shdr *)
 909              bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum));
 910   elf_elfsections (abfd) = ((Elf_Internal_Shdr **)
 911                             bfd_alloc (abfd,
 912                                        sizeof (i_shdrp) * i_ehdrp->e_shnum));
 913   if (!i_shdrp || !elf_elfsections (abfd))
 914     goto got_no_memory_error;
 915   if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) != 0)
 916     goto got_no_match;
 917   for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
 918     {
 919       if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
 920         goto got_no_match;
 921       elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
 922       elf_elfsections (abfd)[shindex] = i_shdrp + shindex;
 923     }
 924   if (i_ehdrp->e_shstrndx)
 925     {
 926       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
 927         goto got_no_match;
 928     }
 929
 930   /* Read in the string table containing the names of the sections.  We
 931      will need the base pointer to this table later. */
 932   /* We read this inline now, so that we don't have to go through
 933      bfd_section_from_shdr with it (since this particular strtab is
 934      used to find all of the ELF section names.) */
 935
 936   shstrtab = elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
 937   if (!shstrtab)
 938     goto got_no_match;
 939
 940   /* Once all of the section headers have been read and converted, we
 941      can start processing them.  Note that the first section header is
 942      a dummy placeholder entry, so we ignore it.  */
 943
 944   for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
 945     {
 946       if (! bfd_section_from_shdr (abfd, shindex))
 947         goto got_no_match;
 948     }
 949
 950   /* Let the backend double check the format and override global
 951      information.  */
 952   if (ebd->elf_backend_object_p)
 953     {
 954       if ((*ebd->elf_backend_object_p) (abfd) == false)
 955         goto got_wrong_format_error;
 956     }
 957
 958   return (abfd->xvec);
 959
 960 got_wrong_format_error:
 961   bfd_set_error (bfd_error_wrong_format);
 962   goto got_no_match;
 963 got_no_memory_error:
 964   bfd_set_error (bfd_error_no_memory);
 965   goto got_no_match;
 966 got_no_match:
 967   if (new_tdata != NULL
 968       && new_tdata->elf_sect_ptr != NULL)
 969     bfd_release (abfd, new_tdata->elf_sect_ptr);
 970   if (i_shdrp != NULL)
 971     bfd_release (abfd, i_shdrp);
 972   if (new_tdata != NULL)
 973     bfd_release (abfd, new_tdata);
 974   elf_tdata (abfd) = preserved_tdata;
 975   return (NULL);
 976 }
 977 \f
 978
 979 /* ELF .o/exec file writing */
 980
 981 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
 982    of the symbol if there is one.  */
 983 static INLINE elf_symbol_type *
 984 elf_symbol_from (ignore_abfd, symbol)
 985      bfd *ignore_abfd;
 986      asymbol *symbol;
 987 {
 988   if (symbol->the_bfd->xvec->flavour != bfd_target_elf_flavour)
 989     return 0;
 990
 991   if (symbol->the_bfd->tdata.elf_obj_data == (struct elf_obj_tdata *) NULL)
 992     return 0;
 993
 994   return (elf_symbol_type *) symbol;
 995 }
 996
 997 void
 998 write_relocs (abfd, sec, xxx)
 999      bfd *abfd;
1000      asection *sec;
1001      PTR xxx;
1002 {
1003   Elf_Internal_Shdr *rela_hdr;
1004   Elf_External_Rela *outbound_relocas;
1005   Elf_External_Rel *outbound_relocs;
1006   int idx;
1007   int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1008   asymbol *last_sym = 0;
1009   int last_sym_idx = 9999999;   /* should always be written before use */
1010
1011   if ((sec->flags & SEC_RELOC) == 0)
1012     return;
1013
1014   /* The linker backend writes the relocs out itself, and sets the
1015      reloc_count field to zero to inhibit writing them here.  Also,
1016      sometimes the SEC_RELOC flag gets set even when there aren't any
1017      relocs.  */
1018   if (sec->reloc_count == 0)
1019     return;
1020
1021   rela_hdr = &elf_section_data (sec)->rel_hdr;
1022
1023   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
1024   rela_hdr->contents = (void *) bfd_alloc (abfd, rela_hdr->sh_size);
1025   if (!rela_hdr->contents)
1026     {
1027       bfd_set_error (bfd_error_no_memory);
1028       abort ();                 /* FIXME */
1029     }
1030
1031   /* orelocation has the data, reloc_count has the count... */
1032   if (use_rela_p)
1033     {
1034       outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
1035
1036       for (idx = 0; idx < sec->reloc_count; idx++)
1037         {
1038           Elf_Internal_Rela dst_rela;
1039           Elf_External_Rela *src_rela;
1040           arelent *ptr;
1041           asymbol *sym;
1042           int n;
1043
1044           ptr = sec->orelocation[idx];
1045           src_rela = outbound_relocas + idx;
1046           if (!(abfd->flags & EXEC_P))
1047             dst_rela.r_offset = ptr->address - sec->vma;
1048           else
1049             dst_rela.r_offset = ptr->address;
1050
1051           sym = *ptr->sym_ptr_ptr;
1052           if (sym == last_sym)
1053             n = last_sym_idx;
1054           else
1055             {
1056               last_sym = sym;
1057               last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
1058             }
1059           dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1060
1061           dst_rela.r_addend = ptr->addend;
1062           elf_swap_reloca_out (abfd, &dst_rela, src_rela);
1063         }
1064     }
1065   else
1066     /* REL relocations */
1067     {
1068       outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
1069
1070       for (idx = 0; idx < sec->reloc_count; idx++)
1071         {
1072           Elf_Internal_Rel dst_rel;
1073           Elf_External_Rel *src_rel;
1074           arelent *ptr;
1075           int n;
1076           asymbol *sym;
1077
1078           ptr = sec->orelocation[idx];
1079           sym = *ptr->sym_ptr_ptr;
1080           src_rel = outbound_relocs + idx;
1081           if (!(abfd->flags & EXEC_P))
1082             dst_rel.r_offset = ptr->address - sec->vma;
1083           else
1084             dst_rel.r_offset = ptr->address;
1085
1086           if (sym == last_sym)
1087             n = last_sym_idx;
1088           else
1089             {
1090               last_sym = sym;
1091               last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
1092             }
1093           dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
1094
1095           elf_swap_reloc_out (abfd, &dst_rel, src_rel);
1096         }
1097     }
1098 }
1099
1100 /* Set up an ELF internal section header for a section.  */
1101
1102 /*ARGSUSED*/
1103 static void
1104 elf_fake_sections (abfd, asect, failedptrarg)
1105      bfd *abfd;
1106      asection *asect;
1107      PTR failedptrarg;
1108 {
1109   boolean *failedptr = (boolean *) failedptrarg;
1110   Elf_Internal_Shdr *this_hdr;
1111
1112   if (*failedptr)
1113     {
1114       /* We already failed; just get out of the bfd_map_over_sections
1115          loop.  */
1116       return;
1117     }
1118
1119   this_hdr = &elf_section_data (asect)->this_hdr;
1120
1121   this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1122                                                           asect->name,
1123                                                           true, false);
1124   if (this_hdr->sh_name == (unsigned long) -1)
1125     {
1126       *failedptr = true;
1127       return;
1128     }
1129
1130   this_hdr->sh_flags = 0;
1131   if ((asect->flags & SEC_ALLOC) != 0)
1132     this_hdr->sh_addr = asect->vma;
1133   else
1134     this_hdr->sh_addr = 0;
1135   this_hdr->sh_offset = 0;
1136   this_hdr->sh_size = asect->_raw_size;
1137   this_hdr->sh_link = 0;
1138   this_hdr->sh_info = 0;
1139   this_hdr->sh_addralign = 1 << asect->alignment_power;
1140   this_hdr->sh_entsize = 0;
1141
1142   this_hdr->bfd_section = asect;
1143   this_hdr->contents = NULL;
1144
1145   /* FIXME: This should not be based on section names.  */
1146   if (strcmp (asect->name, ".dynstr") == 0)
1147     this_hdr->sh_type = SHT_STRTAB;
1148   else if (strcmp (asect->name, ".hash") == 0)
1149     {
1150       this_hdr->sh_type = SHT_HASH;
1151       this_hdr->sh_entsize = ARCH_SIZE / 8;
1152     }
1153   else if (strcmp (asect->name, ".dynsym") == 0)
1154     {
1155       this_hdr->sh_type = SHT_DYNSYM;
1156       this_hdr->sh_entsize = sizeof (Elf_External_Sym);
1157     }
1158   else if (strcmp (asect->name, ".dynamic") == 0)
1159     {
1160       this_hdr->sh_type = SHT_DYNAMIC;
1161       this_hdr->sh_entsize = sizeof (Elf_External_Dyn);
1162     }
1163   else if (strncmp (asect->name, ".rela", 5) == 0
1164            && get_elf_backend_data (abfd)->use_rela_p)
1165     {
1166       this_hdr->sh_type = SHT_RELA;
1167       this_hdr->sh_entsize = sizeof (Elf_External_Rela);
1168     }
1169   else if (strncmp (asect->name, ".rel", 4) == 0
1170            && ! get_elf_backend_data (abfd)->use_rela_p)
1171     {
1172       this_hdr->sh_type = SHT_REL;
1173       this_hdr->sh_entsize = sizeof (Elf_External_Rel);
1174     }
1175   else if (strcmp (asect->name, ".note") == 0)
1176     this_hdr->sh_type = SHT_NOTE;
1177   else if (strncmp (asect->name, ".stab", 5) == 0
1178            && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1179     this_hdr->sh_type = SHT_STRTAB;
1180   else if ((asect->flags & SEC_ALLOC) != 0
1181            && (asect->flags & SEC_LOAD) != 0)
1182     this_hdr->sh_type = SHT_PROGBITS;
1183   else if ((asect->flags & SEC_ALLOC) != 0
1184            && ((asect->flags & SEC_LOAD) == 0))
1185     {
1186       BFD_ASSERT (strcmp (asect->name, ".bss") == 0
1187                   || strcmp (asect->name, ".sbss") == 0);
1188       this_hdr->sh_type = SHT_NOBITS;
1189     }
1190   else
1191     {
1192       /* Who knows?  */
1193       this_hdr->sh_type = SHT_PROGBITS;
1194     }
1195
1196   if ((asect->flags & SEC_ALLOC) != 0)
1197     this_hdr->sh_flags |= SHF_ALLOC;
1198   if ((asect->flags & SEC_READONLY) == 0)
1199     this_hdr->sh_flags |= SHF_WRITE;
1200   if ((asect->flags & SEC_CODE) != 0)
1201     this_hdr->sh_flags |= SHF_EXECINSTR;
1202
1203   /* Check for processor-specific section types.  */
1204   {
1205     struct elf_backend_data *bed = get_elf_backend_data (abfd);
1206
1207     if (bed->elf_backend_fake_sections)
1208       (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1209   }
1210
1211   /* If the section has relocs, set up a section header for the
1212      SHT_REL[A] section.  */
1213   if ((asect->flags & SEC_RELOC) != 0)
1214     {
1215       Elf_Internal_Shdr *rela_hdr;
1216       int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1217       char *name;
1218
1219       rela_hdr = &elf_section_data (asect)->rel_hdr;
1220       name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1221       if (name == NULL)
1222         {
1223           bfd_set_error (bfd_error_no_memory);
1224           *failedptr = true;
1225           return;
1226         }
1227       sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1228       rela_hdr->sh_name =
1229         (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1230                                            true, false);
1231       if (rela_hdr->sh_name == (unsigned int) -1)
1232         {
1233           *failedptr = true;
1234           return;
1235         }
1236       rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1237       rela_hdr->sh_entsize = (use_rela_p
1238                               ? sizeof (Elf_External_Rela)
1239                               : sizeof (Elf_External_Rel));
1240       rela_hdr->sh_addralign = FILE_ALIGN;
1241       rela_hdr->sh_flags = 0;
1242       rela_hdr->sh_addr = 0;
1243       rela_hdr->sh_size = 0;
1244       rela_hdr->sh_offset = 0;
1245     }
1246 }
1247
1248 /* Assign all ELF section numbers.  The dummy first section is handled here
1249    too.  The link/info pointers for the standard section types are filled
1250    in here too, while we're at it.  */
1251
1252 static boolean
1253 assign_section_numbers (abfd)
1254      bfd *abfd;
1255 {
1256   struct elf_obj_tdata *t = elf_tdata (abfd);
1257   asection *sec;
1258   unsigned int section_number;
1259   Elf_Internal_Shdr **i_shdrp;
1260
1261   section_number = 1;
1262
1263   for (sec = abfd->sections; sec; sec = sec->next)
1264     {
1265       struct bfd_elf_section_data *d = elf_section_data (sec);
1266
1267       d->this_idx = section_number++;
1268       if ((sec->flags & SEC_RELOC) == 0)
1269         d->rel_idx = 0;
1270       else
1271         d->rel_idx = section_number++;
1272     }
1273
1274   t->shstrtab_section = section_number++;
1275   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1276   t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1277
1278   if (abfd->symcount > 0)
1279     {
1280       t->symtab_section = section_number++;
1281       t->strtab_section = section_number++;
1282     }
1283
1284   elf_elfheader (abfd)->e_shnum = section_number;
1285
1286   /* Set up the list of section header pointers, in agreement with the
1287      indices.  */
1288   i_shdrp = ((Elf_Internal_Shdr **)
1289              bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1290   if (i_shdrp == NULL)
1291     {
1292       bfd_set_error (bfd_error_no_memory);
1293       return false;
1294     }
1295
1296   i_shdrp[0] = ((Elf_Internal_Shdr *)
1297                 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1298   if (i_shdrp[0] == NULL)
1299     {
1300       bfd_release (abfd, i_shdrp);
1301       bfd_set_error (bfd_error_no_memory);
1302       return false;
1303     }
1304   memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1305
1306   elf_elfsections (abfd) = i_shdrp;
1307
1308   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1309   if (abfd->symcount > 0)
1310     {
1311       i_shdrp[t->symtab_section] = &t->symtab_hdr;
1312       i_shdrp[t->strtab_section] = &t->strtab_hdr;
1313       t->symtab_hdr.sh_link = t->strtab_section;
1314     }
1315   for (sec = abfd->sections; sec; sec = sec->next)
1316     {
1317       struct bfd_elf_section_data *d = elf_section_data (sec);
1318       asection *s;
1319       const char *name;
1320
1321       i_shdrp[d->this_idx] = &d->this_hdr;
1322       if (d->rel_idx != 0)
1323         i_shdrp[d->rel_idx] = &d->rel_hdr;
1324
1325       /* Fill in the sh_link and sh_info fields while we're at it.  */
1326
1327       /* sh_link of a reloc section is the section index of the symbol
1328          table.  sh_info is the section index of the section to which
1329          the relocation entries apply.  */
1330       if (d->rel_idx != 0)
1331         {
1332           d->rel_hdr.sh_link = t->symtab_section;
1333           d->rel_hdr.sh_info = d->this_idx;
1334         }
1335
1336       switch (d->this_hdr.sh_type)
1337         {
1338         case SHT_REL:
1339         case SHT_RELA:
1340           /* A reloc section which we are treating as a normal BFD
1341              section.  sh_link is the section index of the symbol
1342              table.  sh_info is the section index of the section to
1343              which the relocation entries apply.  We assume that an
1344              allocated reloc section uses the dynamic symbol table.
1345              FIXME: How can we be sure?  */
1346           s = bfd_get_section_by_name (abfd, ".dynsym");
1347           if (s != NULL)
1348             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1349
1350           /* We look up the section the relocs apply to by name.  */
1351           name = sec->name;
1352           if (d->this_hdr.sh_type == SHT_REL)
1353             name += 4;
1354           else
1355             name += 5;
1356           s = bfd_get_section_by_name (abfd, name);
1357           if (s != NULL)
1358             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1359           break;
1360
1361         case SHT_STRTAB:
1362           /* We assume that a section named .stab*str is a stabs
1363              string section.  We look for a section with the same name
1364              but without the trailing ``str'', and set its sh_link
1365              field to point to this section.  */
1366           if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1367               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1368             {
1369               size_t len;
1370               char *alc;
1371
1372               len = strlen (sec->name);
1373               alc = (char *) malloc (len - 2);
1374               if (alc == NULL)
1375                 {
1376                   bfd_set_error (bfd_error_no_memory);
1377                   return false;
1378                 }
1379               strncpy (alc, sec->name, len - 3);
1380               alc[len - 3] = '\0';
1381               s = bfd_get_section_by_name (abfd, alc);
1382               free (alc);
1383               if (s != NULL)
1384                 {
1385                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
1386
1387                   /* This is a .stab section.  */
1388                   elf_section_data (s)->this_hdr.sh_entsize =
1389                     4 + 2 * (ARCH_SIZE / 8);
1390                 }
1391             }
1392           break;
1393
1394         case SHT_DYNAMIC:
1395         case SHT_DYNSYM:
1396           /* sh_link is the section header index of the string table
1397              used for the dynamic entries or symbol table.  */
1398           s = bfd_get_section_by_name (abfd, ".dynstr");
1399           if (s != NULL)
1400             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1401           break;
1402
1403         case SHT_HASH:
1404           /* sh_link is the section header index of the symbol table
1405              this hash table is for.  */
1406           s = bfd_get_section_by_name (abfd, ".dynsym");
1407           if (s != NULL)
1408             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1409           break;
1410         }
1411     }
1412
1413   return true;
1414 }
1415
1416 /* Map symbol from it's internal number to the external number, moving
1417    all local symbols to be at the head of the list.  */
1418
1419 static INLINE int
1420 sym_is_global (abfd, sym)
1421      bfd *abfd;
1422      asymbol *sym;
1423 {
1424   /* If the backend has a special mapping, use it.  */
1425   if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1426     return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1427             (abfd, sym));
1428
1429   if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
1430     {
1431       if (sym->flags & BSF_LOCAL)
1432         abort ();
1433       return 1;
1434     }
1435   if (sym->section == 0)
1436     {
1437       /* Is this valid?  */
1438       abort ();
1439
1440       return 1;
1441     }
1442   if (bfd_is_und_section (sym->section))
1443     return 1;
1444   if (bfd_is_com_section (sym->section))
1445     return 1;
1446   if (sym->flags & (BSF_LOCAL | BSF_SECTION_SYM | BSF_FILE))
1447     return 0;
1448   return 0;
1449 }
1450
1451 static boolean
1452 elf_map_symbols (abfd)
1453      bfd *abfd;
1454 {
1455   int symcount = bfd_get_symcount (abfd);
1456   asymbol **syms = bfd_get_outsymbols (abfd);
1457   asymbol **sect_syms;
1458   int num_locals = 0;
1459   int num_globals = 0;
1460   int num_locals2 = 0;
1461   int num_globals2 = 0;
1462   int max_index = 0;
1463   int num_sections = 0;
1464   int idx;
1465   asection *asect;
1466   asymbol **new_syms;
1467
1468 #ifdef DEBUG
1469   fprintf (stderr, "elf_map_symbols\n");
1470   fflush (stderr);
1471 #endif
1472
1473   /* Add a section symbol for each BFD section.  FIXME: Is this really
1474      necessary?  */
1475   for (asect = abfd->sections; asect; asect = asect->next)
1476     {
1477       if (max_index < asect->index)
1478         max_index = asect->index;
1479     }
1480
1481   max_index++;
1482   sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
1483   if (sect_syms == NULL)
1484     {
1485       bfd_set_error (bfd_error_no_memory);
1486       return false;
1487     }
1488   elf_section_syms (abfd) = sect_syms;
1489
1490   for (idx = 0; idx < symcount; idx++)
1491     {
1492       if ((syms[idx]->flags & BSF_SECTION_SYM) != 0)
1493         {
1494           asection *sec;
1495
1496           sec = syms[idx]->section;
1497           if (sec->owner != NULL)
1498             {
1499               if (sec->owner != abfd)
1500                 {
1501                   sec = sec->output_section;
1502                   BFD_ASSERT (sec->owner == abfd);
1503                 }
1504               sect_syms[sec->index] = syms[idx];
1505             }
1506         }
1507     }
1508
1509   for (asect = abfd->sections; asect; asect = asect->next)
1510     {
1511       asymbol *sym;
1512
1513       if (sect_syms[asect->index] != NULL)
1514         continue;
1515
1516       sym = bfd_make_empty_symbol (abfd);
1517       if (sym == NULL)
1518         return false;
1519       sym->the_bfd = abfd;
1520       sym->name = asect->name;
1521       sym->value = asect->vma;
1522       /* Set the flags to 0 to indicate that this one was newly added.  */
1523       sym->flags = 0;
1524       sym->section = asect;
1525       sect_syms[asect->index] = sym;
1526       num_sections++;
1527 #ifdef DEBUG
1528       fprintf (stderr,
1529                "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1530                asect->name, (long) asect->vma, asect->index, (long) asect);
1531 #endif
1532     }
1533
1534   /* Classify all of the symbols.  */
1535   for (idx = 0; idx < symcount; idx++)
1536     {
1537       if (!sym_is_global (abfd, syms[idx]))
1538         num_locals++;
1539       else
1540         num_globals++;
1541     }
1542   for (asect = abfd->sections; asect; asect = asect->next)
1543     {
1544       if (sect_syms[asect->index] != NULL
1545           && sect_syms[asect->index]->flags == 0)
1546         {
1547           sect_syms[asect->index]->flags = BSF_SECTION_SYM;
1548           if (!sym_is_global (abfd, sect_syms[asect->index]))
1549             num_locals++;
1550           else
1551             num_globals++;
1552           sect_syms[asect->index]->flags = 0;
1553         }
1554     }
1555
1556   /* Now sort the symbols so the local symbols are first.  */
1557   new_syms = ((asymbol **)
1558               bfd_alloc (abfd,
1559                          (num_locals + num_globals) * sizeof (asymbol *)));
1560   if (new_syms == NULL)
1561     {
1562       bfd_set_error (bfd_error_no_memory);
1563       return false;
1564     }
1565
1566   for (idx = 0; idx < symcount; idx++)
1567     {
1568       asymbol *sym = syms[idx];
1569       int i;
1570
1571       if (!sym_is_global (abfd, sym))
1572         i = num_locals2++;
1573       else
1574         i = num_locals + num_globals2++;
1575       new_syms[i] = sym;
1576       sym->udata.i = i + 1;
1577     }
1578   for (asect = abfd->sections; asect; asect = asect->next)
1579     {
1580       if (sect_syms[asect->index] != NULL
1581           && sect_syms[asect->index]->flags == 0)
1582         {
1583           asymbol *sym = sect_syms[asect->index];
1584           int i;
1585
1586           sym->flags = BSF_SECTION_SYM;
1587           if (!sym_is_global (abfd, sym))
1588             i = num_locals2++;
1589           else
1590             i = num_locals + num_globals2++;
1591           new_syms[i] = sym;
1592           sym->udata.i = i + 1;
1593         }
1594     }
1595
1596   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
1597
1598   elf_num_locals (abfd) = num_locals;
1599   elf_num_globals (abfd) = num_globals;
1600   return true;
1601 }
1602
1603 /* Compute the file positions we are going to put the sections at, and
1604    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
1605    is not NULL, this is being called by the ELF backend linker.  */
1606
1607 static boolean
1608 elf_compute_section_file_positions (abfd, link_info)
1609      bfd *abfd;
1610      struct bfd_link_info *link_info;
1611 {
1612   struct elf_backend_data *bed = get_elf_backend_data (abfd);
1613   boolean failed;
1614   struct bfd_strtab_hash *strtab;
1615   Elf_Internal_Shdr *shstrtab_hdr;
1616
1617   if (abfd->output_has_begun)
1618     return true;
1619
1620   /* Do any elf backend specific processing first.  */
1621   if (bed->elf_backend_begin_write_processing)
1622     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
1623
1624   if (! prep_headers (abfd))
1625     return false;
1626
1627   failed = false;
1628   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
1629   if (failed)
1630     return false;
1631
1632   if (!assign_section_numbers (abfd))
1633     return false;
1634
1635   /* The backend linker builds symbol table information itself.  */
1636   if (link_info == NULL)
1637     {
1638       if (! swap_out_syms (abfd, &strtab))
1639         return false;
1640     }
1641
1642   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
1643   /* sh_name was set in prep_headers.  */
1644   shstrtab_hdr->sh_type = SHT_STRTAB;
1645   shstrtab_hdr->sh_flags = 0;
1646   shstrtab_hdr->sh_addr = 0;
1647   shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1648   shstrtab_hdr->sh_entsize = 0;
1649   shstrtab_hdr->sh_link = 0;
1650   shstrtab_hdr->sh_info = 0;
1651   /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs.  */
1652   shstrtab_hdr->sh_addralign = 1;
1653
1654   if (!assign_file_positions_except_relocs (abfd,
1655                                             link_info == NULL ? true : false))
1656     return false;
1657
1658   if (link_info == NULL)
1659     {
1660       /* Now that we know where the .strtab section goes, write it
1661          out.  */
1662       if ((bfd_seek (abfd, elf_tdata (abfd)->strtab_hdr.sh_offset, SEEK_SET)
1663            != 0)
1664           || ! _bfd_stringtab_emit (abfd, strtab))
1665         return false;
1666       _bfd_stringtab_free (strtab);
1667     }
1668
1669   abfd->output_has_begun = true;
1670
1671   return true;
1672 }
1673
1674
1675 /* Align to the maximum file alignment that could be required for any
1676    ELF data structure.  */
1677
1678 static INLINE file_ptr
1679 align_file_position (off)
1680      file_ptr off;
1681 {
1682   return (off + FILE_ALIGN - 1) & ~(FILE_ALIGN - 1);
1683 }
1684
1685 /* Assign a file position to a section, optionally aligning to the
1686    required section alignment.  */
1687
1688 static INLINE file_ptr
1689 assign_file_position_for_section (i_shdrp, offset, align)
1690      Elf_Internal_Shdr *i_shdrp;
1691      file_ptr offset;
1692      boolean align;
1693 {
1694   if (align)
1695     {
1696       unsigned int al;
1697
1698       al = i_shdrp->sh_addralign;
1699       if (al > 1)
1700         offset = BFD_ALIGN (offset, al);
1701     }
1702   i_shdrp->sh_offset = offset;
1703   if (i_shdrp->bfd_section != NULL)
1704     i_shdrp->bfd_section->filepos = offset;
1705   if (i_shdrp->sh_type != SHT_NOBITS)
1706     offset += i_shdrp->sh_size;
1707   return offset;
1708 }
1709
1710 /* Get the size of the program header.  This is called by the linker
1711    before any of the section VMA's are set, so it can't calculate the
1712    correct value for a strange memory layout.  */
1713
1714 static bfd_size_type
1715 get_program_header_size (abfd)
1716      bfd *abfd;
1717 {
1718   size_t segs;
1719   asection *s;
1720
1721   /* Assume we will need exactly two PT_LOAD segments: one for text
1722      and one for data.  */
1723   segs = 2;
1724
1725   s = bfd_get_section_by_name (abfd, ".interp");
1726   if (s != NULL && (s->flags & SEC_LOAD) != 0)
1727     {
1728       /* If we have a loadable interpreter section, we need a
1729          PT_INTERP segment.  In this case, assume we also need a
1730          PT_PHDR segment, although that may not be true for all
1731          targets.  */
1732       segs += 2;
1733     }
1734
1735   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
1736     {
1737       /* We need a PT_DYNAMIC segment.  */
1738       ++segs;
1739     }
1740
1741   return segs * sizeof (Elf_External_Phdr);
1742 }
1743
1744 /* Create the program header.  OFF is the file offset where the
1745    program header should be written.  FIRST is the first loadable ELF
1746    section.  PHDR_SIZE is the size of the program header as returned
1747    by get_program_header_size.  */
1748
1749 static file_ptr
1750 map_program_segments (abfd, off, first, phdr_size)
1751      bfd *abfd;
1752      file_ptr off;
1753      Elf_Internal_Shdr *first;
1754      bfd_size_type phdr_size;
1755 {
1756   Elf_Internal_Phdr phdrs[10];
1757   unsigned int phdr_count;
1758   Elf_Internal_Phdr *phdr;
1759   int phdr_size_adjust;
1760   unsigned int i;
1761   Elf_Internal_Shdr **hdrpp;
1762   asection *sinterp, *sdyn;
1763   unsigned int last_type;
1764   Elf_Internal_Ehdr *i_ehdrp;
1765
1766   BFD_ASSERT ((abfd->flags & (EXEC_P | DYNAMIC)) != 0);
1767   BFD_ASSERT (phdr_size / sizeof (Elf_Internal_Phdr)
1768               <= sizeof phdrs / sizeof (phdrs[0]));
1769
1770   phdr_count = 0;
1771   phdr = phdrs;
1772
1773   phdr_size_adjust = 0;
1774
1775   /* If we have a loadable .interp section, we must create a PT_INTERP
1776      segment which must precede all PT_LOAD segments.  We assume that
1777      we must also create a PT_PHDR segment, although that may not be
1778      true for all targets.  */
1779   sinterp = bfd_get_section_by_name (abfd, ".interp");
1780   if (sinterp != NULL && (sinterp->flags & SEC_LOAD) != 0)
1781     {
1782       BFD_ASSERT (first != NULL);
1783
1784       phdr->p_type = PT_PHDR;
1785
1786       phdr->p_offset = off;
1787
1788       /* Account for any adjustment made because of the alignment of
1789          the first loadable section.  */
1790       phdr_size_adjust = (first->sh_offset - phdr_size) - off;
1791       BFD_ASSERT (phdr_size_adjust >= 0 && phdr_size_adjust < 128);
1792
1793       /* The program header precedes all loadable sections.  This lets
1794          us compute its loadable address.  This depends on the linker
1795          script.  */
1796       phdr->p_vaddr = first->sh_addr - (phdr_size + phdr_size_adjust);
1797
1798       phdr->p_paddr = 0;
1799       phdr->p_filesz = phdr_size;
1800       phdr->p_memsz = phdr_size;
1801
1802       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
1803       phdr->p_flags = PF_R | PF_X;
1804
1805       phdr->p_align = FILE_ALIGN;
1806       BFD_ASSERT ((phdr->p_vaddr - phdr->p_offset) % FILE_ALIGN == 0);
1807
1808       /* Include the ELF header in the first loadable segment.  */
1809       phdr_size_adjust += off;
1810
1811       ++phdr_count;
1812       ++phdr;
1813
1814       phdr->p_type = PT_INTERP;
1815       phdr->p_offset = sinterp->filepos;
1816       phdr->p_vaddr = sinterp->vma;
1817       phdr->p_paddr = 0;
1818       phdr->p_filesz = sinterp->_raw_size;
1819       phdr->p_memsz = sinterp->_raw_size;
1820       phdr->p_flags = PF_R;
1821       phdr->p_align = 1 << bfd_get_section_alignment (abfd, sinterp);
1822
1823       ++phdr_count;
1824       ++phdr;
1825     }
1826
1827   /* Look through the sections to see how they will be divided into
1828      program segments.  The sections must be arranged in order by
1829      sh_addr for this to work correctly.  */
1830   phdr->p_type = PT_NULL;
1831   last_type = SHT_PROGBITS;
1832   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
1833        i < elf_elfheader (abfd)->e_shnum;
1834        i++, hdrpp++)
1835     {
1836       Elf_Internal_Shdr *hdr;
1837
1838       hdr = *hdrpp;
1839
1840       /* Ignore any section which will not be part of the process
1841          image.  */
1842       if ((hdr->sh_flags & SHF_ALLOC) == 0)
1843         continue;
1844
1845       /* If this section fits in the segment we are constructing, add
1846          it in.  */
1847       if (phdr->p_type != PT_NULL
1848           && (hdr->sh_offset - (phdr->p_offset + phdr->p_memsz)
1849               == hdr->sh_addr - (phdr->p_vaddr + phdr->p_memsz))
1850           && (last_type != SHT_NOBITS || hdr->sh_type == SHT_NOBITS))
1851         {
1852           bfd_size_type adjust;
1853
1854           adjust = hdr->sh_addr - (phdr->p_vaddr + phdr->p_memsz);
1855           phdr->p_memsz += hdr->sh_size + adjust;
1856           if (hdr->sh_type != SHT_NOBITS)
1857             phdr->p_filesz += hdr->sh_size + adjust;
1858           if ((hdr->sh_flags & SHF_WRITE) != 0)
1859             phdr->p_flags |= PF_W;
1860           if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
1861             phdr->p_flags |= PF_X;
1862           last_type = hdr->sh_type;
1863           continue;
1864         }
1865
1866       /* If we have a segment, move to the next one.  */
1867       if (phdr->p_type != PT_NULL)
1868         {
1869           ++phdr;
1870           ++phdr_count;
1871         }
1872
1873       /* Start a new segment.  */
1874       phdr->p_type = PT_LOAD;
1875       phdr->p_offset = hdr->sh_offset;
1876       phdr->p_vaddr = hdr->sh_addr;
1877       phdr->p_paddr = 0;
1878       if (hdr->sh_type == SHT_NOBITS)
1879         phdr->p_filesz = 0;
1880       else
1881         phdr->p_filesz = hdr->sh_size;
1882       phdr->p_memsz = hdr->sh_size;
1883       phdr->p_flags = PF_R;
1884       if ((hdr->sh_flags & SHF_WRITE) != 0)
1885         phdr->p_flags |= PF_W;
1886       if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
1887         phdr->p_flags |= PF_X;
1888       phdr->p_align = get_elf_backend_data (abfd)->maxpagesize;
1889
1890       if (hdr == first
1891           && sinterp != NULL
1892           && (sinterp->flags & SEC_LOAD) != 0)
1893         {
1894           phdr->p_offset -= phdr_size + phdr_size_adjust;
1895           phdr->p_vaddr -= phdr_size + phdr_size_adjust;
1896           phdr->p_filesz += phdr_size + phdr_size_adjust;
1897           phdr->p_memsz += phdr_size + phdr_size_adjust;
1898         }
1899
1900       last_type = hdr->sh_type;
1901     }
1902
1903   if (phdr->p_type != PT_NULL)
1904     {
1905       ++phdr;
1906       ++phdr_count;
1907     }
1908
1909   /* If we have a .dynamic section, create a PT_DYNAMIC segment.  */
1910   sdyn = bfd_get_section_by_name (abfd, ".dynamic");
1911   if (sdyn != NULL && (sdyn->flags & SEC_LOAD) != 0)
1912     {
1913       phdr->p_type = PT_DYNAMIC;
1914       phdr->p_offset = sdyn->filepos;
1915       phdr->p_vaddr = sdyn->vma;
1916       phdr->p_paddr = 0;
1917       phdr->p_filesz = sdyn->_raw_size;
1918       phdr->p_memsz = sdyn->_raw_size;
1919       phdr->p_flags = PF_R;
1920       if ((sdyn->flags & SEC_READONLY) == 0)
1921         phdr->p_flags |= PF_W;
1922       if ((sdyn->flags & SEC_CODE) != 0)
1923         phdr->p_flags |= PF_X;
1924       phdr->p_align = 1 << bfd_get_section_alignment (abfd, sdyn);
1925
1926       ++phdr;
1927       ++phdr_count;
1928     }
1929
1930   /* Make sure the return value from get_program_header_size matches
1931      what we computed here.  Actually, it's OK if we allocated too
1932      much space in the program header.  */
1933   if (phdr_count > phdr_size / sizeof (Elf_External_Phdr))
1934     abort ();
1935
1936   /* Set up program header information.  */
1937   i_ehdrp = elf_elfheader (abfd);
1938   i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
1939   i_ehdrp->e_phoff = off;
1940   i_ehdrp->e_phnum = phdr_count;
1941
1942   /* Save the program headers away.  I don't think anybody uses this
1943      information right now.  */
1944   elf_tdata (abfd)->phdr = ((Elf_Internal_Phdr *)
1945                             bfd_alloc (abfd,
1946                                        (phdr_count
1947                                         * sizeof (Elf_Internal_Phdr))));
1948   if (elf_tdata (abfd)->phdr == NULL && phdr_count != 0)
1949     {
1950       bfd_set_error (bfd_error_no_memory);
1951       return (file_ptr) -1;
1952     }
1953   memcpy (elf_tdata (abfd)->phdr, phdrs,
1954           phdr_count * sizeof (Elf_Internal_Phdr));
1955
1956   /* Write out the program headers.  */
1957   if (bfd_seek (abfd, off, SEEK_SET) != 0)
1958     return (file_ptr) -1;
1959
1960   for (i = 0, phdr = phdrs; i < phdr_count; i++, phdr++)
1961     {
1962       Elf_External_Phdr extphdr;
1963
1964       elf_swap_phdr_out (abfd, phdr, &extphdr);
1965       if (bfd_write (&extphdr, sizeof (Elf_External_Phdr), 1, abfd)
1966           != sizeof (Elf_External_Phdr))
1967         return (file_ptr) -1;
1968     }
1969
1970   return off + phdr_count * sizeof (Elf_External_Phdr);
1971 }
1972
1973 /* Work out the file positions of all the sections.  This is called by
1974    elf_compute_section_file_positions.  All the section sizes and VMAs
1975    must be known before this is called.
1976
1977    We do not consider reloc sections at this point, unless they form
1978    part of the loadable image.  Reloc sections are assigned file
1979    positions in assign_file_positions_for_relocs, which is called by
1980    write_object_contents and final_link.
1981
1982    If DOSYMS is false, we do not assign file positions for the symbol
1983    table or the string table.  */
1984
1985 static boolean
1986 assign_file_positions_except_relocs (abfd, dosyms)
1987      bfd *abfd;
1988      boolean dosyms;
1989 {
1990   struct elf_obj_tdata * const tdata = elf_tdata (abfd);
1991   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
1992   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
1993   file_ptr off;
1994
1995   /* Start after the ELF header.  */
1996   off = i_ehdrp->e_ehsize;
1997
1998   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
1999     {
2000       Elf_Internal_Shdr **hdrpp;
2001       unsigned int i;
2002
2003       /* We are not creating an executable, which means that we are
2004          not creating a program header, and that the actual order of
2005          the sections in the file is unimportant.  */
2006       for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
2007         {
2008           Elf_Internal_Shdr *hdr;
2009
2010           hdr = *hdrpp;
2011           if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
2012             {
2013               hdr->sh_offset = -1;
2014               continue;
2015             }
2016           if (! dosyms
2017               && (i == tdata->symtab_section
2018                   || i == tdata->strtab_section))
2019             {
2020               hdr->sh_offset = -1;
2021               continue;
2022             }
2023
2024           off = assign_file_position_for_section (hdr, off, true);
2025         }
2026     }
2027   else
2028     {
2029       file_ptr phdr_off;
2030       bfd_size_type phdr_size;
2031       bfd_vma maxpagesize;
2032       size_t hdrppsize;
2033       Elf_Internal_Shdr **sorted_hdrs;
2034       Elf_Internal_Shdr **hdrpp;
2035       unsigned int i;
2036       Elf_Internal_Shdr *first;
2037       file_ptr phdr_map;
2038
2039       /* We are creating an executable.  We must create a program
2040          header.  We can't actually create the program header until we
2041          have set the file positions for the sections, but we can
2042          figure out how big it is going to be.  */
2043       off = align_file_position (off);
2044       phdr_size = get_program_header_size (abfd);
2045       if (phdr_size == (file_ptr) -1)
2046         return false;
2047       phdr_off = off;
2048       off += phdr_size;
2049
2050       maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2051       if (maxpagesize == 0)
2052         maxpagesize = 1;
2053
2054       /* We must sort the sections.  The GNU linker will always create
2055          the sections in an appropriate order, but the Irix 5 linker
2056          will not.  We don't include the dummy first section in the
2057          sort.  We sort sections which are not SHF_ALLOC to the end.  */
2058       hdrppsize = (i_ehdrp->e_shnum - 1) * sizeof (Elf_Internal_Shdr *);
2059       sorted_hdrs = (Elf_Internal_Shdr **) malloc (hdrppsize);
2060       if (sorted_hdrs == NULL)
2061         {
2062           bfd_set_error (bfd_error_no_memory);
2063           return false;
2064         }
2065
2066       memcpy (sorted_hdrs, i_shdrpp + 1, hdrppsize);
2067       qsort (sorted_hdrs, i_ehdrp->e_shnum - 1, sizeof (Elf_Internal_Shdr *),
2068              elf_sort_hdrs);
2069
2070       first = NULL;
2071       for (i = 1, hdrpp = sorted_hdrs; i < i_ehdrp->e_shnum; i++, hdrpp++)
2072         {
2073           Elf_Internal_Shdr *hdr;
2074
2075           hdr = *hdrpp;
2076           if ((hdr->sh_flags & SHF_ALLOC) == 0)
2077             {
2078               if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
2079                 {
2080                   hdr->sh_offset = -1;
2081                   continue;
2082                 }
2083               if (! dosyms
2084                   && (hdr == i_shdrpp[tdata->symtab_section]
2085                       || hdr == i_shdrpp[tdata->strtab_section]))
2086                 {
2087                   hdr->sh_offset = -1;
2088                   continue;
2089                 }
2090             }
2091           else
2092             {
2093               if (first == NULL)
2094                 first = hdr;
2095
2096               /* The section VMA must equal the file position modulo
2097                  the page size.  This is required by the program
2098                  header.  */
2099               off += (hdr->sh_addr - off) % maxpagesize;
2100             }
2101
2102           off = assign_file_position_for_section (hdr, off, false);
2103         }
2104
2105       phdr_map = map_program_segments (abfd, phdr_off, first, phdr_size);
2106       if (phdr_map == (file_ptr) -1)
2107         return false;
2108       BFD_ASSERT (phdr_map <= phdr_off + phdr_size);
2109     }
2110
2111   /* Place the section headers.  */
2112   off = align_file_position (off);
2113   i_ehdrp->e_shoff = off;
2114   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
2115
2116   elf_tdata (abfd)->next_file_pos = off;
2117
2118   return true;
2119 }
2120
2121 /* Sort the ELF headers by VMA.  We sort headers which are not
2122    SHF_ALLOC to the end.  */
2123
2124 static int
2125 elf_sort_hdrs (arg1, arg2)
2126      const PTR arg1;
2127      const PTR arg2;
2128 {
2129   const Elf_Internal_Shdr *hdr1 = *(const Elf_Internal_Shdr **) arg1;
2130   const Elf_Internal_Shdr *hdr2 = *(const Elf_Internal_Shdr **) arg2;
2131
2132   if ((hdr1->sh_flags & SHF_ALLOC) != 0)
2133     {
2134       if ((hdr2->sh_flags & SHF_ALLOC) == 0)
2135         return -1;
2136       if (hdr1->sh_addr < hdr2->sh_addr)
2137         return -1;
2138       else if (hdr1->sh_addr > hdr2->sh_addr)
2139         return 1;
2140       else
2141         return 0;
2142     }
2143   else
2144     {
2145       if ((hdr1->sh_flags & SHF_ALLOC) != 0)
2146         return 1;
2147       return 0;
2148     }
2149 }
2150
2151 static boolean
2152 prep_headers (abfd)
2153      bfd *abfd;
2154 {
2155   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
2156   Elf_Internal_Phdr *i_phdrp = 0;       /* Program header table, internal form */
2157   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
2158   int count;
2159   struct bfd_strtab_hash *shstrtab;
2160
2161   i_ehdrp = elf_elfheader (abfd);
2162   i_shdrp = elf_elfsections (abfd);
2163
2164   shstrtab = elf_stringtab_init ();
2165   if (shstrtab == NULL)
2166     return false;
2167
2168   elf_shstrtab (abfd) = shstrtab;
2169
2170   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
2171   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
2172   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
2173   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
2174
2175   i_ehdrp->e_ident[EI_CLASS] = ELFCLASS;
2176   i_ehdrp->e_ident[EI_DATA] =
2177     abfd->xvec->byteorder_big_p ? ELFDATA2MSB : ELFDATA2LSB;
2178   i_ehdrp->e_ident[EI_VERSION] = EV_CURRENT;
2179
2180   for (count = EI_PAD; count < EI_NIDENT; count++)
2181     i_ehdrp->e_ident[count] = 0;
2182
2183   if ((abfd->flags & DYNAMIC) != 0)
2184     i_ehdrp->e_type = ET_DYN;
2185   else if ((abfd->flags & EXEC_P) != 0)
2186     i_ehdrp->e_type = ET_EXEC;
2187   else
2188     i_ehdrp->e_type = ET_REL;
2189
2190   switch (bfd_get_arch (abfd))
2191     {
2192     case bfd_arch_unknown:
2193       i_ehdrp->e_machine = EM_NONE;
2194       break;
2195     case bfd_arch_sparc:
2196 #if ARCH_SIZE == 64
2197       i_ehdrp->e_machine = EM_SPARC64;
2198 #else
2199       i_ehdrp->e_machine = EM_SPARC;
2200 #endif
2201       break;
2202     case bfd_arch_i386:
2203       i_ehdrp->e_machine = EM_386;
2204       break;
2205     case bfd_arch_m68k:
2206       i_ehdrp->e_machine = EM_68K;
2207       break;
2208     case bfd_arch_m88k:
2209       i_ehdrp->e_machine = EM_88K;
2210       break;
2211     case bfd_arch_i860:
2212       i_ehdrp->e_machine = EM_860;
2213       break;
2214     case bfd_arch_mips: /* MIPS Rxxxx */
2215       i_ehdrp->e_machine = EM_MIPS;     /* only MIPS R3000 */
2216       break;
2217     case bfd_arch_hppa:
2218       i_ehdrp->e_machine = EM_PARISC;
2219       break;
2220     case bfd_arch_powerpc:
2221       i_ehdrp->e_machine = EM_CYGNUS_POWERPC;
2222       break;
2223       /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2224     default:
2225       i_ehdrp->e_machine = EM_NONE;
2226     }
2227   i_ehdrp->e_version = EV_CURRENT;
2228   i_ehdrp->e_ehsize = sizeof (Elf_External_Ehdr);
2229
2230   /* no program header, for now. */
2231   i_ehdrp->e_phoff = 0;
2232   i_ehdrp->e_phentsize = 0;
2233   i_ehdrp->e_phnum = 0;
2234
2235   /* each bfd section is section header entry */
2236   i_ehdrp->e_entry = bfd_get_start_address (abfd);
2237   i_ehdrp->e_shentsize = sizeof (Elf_External_Shdr);
2238
2239   /* if we're building an executable, we'll need a program header table */
2240   if (abfd->flags & EXEC_P)
2241     {
2242       /* it all happens later */
2243 #if 0
2244       i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
2245
2246       /* elf_build_phdrs() returns a (NULL-terminated) array of
2247          Elf_Internal_Phdrs */
2248       i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
2249       i_ehdrp->e_phoff = outbase;
2250       outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
2251 #endif
2252     }
2253   else
2254     {
2255       i_ehdrp->e_phentsize = 0;
2256       i_phdrp = 0;
2257       i_ehdrp->e_phoff = 0;
2258     }
2259
2260   elf_tdata (abfd)->symtab_hdr.sh_name =
2261     (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
2262   elf_tdata (abfd)->strtab_hdr.sh_name =
2263     (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
2264   elf_tdata (abfd)->shstrtab_hdr.sh_name =
2265     (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
2266   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
2267       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
2268       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
2269     return false;
2270
2271   return true;
2272 }
2273
2274 static boolean
2275 swap_out_syms (abfd, sttp)
2276      bfd *abfd;
2277      struct bfd_strtab_hash **sttp;
2278 {
2279   if (!elf_map_symbols (abfd))
2280     return false;
2281
2282   /* Dump out the symtabs. */
2283   {
2284     int symcount = bfd_get_symcount (abfd);
2285     asymbol **syms = bfd_get_outsymbols (abfd);
2286     struct bfd_strtab_hash *stt;
2287     Elf_Internal_Shdr *symtab_hdr;
2288     Elf_Internal_Shdr *symstrtab_hdr;
2289     Elf_External_Sym *outbound_syms;
2290     int idx;
2291
2292     stt = elf_stringtab_init ();
2293     if (stt == NULL)
2294       return false;
2295
2296     symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2297     symtab_hdr->sh_type = SHT_SYMTAB;
2298     symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
2299     symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
2300     symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
2301     symtab_hdr->sh_addralign = FILE_ALIGN;
2302
2303     symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2304     symstrtab_hdr->sh_type = SHT_STRTAB;
2305
2306     outbound_syms = ((Elf_External_Sym *)
2307                      bfd_alloc (abfd,
2308                                 (1 + symcount) * sizeof (Elf_External_Sym)));
2309     if (outbound_syms == NULL)
2310       {
2311         bfd_set_error (bfd_error_no_memory);
2312         return false;
2313       }
2314     symtab_hdr->contents = (PTR) outbound_syms;
2315
2316     /* now generate the data (for "contents") */
2317     {
2318       /* Fill in zeroth symbol and swap it out.  */
2319       Elf_Internal_Sym sym;
2320       sym.st_name = 0;
2321       sym.st_value = 0;
2322       sym.st_size = 0;
2323       sym.st_info = 0;
2324       sym.st_other = 0;
2325       sym.st_shndx = SHN_UNDEF;
2326       elf_swap_symbol_out (abfd, &sym, outbound_syms);
2327       ++outbound_syms;
2328     }
2329     for (idx = 0; idx < symcount; idx++)
2330       {
2331         Elf_Internal_Sym sym;
2332         bfd_vma value = syms[idx]->value;
2333         elf_symbol_type *type_ptr;
2334
2335         if (syms[idx]->flags & BSF_SECTION_SYM)
2336           /* Section symbols have no names.  */
2337           sym.st_name = 0;
2338         else
2339           {
2340             sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
2341                                                               syms[idx]->name,
2342                                                               true, false);
2343             if (sym.st_name == (unsigned long) -1)
2344               return false;
2345           }
2346
2347         type_ptr = elf_symbol_from (abfd, syms[idx]);
2348
2349         if (bfd_is_com_section (syms[idx]->section))
2350           {
2351             /* ELF common symbols put the alignment into the `value' field,
2352                and the size into the `size' field.  This is backwards from
2353                how BFD handles it, so reverse it here.  */
2354             sym.st_size = value;
2355             if (type_ptr == NULL
2356                 || type_ptr->internal_elf_sym.st_value == 0)
2357               sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
2358             else
2359               sym.st_value = type_ptr->internal_elf_sym.st_value;
2360             sym.st_shndx = elf_section_from_bfd_section (abfd,
2361                                                          syms[idx]->section);
2362           }
2363         else
2364           {
2365             asection *sec = syms[idx]->section;
2366             int shndx;
2367
2368             if (sec->output_section)
2369               {
2370                 value += sec->output_offset;
2371                 sec = sec->output_section;
2372               }
2373             value += sec->vma;
2374             sym.st_value = value;
2375             sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
2376             sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec);
2377             if (shndx == -1)
2378               {
2379                 asection *sec2;
2380                 /* Writing this would be a hell of a lot easier if we had
2381                    some decent documentation on bfd, and knew what to expect
2382                    of the library, and what to demand of applications.  For
2383                    example, it appears that `objcopy' might not set the
2384                    section of a symbol to be a section that is actually in
2385                    the output file.  */
2386                 sec2 = bfd_get_section_by_name (abfd, sec->name);
2387                 BFD_ASSERT (sec2 != 0);
2388                 sym.st_shndx = shndx = elf_section_from_bfd_section (abfd, sec2);
2389                 BFD_ASSERT (shndx != -1);
2390               }
2391           }
2392
2393         if (bfd_is_com_section (syms[idx]->section))
2394           sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_OBJECT);
2395         else if (bfd_is_und_section (syms[idx]->section))
2396           sym.st_info = ELF_ST_INFO (STB_GLOBAL,
2397                                      ((syms[idx]->flags & BSF_FUNCTION)
2398                                       ? STT_FUNC
2399                                       : STT_NOTYPE));
2400         else if (syms[idx]->flags & BSF_SECTION_SYM)
2401           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
2402         else if (syms[idx]->flags & BSF_FILE)
2403           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
2404         else
2405           {
2406             int bind = STB_LOCAL;
2407             int type = STT_OBJECT;
2408             unsigned int flags = syms[idx]->flags;
2409
2410             if (flags & BSF_LOCAL)
2411               bind = STB_LOCAL;
2412             else if (flags & BSF_WEAK)
2413               bind = STB_WEAK;
2414             else if (flags & BSF_GLOBAL)
2415               bind = STB_GLOBAL;
2416
2417             if (flags & BSF_FUNCTION)
2418               type = STT_FUNC;
2419
2420             sym.st_info = ELF_ST_INFO (bind, type);
2421           }
2422
2423         sym.st_other = 0;
2424         elf_swap_symbol_out (abfd, &sym, outbound_syms);
2425         ++outbound_syms;
2426       }
2427
2428     *sttp = stt;
2429     symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
2430     symstrtab_hdr->sh_type = SHT_STRTAB;
2431
2432     symstrtab_hdr->sh_flags = 0;
2433     symstrtab_hdr->sh_addr = 0;
2434     symstrtab_hdr->sh_entsize = 0;
2435     symstrtab_hdr->sh_link = 0;
2436     symstrtab_hdr->sh_info = 0;
2437     symstrtab_hdr->sh_addralign = 1;
2438   }
2439
2440   return true;
2441 }
2442
2443 static boolean
2444 write_shdrs_and_ehdr (abfd)
2445      bfd *abfd;
2446 {
2447   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
2448   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
2449   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
2450   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
2451   unsigned int count;
2452
2453   i_ehdrp = elf_elfheader (abfd);
2454   i_shdrp = elf_elfsections (abfd);
2455
2456   /* swap the header before spitting it out... */
2457
2458 #if DEBUG & 1
2459   elf_debug_file (i_ehdrp);
2460 #endif
2461   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
2462   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2463       || (bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd)
2464           != sizeof (x_ehdr)))
2465     return false;
2466
2467   /* at this point we've concocted all the ELF sections... */
2468   x_shdrp = (Elf_External_Shdr *)
2469     bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
2470   if (!x_shdrp)
2471     {
2472       bfd_set_error (bfd_error_no_memory);
2473       return false;
2474     }
2475
2476   for (count = 0; count < i_ehdrp->e_shnum; count++)
2477     {
2478 #if DEBUG & 2
2479       elf_debug_section (count, i_shdrp[count]);
2480 #endif
2481       elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
2482     }
2483   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
2484       || (bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd)
2485           != sizeof (*x_shdrp) * i_ehdrp->e_shnum))
2486     return false;
2487
2488   /* need to dump the string table too... */
2489
2490   return true;
2491 }
2492
2493 /* Assign file positions for all the reloc sections which are not part
2494    of the loadable file image.  */
2495
2496 static void
2497 assign_file_positions_for_relocs (abfd)
2498      bfd *abfd;
2499 {
2500   file_ptr off;
2501   unsigned int i;
2502   Elf_Internal_Shdr **shdrpp;
2503
2504   off = elf_tdata (abfd)->next_file_pos;
2505
2506   for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
2507        i < elf_elfheader (abfd)->e_shnum;
2508        i++, shdrpp++)
2509     {
2510       Elf_Internal_Shdr *shdrp;
2511
2512       shdrp = *shdrpp;
2513       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
2514           && shdrp->sh_offset == -1)
2515         off = assign_file_position_for_section (shdrp, off, true);
2516     }
2517
2518   elf_tdata (abfd)->next_file_pos = off;
2519 }
2520
2521 boolean
2522 NAME(bfd_elf,write_object_contents) (abfd)
2523      bfd *abfd;
2524 {
2525   struct elf_backend_data *bed = get_elf_backend_data (abfd);
2526   Elf_Internal_Ehdr *i_ehdrp;
2527   Elf_Internal_Shdr **i_shdrp;
2528   unsigned int count;
2529
2530   if (! abfd->output_has_begun
2531       && ! elf_compute_section_file_positions (abfd,
2532                                                (struct bfd_link_info *) NULL))
2533     return false;
2534
2535   i_shdrp = elf_elfsections (abfd);
2536   i_ehdrp = elf_elfheader (abfd);
2537
2538   bfd_map_over_sections (abfd, write_relocs, (PTR) 0);
2539   assign_file_positions_for_relocs (abfd);
2540
2541   /* After writing the headers, we need to write the sections too... */
2542   for (count = 1; count < i_ehdrp->e_shnum; count++)
2543     {
2544       if (bed->elf_backend_section_processing)
2545         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
2546       if (i_shdrp[count]->contents)
2547         {
2548           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
2549               || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
2550                              1, abfd)
2551                   != i_shdrp[count]->sh_size))
2552             return false;
2553         }
2554     }
2555
2556   /* Write out the section header names.  */
2557   if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
2558       || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
2559     return false;
2560
2561   if (bed->elf_backend_final_write_processing)
2562     (*bed->elf_backend_final_write_processing) (abfd,
2563                                                 elf_tdata (abfd)->linker);
2564
2565   return write_shdrs_and_ehdr (abfd);
2566 }
2567
2568 /* Given an ELF section number, retrieve the corresponding BFD
2569    section.  */
2570
2571 static asection *
2572 section_from_elf_index (abfd, index)
2573      bfd *abfd;
2574      unsigned int index;
2575 {
2576   BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
2577   if (index >= elf_elfheader (abfd)->e_shnum)
2578     return NULL;
2579   return elf_elfsections (abfd)[index]->bfd_section;
2580 }
2581
2582 /* given a section, search the header to find them... */
2583 static int
2584 elf_section_from_bfd_section (abfd, asect)
2585      bfd *abfd;
2586      struct sec *asect;
2587 {
2588   struct elf_backend_data *bed = get_elf_backend_data (abfd);
2589   Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
2590   int index;
2591   Elf_Internal_Shdr *hdr;
2592   int maxindex = elf_elfheader (abfd)->e_shnum;
2593
2594   if (bfd_is_abs_section (asect))
2595     return SHN_ABS;
2596   if (bfd_is_com_section (asect))
2597     return SHN_COMMON;
2598   if (bfd_is_und_section (asect))
2599     return SHN_UNDEF;
2600
2601   for (index = 0; index < maxindex; index++)
2602     {
2603       hdr = i_shdrp[index];
2604       if (hdr->bfd_section == asect)
2605         return index;
2606     }
2607
2608   if (bed->elf_backend_section_from_bfd_section)
2609     {
2610       for (index = 0; index < maxindex; index++)
2611         {
2612           int retval;
2613
2614           hdr = i_shdrp[index];
2615           retval = index;
2616           if ((*bed->elf_backend_section_from_bfd_section)
2617               (abfd, hdr, asect, &retval))
2618             return retval;
2619         }
2620     }
2621
2622   return -1;
2623 }
2624
2625 /* given a symbol, return the bfd index for that symbol.  */
2626 static int
2627 elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
2628      bfd *abfd;
2629      struct symbol_cache_entry **asym_ptr_ptr;
2630 {
2631   struct symbol_cache_entry *asym_ptr = *asym_ptr_ptr;
2632   int idx;
2633   flagword flags = asym_ptr->flags;
2634
2635   /* When gas creates relocations against local labels, it creates its
2636      own symbol for the section, but does put the symbol into the
2637      symbol chain, so udata is 0.  When the linker is generating
2638      relocatable output, this section symbol may be for one of the
2639      input sections rather than the output section.  */
2640   if (asym_ptr->udata.i == 0
2641       && (flags & BSF_SECTION_SYM)
2642       && asym_ptr->section)
2643     {
2644       int indx;
2645
2646       if (asym_ptr->section->output_section != NULL)
2647         indx = asym_ptr->section->output_section->index;
2648       else
2649         indx = asym_ptr->section->index;
2650       if (elf_section_syms (abfd)[indx])
2651         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
2652     }
2653
2654   idx = asym_ptr->udata.i;
2655   if (idx == 0)
2656     abort ();
2657
2658 #if DEBUG & 4
2659   {
2660
2661     fprintf (stderr,
2662              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2663      (long) asym_ptr, asym_ptr->name, idx, flags, elf_symbol_flags (flags));
2664     fflush (stderr);
2665   }
2666 #endif
2667
2668   return idx;
2669 }
2670
2671 static long
2672 elf_slurp_symbol_table (abfd, symptrs, dynamic)
2673      bfd *abfd;
2674      asymbol **symptrs;         /* Buffer for generated bfd symbols */
2675      boolean dynamic;
2676 {
2677   Elf_Internal_Shdr *hdr;
2678   long symcount;                /* Number of external ELF symbols */
2679   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
2680   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
2681   Elf_Internal_Sym i_sym;
2682   Elf_External_Sym *x_symp = NULL;
2683
2684   /* Read each raw ELF symbol, converting from external ELF form to
2685      internal ELF form, and then using the information to create a
2686      canonical bfd symbol table entry.
2687
2688      Note that we allocate the initial bfd canonical symbol buffer
2689      based on a one-to-one mapping of the ELF symbols to canonical
2690      symbols.  We actually use all the ELF symbols, so there will be no
2691      space left over at the end.  When we have all the symbols, we
2692      build the caller's pointer vector. */
2693
2694   if (dynamic)
2695     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2696   else
2697     hdr = &elf_tdata (abfd)->symtab_hdr;
2698   if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
2699     return -1;
2700
2701   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
2702
2703   if (symcount == 0)
2704     sym = symbase = NULL;
2705   else
2706     {
2707       long i;
2708
2709       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
2710         return -1;
2711
2712       symbase = ((elf_symbol_type *)
2713                  bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
2714       if (symbase == (elf_symbol_type *) NULL)
2715         {
2716           bfd_set_error (bfd_error_no_memory);
2717           return -1;
2718         }
2719       sym = symbase;
2720
2721       /* Temporarily allocate room for the raw ELF symbols.  */
2722       x_symp = ((Elf_External_Sym *)
2723                 malloc (symcount * sizeof (Elf_External_Sym)));
2724       if (x_symp == NULL && symcount != 0)
2725         {
2726           bfd_set_error (bfd_error_no_memory);
2727           goto error_return;
2728         }
2729
2730       if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
2731           != symcount * sizeof (Elf_External_Sym))
2732         goto error_return;
2733       /* Skip first symbol, which is a null dummy.  */
2734       for (i = 1; i < symcount; i++)
2735         {
2736           elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
2737           memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
2738 #ifdef ELF_KEEP_EXTSYM
2739           memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
2740 #endif
2741           sym->symbol.the_bfd = abfd;
2742
2743           sym->symbol.name = elf_string_from_elf_section (abfd, hdr->sh_link,
2744                                                           i_sym.st_name);
2745
2746           sym->symbol.value = i_sym.st_value;
2747
2748           if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
2749             {
2750               sym->symbol.section = section_from_elf_index (abfd,
2751                                                             i_sym.st_shndx);
2752               if (sym->symbol.section == NULL)
2753                 {
2754                   /* This symbol is in a section for which we did not
2755                      create a BFD section.  Just use bfd_abs_section,
2756                      although it is wrong.  FIXME.  */
2757                   sym->symbol.section = bfd_abs_section_ptr;
2758                 }
2759             }
2760           else if (i_sym.st_shndx == SHN_ABS)
2761             {
2762               sym->symbol.section = bfd_abs_section_ptr;
2763             }
2764           else if (i_sym.st_shndx == SHN_COMMON)
2765             {
2766               sym->symbol.section = bfd_com_section_ptr;
2767               /* Elf puts the alignment into the `value' field, and
2768                  the size into the `size' field.  BFD wants to see the
2769                  size in the value field, and doesn't care (at the
2770                  moment) about the alignment.  */
2771               sym->symbol.value = i_sym.st_size;
2772             }
2773           else if (i_sym.st_shndx == SHN_UNDEF)
2774             {
2775               sym->symbol.section = bfd_und_section_ptr;
2776             }
2777           else
2778             sym->symbol.section = bfd_abs_section_ptr;
2779
2780           sym->symbol.value -= sym->symbol.section->vma;
2781
2782           switch (ELF_ST_BIND (i_sym.st_info))
2783             {
2784             case STB_LOCAL:
2785               sym->symbol.flags |= BSF_LOCAL;
2786               break;
2787             case STB_GLOBAL:
2788               sym->symbol.flags |= BSF_GLOBAL;
2789               break;
2790             case STB_WEAK:
2791               sym->symbol.flags |= BSF_WEAK;
2792               break;
2793             }
2794
2795           switch (ELF_ST_TYPE (i_sym.st_info))
2796             {
2797             case STT_SECTION:
2798               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
2799               break;
2800             case STT_FILE:
2801               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
2802               break;
2803             case STT_FUNC:
2804               sym->symbol.flags |= BSF_FUNCTION;
2805               break;
2806             }
2807
2808           if (dynamic)
2809             sym->symbol.flags |= BSF_DYNAMIC;
2810
2811           /* Do some backend-specific processing on this symbol.  */
2812           {
2813             struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2814             if (ebd->elf_backend_symbol_processing)
2815               (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
2816           }
2817
2818           sym++;
2819         }
2820     }
2821
2822   /* Do some backend-specific processing on this symbol table.  */
2823   {
2824     struct elf_backend_data *ebd = get_elf_backend_data (abfd);
2825     if (ebd->elf_backend_symbol_table_processing)
2826       (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
2827   }
2828
2829   /* We rely on the zalloc to clear out the final symbol entry.  */
2830
2831   symcount = sym - symbase;
2832
2833   /* Fill in the user's symbol pointer vector if needed.  */
2834   if (symptrs)
2835     {
2836       long l = symcount;
2837
2838       sym = symbase;
2839       while (l-- > 0)
2840         {
2841           *symptrs++ = &sym->symbol;
2842           sym++;
2843         }
2844       *symptrs = 0;             /* Final null pointer */
2845     }
2846
2847   if (x_symp != NULL)
2848     free (x_symp);
2849   return symcount;
2850 error_return:
2851   if (x_symp != NULL)
2852     free (x_symp);
2853   return -1;
2854 }
2855
2856 /* Return the number of bytes required to hold the symtab vector.
2857
2858    Note that we base it on the count plus 1, since we will null terminate
2859    the vector allocated based on this size.  However, the ELF symbol table
2860    always has a dummy entry as symbol #0, so it ends up even.  */
2861
2862 long
2863 elf_get_symtab_upper_bound (abfd)
2864      bfd *abfd;
2865 {
2866   long symcount;
2867   long symtab_size;
2868   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
2869
2870   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
2871   symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
2872
2873   return symtab_size;
2874 }
2875
2876 long
2877 elf_get_dynamic_symtab_upper_bound (abfd)
2878      bfd *abfd;
2879 {
2880   long symcount;
2881   long symtab_size;
2882   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2883
2884   if (elf_dynsymtab (abfd) == 0)
2885     {
2886       bfd_set_error (bfd_error_invalid_operation);
2887       return -1;
2888     }
2889
2890   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
2891   symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
2892
2893   return symtab_size;
2894 }
2895
2896 long
2897 elf_get_reloc_upper_bound (abfd, asect)
2898      bfd *abfd;
2899      sec_ptr asect;
2900 {
2901   return (asect->reloc_count + 1) * sizeof (arelent *);
2902 }
2903
2904 /* Read in and swap the external relocs.  */
2905
2906 static boolean
2907 elf_slurp_reloc_table (abfd, asect, symbols)
2908      bfd *abfd;
2909      asection *asect;
2910      asymbol **symbols;
2911 {
2912   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
2913   struct bfd_elf_section_data * const d = elf_section_data (asect);
2914   PTR allocated = NULL;
2915   bfd_byte *native_relocs;
2916   arelent *relents;
2917   arelent *relent;
2918   unsigned int i;
2919   int entsize;
2920
2921   if (asect->relocation != NULL
2922       || (asect->flags & SEC_RELOC) == 0
2923       || asect->reloc_count == 0)
2924     return true;
2925
2926   BFD_ASSERT (asect->rel_filepos == d->rel_hdr.sh_offset
2927               && (asect->reloc_count
2928                   == d->rel_hdr.sh_size / d->rel_hdr.sh_entsize));
2929
2930   allocated = (PTR) malloc (d->rel_hdr.sh_size);
2931   if (allocated == NULL)
2932     {
2933       bfd_set_error (bfd_error_no_memory);
2934       goto error_return;
2935     }
2936
2937   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0
2938       || (bfd_read (allocated, 1, d->rel_hdr.sh_size, abfd)
2939           != d->rel_hdr.sh_size))
2940     goto error_return;
2941
2942   native_relocs = (bfd_byte *) allocated;
2943
2944   relents = ((arelent *)
2945              bfd_alloc (abfd, asect->reloc_count * sizeof (arelent)));
2946   if (relents == NULL)
2947     {
2948       bfd_set_error (bfd_error_no_memory);
2949       goto error_return;
2950     }
2951
2952   entsize = d->rel_hdr.sh_entsize;
2953   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
2954               || entsize == sizeof (Elf_External_Rela));
2955
2956   for (i = 0, relent = relents;
2957        i < asect->reloc_count;
2958        i++, relent++, native_relocs += entsize)
2959     {
2960       Elf_Internal_Rela rela;
2961       Elf_Internal_Rel rel;
2962
2963       if (entsize == sizeof (Elf_External_Rela))
2964         elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
2965       else
2966         {
2967           elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
2968           rela.r_offset = rel.r_offset;
2969           rela.r_info = rel.r_info;
2970           rela.r_addend = 0;
2971         }
2972
2973       /* The address of an ELF reloc is section relative for an object
2974          file, and absolute for an executable file or shared library.
2975          The address of a BFD reloc is always section relative.  */
2976       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2977         relent->address = rela.r_offset;
2978       else
2979         relent->address = rela.r_offset - asect->vma;
2980
2981       if (ELF_R_SYM (rela.r_info) == 0)
2982         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2983       else
2984         {
2985           asymbol **ps, *s;
2986
2987           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
2988           s = *ps;
2989
2990           /* Canonicalize ELF section symbols.  FIXME: Why?  */
2991           if ((s->flags & BSF_SECTION_SYM) == 0)
2992             relent->sym_ptr_ptr = ps;
2993           else
2994             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
2995         }
2996
2997       relent->addend = rela.r_addend;
2998
2999       if (entsize == sizeof (Elf_External_Rela))
3000         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
3001       else
3002         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
3003     }
3004
3005   asect->relocation = relents;
3006
3007   if (allocated != NULL)
3008     free (allocated);
3009
3010   return true;
3011
3012  error_return:
3013   if (allocated != NULL)
3014     free (allocated);
3015   return false;
3016 }
3017
3018 #ifdef DEBUG
3019 static void
3020 elf_debug_section (num, hdr)
3021      int num;
3022      Elf_Internal_Shdr *hdr;
3023 {
3024   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
3025            hdr->bfd_section != NULL ? hfd->bfd_section->name : "",
3026            (long) hdr);
3027   fprintf (stderr,
3028            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
3029            (long) hdr->sh_name,
3030            (long) hdr->sh_type,
3031            (long) hdr->sh_flags);
3032   fprintf (stderr,
3033            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
3034            (long) hdr->sh_addr,
3035            (long) hdr->sh_offset,
3036            (long) hdr->sh_size);
3037   fprintf (stderr,
3038            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
3039            (long) hdr->sh_link,
3040            (long) hdr->sh_info,
3041            (long) hdr->sh_addralign);
3042   fprintf (stderr, "sh_entsize   = %ld\n",
3043            (long) hdr->sh_entsize);
3044   fflush (stderr);
3045 }
3046
3047 static void
3048 elf_debug_file (ehdrp)
3049      Elf_Internal_Ehdr *ehdrp;
3050 {
3051   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
3052   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
3053   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
3054   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
3055   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
3056   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
3057   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
3058 }
3059 #endif
3060
3061 /* Canonicalize the relocs.  */
3062
3063 long
3064 elf_canonicalize_reloc (abfd, section, relptr, symbols)
3065      bfd *abfd;
3066      sec_ptr section;
3067      arelent **relptr;
3068      asymbol **symbols;
3069 {
3070   arelent *tblptr;
3071   unsigned int i;
3072
3073   if (! elf_slurp_reloc_table (abfd, section, symbols))
3074     return -1;
3075
3076   tblptr = section->relocation;
3077   for (i = 0; i < section->reloc_count; i++)
3078     *relptr++ = tblptr++;
3079
3080   *relptr = NULL;
3081
3082   return section->reloc_count;
3083 }
3084
3085 long
3086 elf_get_symtab (abfd, alocation)
3087      bfd *abfd;
3088      asymbol **alocation;
3089 {
3090   long symcount = elf_slurp_symbol_table (abfd, alocation, false);
3091
3092   if (symcount >= 0)
3093     bfd_get_symcount (abfd) = symcount;
3094   return symcount;
3095 }
3096
3097 long
3098 elf_canonicalize_dynamic_symtab (abfd, alocation)
3099      bfd *abfd;
3100      asymbol **alocation;
3101 {
3102   return elf_slurp_symbol_table (abfd, alocation, true);
3103 }
3104
3105 asymbol *
3106 elf_make_empty_symbol (abfd)
3107      bfd *abfd;
3108 {
3109   elf_symbol_type *newsym;
3110
3111   newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
3112   if (!newsym)
3113     {
3114       bfd_set_error (bfd_error_no_memory);
3115       return NULL;
3116     }
3117   else
3118     {
3119       newsym->symbol.the_bfd = abfd;
3120       return &newsym->symbol;
3121     }
3122 }
3123
3124 void
3125 elf_get_symbol_info (ignore_abfd, symbol, ret)
3126      bfd *ignore_abfd;
3127      asymbol *symbol;
3128      symbol_info *ret;
3129 {
3130   bfd_symbol_info (symbol, ret);
3131 }
3132
3133 alent *
3134 elf_get_lineno (ignore_abfd, symbol)
3135      bfd *ignore_abfd;
3136      asymbol *symbol;
3137 {
3138   fprintf (stderr, "elf_get_lineno unimplemented\n");
3139   fflush (stderr);
3140   BFD_FAIL ();
3141   return NULL;
3142 }
3143
3144 boolean
3145 elf_set_arch_mach (abfd, arch, machine)
3146      bfd *abfd;
3147      enum bfd_architecture arch;
3148      unsigned long machine;
3149 {
3150   /* If this isn't the right architecture for this backend, and this
3151      isn't the generic backend, fail.  */
3152   if (arch != get_elf_backend_data (abfd)->arch
3153       && arch != bfd_arch_unknown
3154       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
3155     return false;
3156
3157   return bfd_default_set_arch_mach (abfd, arch, machine);
3158 }
3159
3160 boolean
3161 elf_find_nearest_line (abfd,
3162                        section,
3163                        symbols,
3164                        offset,
3165                        filename_ptr,
3166                        functionname_ptr,
3167                        line_ptr)
3168      bfd *abfd;
3169      asection *section;
3170      asymbol **symbols;
3171      bfd_vma offset;
3172      CONST char **filename_ptr;
3173      CONST char **functionname_ptr;
3174      unsigned int *line_ptr;
3175 {
3176   return false;
3177 }
3178
3179 int
3180 elf_sizeof_headers (abfd, reloc)
3181      bfd *abfd;
3182      boolean reloc;
3183 {
3184   int ret;
3185
3186   ret = sizeof (Elf_External_Ehdr);
3187   if (! reloc)
3188     ret += get_program_header_size (abfd);
3189   return ret;
3190 }
3191
3192 boolean
3193 elf_set_section_contents (abfd, section, location, offset, count)
3194      bfd *abfd;
3195      sec_ptr section;
3196      PTR location;
3197      file_ptr offset;
3198      bfd_size_type count;
3199 {
3200   Elf_Internal_Shdr *hdr;
3201
3202   if (! abfd->output_has_begun
3203       && ! elf_compute_section_file_positions (abfd,
3204                                                (struct bfd_link_info *) NULL))
3205     return false;
3206
3207   hdr = &elf_section_data (section)->this_hdr;
3208
3209   if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
3210     return false;
3211   if (bfd_write (location, 1, count, abfd) != count)
3212     return false;
3213
3214   return true;
3215 }
3216
3217 void
3218 elf_no_info_to_howto (abfd, cache_ptr, dst)
3219      bfd *abfd;
3220      arelent *cache_ptr;
3221      Elf_Internal_Rela *dst;
3222 {
3223   fprintf (stderr, "elf RELA relocation support for target machine unimplemented\n");
3224   fflush (stderr);
3225   BFD_FAIL ();
3226 }
3227
3228 void
3229 elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
3230      bfd *abfd;
3231      arelent *cache_ptr;
3232      Elf_Internal_Rel *dst;
3233 {
3234   fprintf (stderr, "elf REL relocation support for target machine unimplemented\n");
3235   fflush (stderr);
3236   BFD_FAIL ();
3237 }
3238 \f
3239
3240 /* Core file support */
3241
3242 #ifdef HAVE_PROCFS              /* Some core file support requires host /proc files */
3243 #include <sys/procfs.h>
3244 #else
3245 #define bfd_prstatus(abfd, descdata, descsz, filepos) true
3246 #define bfd_fpregset(abfd, descdata, descsz, filepos) true
3247 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) true
3248 #endif
3249
3250 #ifdef HAVE_PROCFS
3251
3252 static boolean
3253 bfd_prstatus (abfd, descdata, descsz, filepos)
3254      bfd *abfd;
3255      char *descdata;
3256      int descsz;
3257      long filepos;
3258 {
3259   asection *newsect;
3260   prstatus_t *status = (prstatus_t *) 0;
3261
3262   if (descsz == sizeof (prstatus_t))
3263     {
3264       newsect = bfd_make_section (abfd, ".reg");
3265       if (newsect == NULL)
3266         return false;
3267       newsect->_raw_size = sizeof (status->pr_reg);
3268       newsect->filepos = filepos + (long) &status->pr_reg;
3269       newsect->flags = SEC_HAS_CONTENTS;
3270       newsect->alignment_power = 2;
3271       if ((core_prstatus (abfd) = bfd_alloc (abfd, descsz)) != NULL)
3272         {
3273           memcpy (core_prstatus (abfd), descdata, descsz);
3274         }
3275     }
3276   return true;
3277 }
3278
3279 /* Stash a copy of the prpsinfo structure away for future use. */
3280
3281 static boolean
3282 bfd_prpsinfo (abfd, descdata, descsz, filepos)
3283      bfd *abfd;
3284      char *descdata;
3285      int descsz;
3286      long filepos;
3287 {
3288   if (descsz == sizeof (prpsinfo_t))
3289     {
3290       if ((core_prpsinfo (abfd) = bfd_alloc (abfd, descsz)) == NULL)
3291         {
3292           bfd_set_error (bfd_error_no_memory);
3293           return false;
3294         }
3295       memcpy (core_prpsinfo (abfd), descdata, descsz);
3296     }
3297   return true;
3298 }
3299
3300 static boolean
3301 bfd_fpregset (abfd, descdata, descsz, filepos)
3302      bfd *abfd;
3303      char *descdata;
3304      int descsz;
3305      long filepos;
3306 {
3307   asection *newsect;
3308
3309   newsect = bfd_make_section (abfd, ".reg2");
3310   if (newsect == NULL)
3311     return false;
3312   newsect->_raw_size = descsz;
3313   newsect->filepos = filepos;
3314   newsect->flags = SEC_HAS_CONTENTS;
3315   newsect->alignment_power = 2;
3316   return true;
3317 }
3318
3319 #endif /* HAVE_PROCFS */
3320
3321 /* Return a pointer to the args (including the command name) that were
3322    seen by the program that generated the core dump.  Note that for
3323    some reason, a spurious space is tacked onto the end of the args
3324    in some (at least one anyway) implementations, so strip it off if
3325    it exists. */
3326
3327 char *
3328 elf_core_file_failing_command (abfd)
3329      bfd *abfd;
3330 {
3331 #ifdef HAVE_PROCFS
3332   if (core_prpsinfo (abfd))
3333     {
3334       prpsinfo_t *p = core_prpsinfo (abfd);
3335       char *scan = p->pr_psargs;
3336       while (*scan++)
3337         {;
3338         }
3339       scan -= 2;
3340       if ((scan > p->pr_psargs) && (*scan == ' '))
3341         {
3342           *scan = '\000';
3343         }
3344       return p->pr_psargs;
3345     }
3346 #endif
3347   return NULL;
3348 }
3349
3350 /* Return the number of the signal that caused the core dump.  Presumably,
3351    since we have a core file, we got a signal of some kind, so don't bother
3352    checking the other process status fields, just return the signal number.
3353    */
3354
3355 int
3356 elf_core_file_failing_signal (abfd)
3357      bfd *abfd;
3358 {
3359 #ifdef HAVE_PROCFS
3360   if (core_prstatus (abfd))
3361     {
3362       return ((prstatus_t *) (core_prstatus (abfd)))->pr_cursig;
3363     }
3364 #endif
3365   return -1;
3366 }
3367
3368 /* Check to see if the core file could reasonably be expected to have
3369    come for the current executable file.  Note that by default we return
3370    true unless we find something that indicates that there might be a
3371    problem.
3372    */
3373
3374 boolean
3375 elf_core_file_matches_executable_p (core_bfd, exec_bfd)
3376      bfd *core_bfd;
3377      bfd *exec_bfd;
3378 {
3379 #ifdef HAVE_PROCFS
3380   char *corename;
3381   char *execname;
3382 #endif
3383
3384   /* First, xvecs must match since both are ELF files for the same target. */
3385
3386   if (core_bfd->xvec != exec_bfd->xvec)
3387     {
3388       bfd_set_error (bfd_error_system_call);
3389       return false;
3390     }
3391
3392 #ifdef HAVE_PROCFS
3393
3394   /* If no prpsinfo, just return true.  Otherwise, grab the last component
3395      of the exec'd pathname from the prpsinfo. */
3396
3397   if (core_prpsinfo (core_bfd))
3398     {
3399       corename = (((struct prpsinfo *) core_prpsinfo (core_bfd))->pr_fname);
3400     }
3401   else
3402     {
3403       return true;
3404     }
3405
3406   /* Find the last component of the executable pathname. */
3407
3408   if ((execname = strrchr (exec_bfd->filename, '/')) != NULL)
3409     {
3410       execname++;
3411     }
3412   else
3413     {
3414       execname = (char *) exec_bfd->filename;
3415     }
3416
3417   /* See if they match */
3418
3419   return strcmp (execname, corename) ? false : true;
3420
3421 #else
3422
3423   return true;
3424
3425 #endif /* HAVE_PROCFS */
3426 }
3427
3428 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3429    the information that would normally be available from the /proc interface
3430    for the process, at the time the process dumped core.  Currently this
3431    includes copies of the prstatus, prpsinfo, and fpregset structures.
3432
3433    Since these structures are potentially machine dependent in size and
3434    ordering, bfd provides two levels of support for them.  The first level,
3435    available on all machines since it does not require that the host
3436    have /proc support or the relevant include files, is to create a bfd
3437    section for each of the prstatus, prpsinfo, and fpregset structures,
3438    without any interpretation of their contents.  With just this support,
3439    the bfd client will have to interpret the structures itself.  Even with
3440    /proc support, it might want these full structures for it's own reasons.
3441
3442    In the second level of support, where HAVE_PROCFS is defined, bfd will
3443    pick apart the structures to gather some additional information that
3444    clients may want, such as the general register set, the name of the
3445    exec'ed file and its arguments, the signal (if any) that caused the
3446    core dump, etc.
3447
3448    */
3449
3450 static boolean
3451 elf_corefile_note (abfd, hdr)
3452      bfd *abfd;
3453      Elf_Internal_Phdr *hdr;
3454 {
3455   Elf_External_Note *x_note_p;  /* Elf note, external form */
3456   Elf_Internal_Note i_note;     /* Elf note, internal form */
3457   char *buf = NULL;             /* Entire note segment contents */
3458   char *namedata;               /* Name portion of the note */
3459   char *descdata;               /* Descriptor portion of the note */
3460   char *sectname;               /* Name to use for new section */
3461   long filepos;                 /* File offset to descriptor data */
3462   asection *newsect;
3463
3464   if (hdr->p_filesz > 0
3465       && (buf = (char *) malloc (hdr->p_filesz)) != NULL
3466       && bfd_seek (abfd, hdr->p_offset, SEEK_SET) != -1
3467       && bfd_read ((PTR) buf, hdr->p_filesz, 1, abfd) == hdr->p_filesz)
3468     {
3469       x_note_p = (Elf_External_Note *) buf;
3470       while ((char *) x_note_p < (buf + hdr->p_filesz))
3471         {
3472           i_note.namesz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->namesz);
3473           i_note.descsz = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->descsz);
3474           i_note.type = bfd_h_get_32 (abfd, (bfd_byte *) x_note_p->type);
3475           namedata = x_note_p->name;
3476           descdata = namedata + BFD_ALIGN (i_note.namesz, 4);
3477           filepos = hdr->p_offset + (descdata - buf);
3478           switch (i_note.type)
3479             {
3480             case NT_PRSTATUS:
3481               /* process descdata as prstatus info */
3482               if (! bfd_prstatus (abfd, descdata, i_note.descsz, filepos))
3483                 return false;
3484               sectname = ".prstatus";
3485               break;
3486             case NT_FPREGSET:
3487               /* process descdata as fpregset info */
3488               if (! bfd_fpregset (abfd, descdata, i_note.descsz, filepos))
3489                 return false;
3490               sectname = ".fpregset";
3491               break;
3492             case NT_PRPSINFO:
3493               /* process descdata as prpsinfo */
3494               if (! bfd_prpsinfo (abfd, descdata, i_note.descsz, filepos))
3495                 return false;
3496               sectname = ".prpsinfo";
3497               break;
3498             default:
3499               /* Unknown descriptor, just ignore it. */
3500               sectname = NULL;
3501               break;
3502             }
3503           if (sectname != NULL)
3504             {
3505               newsect = bfd_make_section (abfd, sectname);
3506               if (newsect == NULL)
3507                 return false;
3508               newsect->_raw_size = i_note.descsz;
3509               newsect->filepos = filepos;
3510               newsect->flags = SEC_ALLOC | SEC_HAS_CONTENTS;
3511               newsect->alignment_power = 2;
3512             }
3513           x_note_p = (Elf_External_Note *)
3514             (descdata + BFD_ALIGN (i_note.descsz, 4));
3515         }
3516     }
3517   if (buf != NULL)
3518     {
3519       free (buf);
3520     }
3521   else if (hdr->p_filesz > 0)
3522     {
3523       bfd_set_error (bfd_error_no_memory);
3524       return false;
3525     }
3526   return true;
3527
3528 }
3529
3530 /*  Core files are simply standard ELF formatted files that partition
3531     the file using the execution view of the file (program header table)
3532     rather than the linking view.  In fact, there is no section header
3533     table in a core file.
3534
3535     The process status information (including the contents of the general
3536     register set) and the floating point register set are stored in a
3537     segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
3538     that allow standard bfd access to the general registers (.reg) and the
3539     floating point registers (.reg2).
3540
3541  */
3542
3543 const bfd_target *
3544 elf_core_file_p (abfd)
3545      bfd *abfd;
3546 {
3547   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
3548   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
3549   Elf_External_Phdr x_phdr;     /* Program header table entry, external form */
3550   Elf_Internal_Phdr *i_phdrp;   /* Program header table, internal form */
3551   unsigned int phindex;
3552   struct elf_backend_data *ebd;
3553
3554   /* Read in the ELF header in external format.  */
3555
3556   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
3557     {
3558       if (bfd_get_error () != bfd_error_system_call)
3559         bfd_set_error (bfd_error_wrong_format);
3560       return NULL;
3561     }
3562
3563   /* Now check to see if we have a valid ELF file, and one that BFD can
3564      make use of.  The magic number must match, the address size ('class')
3565      and byte-swapping must match our XVEC entry, and it must have a
3566      program header table (FIXME: See comments re segments at top of this
3567      file). */
3568
3569   if (elf_file_p (&x_ehdr) == false)
3570     {
3571     wrong:
3572       bfd_set_error (bfd_error_wrong_format);
3573       return NULL;
3574     }
3575
3576   /* FIXME, Check EI_VERSION here !  */
3577
3578   {
3579 #if ARCH_SIZE == 32
3580     int desired_address_size = ELFCLASS32;
3581 #endif
3582 #if ARCH_SIZE == 64
3583     int desired_address_size = ELFCLASS64;
3584 #endif
3585
3586     if (x_ehdr.e_ident[EI_CLASS] != desired_address_size)
3587       goto wrong;
3588   }
3589
3590   /* Switch xvec to match the specified byte order.  */
3591   switch (x_ehdr.e_ident[EI_DATA])
3592     {
3593     case ELFDATA2MSB:           /* Big-endian */
3594       if (abfd->xvec->byteorder_big_p == false)
3595         goto wrong;
3596       break;
3597     case ELFDATA2LSB:           /* Little-endian */
3598       if (abfd->xvec->byteorder_big_p == true)
3599         goto wrong;
3600       break;
3601     case ELFDATANONE:           /* No data encoding specified */
3602     default:                    /* Unknown data encoding specified */
3603       goto wrong;
3604     }
3605
3606   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3607      the tdata pointer in the bfd. */
3608
3609   elf_tdata (abfd) =
3610     (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
3611   if (elf_tdata (abfd) == NULL)
3612     {
3613       bfd_set_error (bfd_error_no_memory);
3614       return NULL;
3615     }
3616
3617   /* FIXME, `wrong' returns from this point onward, leak memory.  */
3618
3619   /* Now that we know the byte order, swap in the rest of the header */
3620   i_ehdrp = elf_elfheader (abfd);
3621   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
3622 #if DEBUG & 1
3623   elf_debug_file (i_ehdrp);
3624 #endif
3625
3626   ebd = get_elf_backend_data (abfd);
3627
3628   /* Check that the ELF e_machine field matches what this particular
3629      BFD format expects.  */
3630   if (ebd->elf_machine_code != i_ehdrp->e_machine)
3631     {
3632       const bfd_target * const *target_ptr;
3633
3634       if (ebd->elf_machine_code != EM_NONE)
3635         goto wrong;
3636
3637       /* This is the generic ELF target.  Let it match any ELF target
3638          for which we do not have a specific backend.  */
3639       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
3640         {
3641           struct elf_backend_data *back;
3642
3643           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
3644             continue;
3645           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
3646           if (back->elf_machine_code == i_ehdrp->e_machine)
3647             {
3648               /* target_ptr is an ELF backend which matches this
3649                  object file, so reject the generic ELF target.  */
3650               goto wrong;
3651             }
3652         }
3653     }
3654
3655   /* If there is no program header, or the type is not a core file, then
3656      we are hosed. */
3657   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
3658     goto wrong;
3659
3660   /* Allocate space for a copy of the program header table in
3661      internal form, seek to the program header table in the file,
3662      read it in, and convert it to internal form.  As a simple sanity
3663      check, verify that the what BFD thinks is the size of each program
3664      header table entry actually matches the size recorded in the file. */
3665
3666   if (i_ehdrp->e_phentsize != sizeof (x_phdr))
3667     goto wrong;
3668   i_phdrp = (Elf_Internal_Phdr *)
3669     bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
3670   if (!i_phdrp)
3671     {
3672       bfd_set_error (bfd_error_no_memory);
3673       return NULL;
3674     }
3675   if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) == -1)
3676     return NULL;
3677   for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
3678     {
3679       if (bfd_read ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd)
3680           != sizeof (x_phdr))
3681         return NULL;
3682       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
3683     }
3684
3685   /* Once all of the program headers have been read and converted, we
3686      can start processing them. */
3687
3688   for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
3689     {
3690       bfd_section_from_phdr (abfd, i_phdrp + phindex, phindex);
3691       if ((i_phdrp + phindex)->p_type == PT_NOTE)
3692         {
3693           if (! elf_corefile_note (abfd, i_phdrp + phindex))
3694             return NULL;
3695         }
3696     }
3697
3698   /* Remember the entry point specified in the ELF file header. */
3699
3700   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
3701
3702   return abfd->xvec;
3703 }
3704 \f
3705 /* ELF linker code.  */
3706
3707 static boolean elf_link_add_object_symbols
3708   PARAMS ((bfd *, struct bfd_link_info *));
3709 static boolean elf_link_add_archive_symbols
3710   PARAMS ((bfd *, struct bfd_link_info *));
3711 static Elf_Internal_Rela *elf_link_read_relocs
3712   PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean));
3713 static boolean elf_export_symbol
3714   PARAMS ((struct elf_link_hash_entry *, PTR));
3715 static boolean elf_adjust_dynamic_symbol
3716   PARAMS ((struct elf_link_hash_entry *, PTR));
3717
3718 /* Given an ELF BFD, add symbols to the global hash table as
3719    appropriate.  */
3720
3721 boolean
3722 elf_bfd_link_add_symbols (abfd, info)
3723      bfd *abfd;
3724      struct bfd_link_info *info;
3725 {
3726   switch (bfd_get_format (abfd))
3727     {
3728     case bfd_object:
3729       return elf_link_add_object_symbols (abfd, info);
3730     case bfd_archive:
3731       return elf_link_add_archive_symbols (abfd, info);
3732     default:
3733       bfd_set_error (bfd_error_wrong_format);
3734       return false;
3735     }
3736 }
3737
3738 /* Add symbols from an ELF archive file to the linker hash table.  We
3739    don't use _bfd_generic_link_add_archive_symbols because of a
3740    problem which arises on UnixWare.  The UnixWare libc.so is an
3741    archive which includes an entry libc.so.1 which defines a bunch of
3742    symbols.  The libc.so archive also includes a number of other
3743    object files, which also define symbols, some of which are the same
3744    as those defined in libc.so.1.  Correct linking requires that we
3745    consider each object file in turn, and include it if it defines any
3746    symbols we need.  _bfd_generic_link_add_archive_symbols does not do
3747    this; it looks through the list of undefined symbols, and includes
3748    any object file which defines them.  When this algorithm is used on
3749    UnixWare, it winds up pulling in libc.so.1 early and defining a
3750    bunch of symbols.  This means that some of the other objects in the
3751    archive are not included in the link, which is incorrect since they
3752    precede libc.so.1 in the archive.
3753
3754    Fortunately, ELF archive handling is simpler than that done by
3755    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
3756    oddities.  In ELF, if we find a symbol in the archive map, and the
3757    symbol is currently undefined, we know that we must pull in that
3758    object file.
3759
3760    Unfortunately, we do have to make multiple passes over the symbol
3761    table until nothing further is resolved.  */
3762
3763 static boolean
3764 elf_link_add_archive_symbols (abfd, info)
3765      bfd *abfd;
3766      struct bfd_link_info *info;
3767 {
3768   symindex c;
3769   boolean *defined = NULL;
3770   boolean *included = NULL;
3771   carsym *symdefs;
3772   boolean loop;
3773
3774   if (! bfd_has_map (abfd))
3775     {
3776       /* An empty archive is a special case.  */
3777       if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
3778         return true;
3779       bfd_set_error (bfd_error_no_symbols);
3780       return false;
3781     }
3782
3783   /* Keep track of all symbols we know to be already defined, and all
3784      files we know to be already included.  This is to speed up the
3785      second and subsequent passes.  */
3786   c = bfd_ardata (abfd)->symdef_count;
3787   if (c == 0)
3788     return true;
3789   defined = (boolean *) malloc (c * sizeof (boolean));
3790   included = (boolean *) malloc (c * sizeof (boolean));
3791   if (defined == (boolean *) NULL || included == (boolean *) NULL)
3792     {
3793       bfd_set_error (bfd_error_no_memory);
3794       goto error_return;
3795     }
3796   memset (defined, 0, c * sizeof (boolean));
3797   memset (included, 0, c * sizeof (boolean));
3798
3799   symdefs = bfd_ardata (abfd)->symdefs;
3800
3801   do
3802     {
3803       file_ptr last;
3804       symindex i;
3805       carsym *symdef;
3806       carsym *symdefend;
3807
3808       loop = false;
3809       last = -1;
3810
3811       symdef = symdefs;
3812       symdefend = symdef + c;
3813       for (i = 0; symdef < symdefend; symdef++, i++)
3814         {
3815           struct elf_link_hash_entry *h;
3816           bfd *element;
3817           struct bfd_link_hash_entry *undefs_tail;
3818           symindex mark;
3819
3820           if (defined[i] || included[i])
3821             continue;
3822           if (symdef->file_offset == last)
3823             {
3824               included[i] = true;
3825               continue;
3826             }
3827
3828           h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
3829                                     false, false, false);
3830           if (h == (struct elf_link_hash_entry *) NULL)
3831             continue;
3832           if (h->root.type != bfd_link_hash_undefined)
3833             {
3834               defined[i] = true;
3835               continue;
3836             }
3837
3838           /* We need to include this archive member.  */
3839
3840           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
3841           if (element == (bfd *) NULL)
3842             goto error_return;
3843
3844           if (! bfd_check_format (element, bfd_object))
3845             goto error_return;
3846
3847           /* Doublecheck that we have not included this object
3848              already--it should be impossible, but there may be
3849              something wrong with the archive.  */
3850           if (element->archive_pass != 0)
3851             {
3852               bfd_set_error (bfd_error_bad_value);
3853               goto error_return;
3854             }
3855           element->archive_pass = 1;
3856
3857           undefs_tail = info->hash->undefs_tail;
3858
3859           if (! (*info->callbacks->add_archive_element) (info, element,
3860                                                          symdef->name))
3861             goto error_return;
3862           if (! elf_link_add_object_symbols (element, info))
3863             goto error_return;
3864
3865           /* If there are any new undefined symbols, we need to make
3866              another pass through the archive in order to see whether
3867              they can be defined.  FIXME: This isn't perfect, because
3868              common symbols wind up on undefs_tail and because an
3869              undefined symbol which is defined later on in this pass
3870              does not require another pass.  This isn't a bug, but it
3871              does make the code less efficient than it could be.  */
3872           if (undefs_tail != info->hash->undefs_tail)
3873             loop = true;
3874
3875           /* Look backward to mark all symbols from this object file
3876              which we have already seen in this pass.  */
3877           mark = i;
3878           do
3879             {
3880               included[mark] = true;
3881               if (mark == 0)
3882                 break;
3883               --mark;
3884             }
3885           while (symdefs[mark].file_offset == symdef->file_offset);
3886
3887           /* We mark subsequent symbols from this object file as we go
3888              on through the loop.  */
3889           last = symdef->file_offset;
3890         }
3891     }
3892   while (loop);
3893
3894   free (defined);
3895   free (included);
3896
3897   return true;
3898
3899  error_return:
3900   if (defined != (boolean *) NULL)
3901     free (defined);
3902   if (included != (boolean *) NULL)
3903     free (included);
3904   return false;
3905 }
3906
3907 /* Record a new dynamic symbol.  We record the dynamic symbols as we
3908    read the input files, since we need to have a list of all of them
3909    before we can determine the final sizes of the output sections.
3910    Note that we may actually call this function even though we are not
3911    going to output any dynamic symbols; in some cases we know that a
3912    symbol should be in the dynamic symbol table, but only if there is
3913    one.  */
3914
3915 boolean
3916 elf_link_record_dynamic_symbol (info, h)
3917      struct bfd_link_info *info;
3918      struct elf_link_hash_entry *h;
3919 {
3920   if (h->dynindx == -1)
3921     {
3922       struct bfd_strtab_hash *dynstr;
3923
3924       h->dynindx = elf_hash_table (info)->dynsymcount;
3925       ++elf_hash_table (info)->dynsymcount;
3926
3927       dynstr = elf_hash_table (info)->dynstr;
3928       if (dynstr == NULL)
3929         {
3930           /* Create a strtab to hold the dynamic symbol names.  */
3931           elf_hash_table (info)->dynstr = dynstr = elf_stringtab_init ();
3932           if (dynstr == NULL)
3933             return false;
3934         }
3935
3936       h->dynstr_index = ((unsigned long)
3937                          _bfd_stringtab_add (dynstr, h->root.root.string,
3938                                              true, false));
3939       if (h->dynstr_index == (unsigned long) -1)
3940         return false;
3941     }
3942
3943   return true;
3944 }
3945
3946 /* Add symbols from an ELF object file to the linker hash table.  */
3947
3948 static boolean
3949 elf_link_add_object_symbols (abfd, info)
3950      bfd *abfd;
3951      struct bfd_link_info *info;
3952 {
3953   boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
3954                                       const Elf_Internal_Sym *,
3955                                       const char **, flagword *,
3956                                       asection **, bfd_vma *));
3957   boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
3958                                    asection *, const Elf_Internal_Rela *));
3959   boolean collect;
3960   Elf_Internal_Shdr *hdr;
3961   size_t symcount;
3962   size_t extsymcount;
3963   size_t extsymoff;
3964   Elf_External_Sym *buf = NULL;
3965   struct elf_link_hash_entry **sym_hash;
3966   boolean dynamic;
3967   Elf_External_Dyn *dynbuf = NULL;
3968   struct elf_link_hash_entry *weaks;
3969   Elf_External_Sym *esym;
3970   Elf_External_Sym *esymend;
3971
3972   add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
3973   collect = get_elf_backend_data (abfd)->collect;
3974
3975   /* A stripped shared library might only have a dynamic symbol table,
3976      not a regular symbol table.  In that case we can still go ahead
3977      and link using the dynamic symbol table.  */
3978   if (elf_onesymtab (abfd) == 0
3979       && elf_dynsymtab (abfd) != 0)
3980     {
3981       elf_onesymtab (abfd) = elf_dynsymtab (abfd);
3982       elf_tdata (abfd)->symtab_hdr = elf_tdata (abfd)->dynsymtab_hdr;
3983     }
3984
3985   hdr = &elf_tdata (abfd)->symtab_hdr;
3986   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
3987
3988   /* The sh_info field of the symtab header tells us where the
3989      external symbols start.  We don't care about the local symbols at
3990      this point.  */
3991   if (elf_bad_symtab (abfd))
3992     {
3993       extsymcount = symcount;
3994       extsymoff = 0;
3995     }
3996   else
3997     {
3998       extsymcount = symcount - hdr->sh_info;
3999       extsymoff = hdr->sh_info;
4000     }
4001
4002   buf = (Elf_External_Sym *) malloc (extsymcount * sizeof (Elf_External_Sym));
4003   if (buf == NULL && extsymcount != 0)
4004     {
4005       bfd_set_error (bfd_error_no_memory);
4006       goto error_return;
4007     }
4008
4009   /* We store a pointer to the hash table entry for each external
4010      symbol.  */
4011   sym_hash = ((struct elf_link_hash_entry **)
4012               bfd_alloc (abfd,
4013                          extsymcount * sizeof (struct elf_link_hash_entry *)));
4014   if (sym_hash == NULL)
4015     {
4016       bfd_set_error (bfd_error_no_memory);
4017       goto error_return;
4018     }
4019   elf_sym_hashes (abfd) = sym_hash;
4020
4021   if (elf_elfheader (abfd)->e_type != ET_DYN)
4022     {
4023       dynamic = false;
4024
4025       /* If we are creating a shared library, create all the dynamic
4026          sections immediately.  We need to attach them to something,
4027          so we attach them to this BFD, provided it is the right
4028          format.  FIXME: If there are no input BFD's of the same
4029          format as the output, we can't make a shared library.  */
4030       if (info->shared
4031           && ! elf_hash_table (info)->dynamic_sections_created
4032           && abfd->xvec == info->hash->creator)
4033         {
4034           if (! elf_link_create_dynamic_sections (abfd, info))
4035             goto error_return;
4036         }
4037     }
4038   else
4039     {
4040       asection *s;
4041       const char *name;
4042       bfd_size_type strindex;
4043
4044       dynamic = true;
4045
4046       /* You can't use -r against a dynamic object.  Also, there's no
4047          hope of using a dynamic object which does not exactly match
4048          the format of the output file.  */
4049       if (info->relocateable
4050           || info->hash->creator != abfd->xvec)
4051         {
4052           bfd_set_error (bfd_error_invalid_operation);
4053           goto error_return;
4054         }
4055
4056       /* Find the name to use in a DT_NEEDED entry that refers to this
4057          object.  If the object has a DT_SONAME entry, we use it.
4058          Otherwise, if the generic linker stuck something in
4059          elf_dt_needed_name, we use that.  Otherwise, we just use the
4060          file name.  */
4061       name = bfd_get_filename (abfd);
4062       if (elf_dt_needed_name (abfd) != NULL)
4063         name = elf_dt_needed_name (abfd);
4064       s = bfd_get_section_by_name (abfd, ".dynamic");
4065       if (s != NULL)
4066         {
4067           Elf_External_Dyn *extdyn;
4068           Elf_External_Dyn *extdynend;
4069
4070           dynbuf = (Elf_External_Dyn *) malloc (s->_raw_size);
4071           if (dynbuf == NULL)
4072             {
4073               bfd_set_error (bfd_error_no_memory);
4074               goto error_return;
4075             }
4076
4077           if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
4078                                           (file_ptr) 0, s->_raw_size))
4079             goto error_return;
4080
4081           extdyn = dynbuf;
4082           extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
4083           for (; extdyn < extdynend; extdyn++)
4084             {
4085               Elf_Internal_Dyn dyn;
4086
4087               elf_swap_dyn_in (abfd, extdyn, &dyn);
4088               if (dyn.d_tag == DT_SONAME)
4089                 {
4090                   int elfsec;
4091                   unsigned long link;
4092
4093                   elfsec = elf_section_from_bfd_section (abfd, s);
4094                   if (elfsec == -1)
4095                     goto error_return;
4096                   link = elf_elfsections (abfd)[elfsec]->sh_link;
4097                   name = elf_string_from_elf_section (abfd, link,
4098                                                       dyn.d_un.d_val);
4099                   if (name == NULL)
4100                     goto error_return;
4101
4102                   break;
4103                 }
4104             }
4105
4106           free (dynbuf);
4107           dynbuf = NULL;
4108         }
4109
4110       /* We do not want to include any of the sections in a dynamic
4111          object in the output file.  We hack by simply clobbering the
4112          list of sections in the BFD.  This could be handled more
4113          cleanly by, say, a new section flag; the existing
4114          SEC_NEVER_LOAD flag is not the one we want, because that one
4115          still implies that the section takes up space in the output
4116          file.  */
4117       abfd->sections = NULL;
4118
4119       /* If this is the first dynamic object found in the link, create
4120          the special sections required for dynamic linking.  */
4121       if (! elf_hash_table (info)->dynamic_sections_created)
4122         {
4123           if (! elf_link_create_dynamic_sections (abfd, info))
4124             goto error_return;
4125         }
4126
4127       /* Add a DT_NEEDED entry for this dynamic object.  */
4128       strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
4129                                      true, false);
4130       if (strindex == (bfd_size_type) -1)
4131         goto error_return;
4132       if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
4133         goto error_return;
4134     }
4135
4136   if (bfd_seek (abfd,
4137                 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
4138                 SEEK_SET) != 0
4139       || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
4140           != extsymcount * sizeof (Elf_External_Sym)))
4141     goto error_return;
4142
4143   weaks = NULL;
4144
4145   esymend = buf + extsymcount;
4146   for (esym = buf; esym < esymend; esym++, sym_hash++)
4147     {
4148       Elf_Internal_Sym sym;
4149       int bind;
4150       bfd_vma value;
4151       asection *sec;
4152       flagword flags;
4153       const char *name;
4154       struct elf_link_hash_entry *h = NULL;
4155       boolean definition;
4156
4157       elf_swap_symbol_in (abfd, esym, &sym);
4158
4159       flags = BSF_NO_FLAGS;
4160       sec = NULL;
4161       value = sym.st_value;
4162       *sym_hash = NULL;
4163
4164       bind = ELF_ST_BIND (sym.st_info);
4165       if (bind == STB_LOCAL)
4166         {
4167           /* This should be impossible, since ELF requires that all
4168              global symbols follow all local symbols, and that sh_info
4169              point to the first global symbol.  Unfortunatealy, Irix 5
4170              screws this up.  */
4171           continue;
4172         }
4173       else if (bind == STB_GLOBAL)
4174         flags = BSF_GLOBAL;
4175       else if (bind == STB_WEAK)
4176         flags = BSF_WEAK;
4177       else
4178         {
4179           /* Leave it up to the processor backend.  */
4180         }
4181
4182       if (sym.st_shndx == SHN_UNDEF)
4183         sec = bfd_und_section_ptr;
4184       else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
4185         {
4186           sec = section_from_elf_index (abfd, sym.st_shndx);
4187           if (sec != NULL)
4188             value -= sec->vma;
4189           else
4190             sec = bfd_abs_section_ptr;
4191         }
4192       else if (sym.st_shndx == SHN_ABS)
4193         sec = bfd_abs_section_ptr;
4194       else if (sym.st_shndx == SHN_COMMON)
4195         {
4196           sec = bfd_com_section_ptr;
4197           /* What ELF calls the size we call the value.  What ELF
4198              calls the value we call the alignment.  */
4199           value = sym.st_size;
4200         }
4201       else
4202         {
4203           /* Leave it up to the processor backend.  */
4204         }
4205
4206       name = elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
4207       if (name == (const char *) NULL)
4208         goto error_return;
4209
4210       if (add_symbol_hook)
4211         {
4212           if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
4213                                     &value))
4214             goto error_return;
4215
4216           /* The hook function sets the name to NULL if this symbol
4217              should be skipped for some reason.  */
4218           if (name == (const char *) NULL)
4219             continue;
4220         }
4221
4222       /* Sanity check that all possibilities were handled.  */
4223       if (flags == BSF_NO_FLAGS || sec == (asection *) NULL)
4224         {
4225           bfd_set_error (bfd_error_bad_value);
4226           goto error_return;
4227         }
4228
4229       if (bfd_is_und_section (sec)
4230           || bfd_is_com_section (sec))
4231         definition = false;
4232       else
4233         definition = true;
4234
4235       if (info->hash->creator->flavour == bfd_target_elf_flavour)
4236         {
4237           /* We need to look up the symbol now in order to get some of
4238              the dynamic object handling right.  We pass the hash
4239              table entry in to _bfd_generic_link_add_one_symbol so
4240              that it does not have to look it up again.  */
4241           h = elf_link_hash_lookup (elf_hash_table (info), name,
4242                                     true, false, false);
4243           if (h == NULL)
4244             goto error_return;
4245           *sym_hash = h;
4246
4247           /* If we are looking at a dynamic object, and this is a
4248              definition, we need to see if it has already been defined
4249              by some other object.  If it has, we want to use the
4250              existing definition, and we do not want to report a
4251              multiple symbol definition error; we do this by
4252              clobbering sec to be bfd_und_section_ptr.  */
4253           if (dynamic && definition)
4254             {
4255               if (h->root.type == bfd_link_hash_defined)
4256                 sec = bfd_und_section_ptr;
4257             }
4258
4259           /* Similarly, if we are not looking at a dynamic object, and
4260              we have a definition, we want to override any definition
4261              we may have from a dynamic object.  Symbols from regular
4262              files always take precedence over symbols from dynamic
4263              objects, even if they are defined after the dynamic
4264              object in the link.  */
4265           if (! dynamic
4266               && definition
4267               && h->root.type == bfd_link_hash_defined
4268               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4269               && (bfd_get_flavour (h->root.u.def.section->owner)
4270                   == bfd_target_elf_flavour)
4271               && (elf_elfheader (h->root.u.def.section->owner)->e_type
4272                   == ET_DYN))
4273             {
4274               /* Change the hash table entry to undefined, and let
4275                  _bfd_generic_link_add_one_symbol do the right thing
4276                  with the new definition.  */
4277               h->root.type = bfd_link_hash_undefined;
4278               h->root.u.undef.abfd = h->root.u.def.section->owner;
4279               h->elf_link_hash_flags &=~ ELF_LINK_HASH_DEFINED_WEAK;
4280             }
4281
4282           /* If this is a weak definition which we are going to use,
4283              and the symbol is currently undefined, record that the
4284              definition is weak.  */
4285           if (definition
4286               && (flags & BSF_WEAK) != 0
4287               && ! bfd_is_und_section (sec)
4288               && (h->root.type == bfd_link_hash_new
4289                   || h->root.type == bfd_link_hash_undefined
4290                   || h->root.type == bfd_link_hash_weak))
4291             h->elf_link_hash_flags |= ELF_LINK_HASH_DEFINED_WEAK;
4292         }
4293
4294       if (! (_bfd_generic_link_add_one_symbol
4295              (info, abfd, name, flags, sec, value, (const char *) NULL,
4296               false, collect, (struct bfd_link_hash_entry **) sym_hash)))
4297         goto error_return;
4298
4299       if (dynamic
4300           && definition
4301           && (flags & BSF_WEAK) != 0
4302           && ELF_ST_TYPE (sym.st_info) != STT_FUNC
4303           && (*sym_hash)->weakdef == NULL)
4304         {
4305           /* Keep a list of all weak defined non function symbols from
4306              a dynamic object, using the weakdef field.  Later in this
4307              function we will set the weakdef field to the correct
4308              value.  We only put non-function symbols from dynamic
4309              objects on this list, because that happens to be the only
4310              time we need to know the normal symbol corresponding to a
4311              weak symbol, and the information is time consuming to
4312              figure out.  If the weakdef field is not already NULL,
4313              then this symbol was already defined by some previous
4314              dynamic object, and we will be using that previous
4315              definition anyhow.  */
4316
4317           (*sym_hash)->weakdef = weaks;
4318           weaks = *sym_hash;
4319         }
4320
4321       /* Get the alignment of a common symbol.  */
4322       if (sym.st_shndx == SHN_COMMON
4323           && h->root.type == bfd_link_hash_common)
4324         h->root.u.c.alignment_power = bfd_log2 (sym.st_value);
4325
4326       if (info->hash->creator->flavour == bfd_target_elf_flavour)
4327         {
4328           int old_flags;
4329           boolean dynsym;
4330           int new_flag;
4331
4332           /* Remember the symbol size and type.  */
4333           if (sym.st_size != 0)
4334             {
4335               /* FIXME: We should probably somehow give a warning if
4336                  the symbol size changes.  */
4337               h->size = sym.st_size;
4338             }
4339           if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE)
4340             {
4341               /* FIXME: We should probably somehow give a warning if
4342                  the symbol type changes.  */
4343               h->type = ELF_ST_TYPE (sym.st_info);
4344             }
4345
4346           /* Set a flag in the hash table entry indicating the type of
4347              reference or definition we just found.  Keep a count of
4348              the number of dynamic symbols we find.  A dynamic symbol
4349              is one which is referenced or defined by both a regular
4350              object and a shared object, or one which is referenced or
4351              defined by more than one shared object.  */
4352           old_flags = h->elf_link_hash_flags;
4353           dynsym = false;
4354           if (! dynamic)
4355             {
4356               if (! definition)
4357                 new_flag = ELF_LINK_HASH_REF_REGULAR;
4358               else
4359                 new_flag = ELF_LINK_HASH_DEF_REGULAR;
4360               if (info->shared
4361                   || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
4362                                    | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
4363                 dynsym = true;
4364             }
4365           else
4366             {
4367               if (! definition)
4368                 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
4369               else
4370                 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
4371               if ((old_flags & new_flag) != 0
4372                   || (old_flags & (ELF_LINK_HASH_DEF_REGULAR
4373                                    | ELF_LINK_HASH_REF_REGULAR)) != 0)
4374                 dynsym = true;
4375             }
4376
4377           h->elf_link_hash_flags |= new_flag;
4378           if (dynsym && h->dynindx == -1)
4379             {
4380               if (! elf_link_record_dynamic_symbol (info, h))
4381                 goto error_return;
4382             }
4383         }
4384     }
4385
4386   /* Now set the weakdefs field correctly for all the weak defined
4387      symbols we found.  The only way to do this is to search all the
4388      symbols.  Since we only need the information for non functions in
4389      dynamic objects, that's the only time we actually put anything on
4390      the list WEAKS.  We need this information so that if a regular
4391      object refers to a symbol defined weakly in a dynamic object, the
4392      real symbol in the dynamic object is also put in the dynamic
4393      symbols; we also must arrange for both symbols to point to the
4394      same memory location.  We could handle the general case of symbol
4395      aliasing, but a general symbol alias can only be generated in
4396      assembler code, handling it correctly would be very time
4397      consuming, and other ELF linkers don't handle general aliasing
4398      either.  */
4399   while (weaks != NULL)
4400     {
4401       struct elf_link_hash_entry *hlook;
4402       asection *slook;
4403       bfd_vma vlook;
4404       struct elf_link_hash_entry **hpp;
4405       struct elf_link_hash_entry **hppend;
4406
4407       hlook = weaks;
4408       weaks = hlook->weakdef;
4409       hlook->weakdef = NULL;
4410
4411       BFD_ASSERT (hlook->root.type == bfd_link_hash_defined);
4412       slook = hlook->root.u.def.section;
4413       vlook = hlook->root.u.def.value;
4414
4415       hpp = elf_sym_hashes (abfd);
4416       hppend = hpp + extsymcount;
4417       for (; hpp < hppend; hpp++)
4418         {
4419           struct elf_link_hash_entry *h;
4420
4421           h = *hpp;
4422           if (h != hlook
4423               && h->root.type == bfd_link_hash_defined
4424               && h->root.u.def.section == slook
4425               && h->root.u.def.value == vlook)
4426             {
4427               hlook->weakdef = h;
4428
4429               /* If the weak definition is in the list of dynamic
4430                  symbols, make sure the real definition is put there
4431                  as well.  */
4432               if (hlook->dynindx != -1
4433                   && h->dynindx == -1)
4434                 {
4435                   if (! elf_link_record_dynamic_symbol (info, h))
4436                     goto error_return;
4437                 }
4438
4439               break;
4440             }
4441         }
4442     }
4443
4444   if (buf != NULL)
4445     {
4446       free (buf);
4447       buf = NULL;
4448     }
4449
4450   /* If this object is the same format as the output object, and it is
4451      not a shared library, then let the backend look through the
4452      relocs.
4453
4454      This is required to build global offset table entries and to
4455      arrange for dynamic relocs.  It is not required for the
4456      particular common case of linking non PIC code, even when linking
4457      against shared libraries, but unfortunately there is no way of
4458      knowing whether an object file has been compiled PIC or not.
4459      Looking through the relocs is not particularly time consuming.
4460      The problem is that we must either (1) keep the relocs in memory,
4461      which causes the linker to require additional runtime memory or
4462      (2) read the relocs twice from the input file, which wastes time.
4463      This would be a good case for using mmap.
4464
4465      I have no idea how to handle linking PIC code into a file of a
4466      different format.  It probably can't be done.  */
4467   check_relocs = get_elf_backend_data (abfd)->check_relocs;
4468   if (! dynamic
4469       && abfd->xvec == info->hash->creator
4470       && check_relocs != NULL)
4471     {
4472       asection *o;
4473
4474       for (o = abfd->sections; o != NULL; o = o->next)
4475         {
4476           Elf_Internal_Rela *internal_relocs;
4477           boolean ok;
4478
4479           if ((o->flags & SEC_RELOC) == 0
4480               || o->reloc_count == 0)
4481             continue;
4482
4483           /* I believe we can ignore the relocs for any section which
4484              does not form part of the final process image, such as a
4485              debugging section.  */
4486           if ((o->flags & SEC_ALLOC) == 0)
4487             continue;
4488
4489           internal_relocs = elf_link_read_relocs (abfd, o, (PTR) NULL,
4490                                                   (Elf_Internal_Rela *) NULL,
4491                                                   info->keep_memory);
4492           if (internal_relocs == NULL)
4493             goto error_return;
4494
4495           ok = (*check_relocs) (abfd, info, o, internal_relocs);
4496
4497           if (! info->keep_memory)
4498             free (internal_relocs);
4499
4500           if (! ok)
4501             goto error_return;
4502         }
4503     }
4504
4505   return true;
4506
4507  error_return:
4508   if (buf != NULL)
4509     free (buf);
4510   if (dynbuf != NULL)
4511     free (dynbuf);
4512   return false;
4513 }
4514
4515 /* Create some sections which will be filled in with dynamic linking
4516    information.  ABFD is an input file which requires dynamic sections
4517    to be created.  The dynamic sections take up virtual memory space
4518    when the final executable is run, so we need to create them before
4519    addresses are assigned to the output sections.  We work out the
4520    actual contents and size of these sections later.  */
4521
4522 boolean
4523 elf_link_create_dynamic_sections (abfd, info)
4524      bfd *abfd;
4525      struct bfd_link_info *info;
4526 {
4527   flagword flags;
4528   register asection *s;
4529   struct elf_link_hash_entry *h;
4530   struct elf_backend_data *bed;
4531
4532   if (elf_hash_table (info)->dynamic_sections_created)
4533     return true;
4534
4535   /* Make sure that all dynamic sections use the same input BFD.  */
4536   if (elf_hash_table (info)->dynobj == NULL)
4537     elf_hash_table (info)->dynobj = abfd;
4538   else
4539     abfd = elf_hash_table (info)->dynobj;
4540
4541   /* Note that we set the SEC_IN_MEMORY flag for all of these
4542      sections.  */
4543   flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
4544
4545   /* A dynamically linked executable has a .interp section, but a
4546      shared library does not.  */
4547   if (! info->shared)
4548     {
4549       s = bfd_make_section (abfd, ".interp");
4550       if (s == NULL
4551           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
4552         return false;
4553     }
4554
4555   s = bfd_make_section (abfd, ".dynsym");
4556   if (s == NULL
4557       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4558       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
4559     return false;
4560
4561   s = bfd_make_section (abfd, ".dynstr");
4562   if (s == NULL
4563       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
4564     return false;
4565
4566   /* Create a strtab to hold the dynamic symbol names.  */
4567   if (elf_hash_table (info)->dynstr == NULL)
4568     {
4569       elf_hash_table (info)->dynstr = elf_stringtab_init ();
4570       if (elf_hash_table (info)->dynstr == NULL)
4571         return false;
4572     }
4573
4574   s = bfd_make_section (abfd, ".dynamic");
4575   if (s == NULL
4576       || ! bfd_set_section_flags (abfd, s, flags)
4577       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
4578     return false;
4579
4580   /* The special symbol _DYNAMIC is always set to the start of the
4581      .dynamic section.  This call occurs before we have processed the
4582      symbols for any dynamic object, so we don't have to worry about
4583      overriding a dynamic definition.  We could set _DYNAMIC in a
4584      linker script, but we only want to define it if we are, in fact,
4585      creating a .dynamic section.  We don't want to define it if there
4586      is no .dynamic section, since on some ELF platforms the start up
4587      code examines it to decide how to initialize the process.  */
4588   h = NULL;
4589   if (! (_bfd_generic_link_add_one_symbol
4590          (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
4591           (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
4592           (struct bfd_link_hash_entry **) &h)))
4593     return false;
4594   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4595   h->type = STT_OBJECT;
4596
4597   if (info->shared
4598       && ! elf_link_record_dynamic_symbol (info, h))
4599     return false;
4600
4601   s = bfd_make_section (abfd, ".hash");
4602   if (s == NULL
4603       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4604       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
4605     return false;
4606
4607   /* Let the backend create the rest of the sections.  This lets the
4608      backend set the right flags.  The backend will normally create
4609      the .got and .plt sections.  */
4610   bed = get_elf_backend_data (abfd);
4611   if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
4612     return false;
4613
4614   elf_hash_table (info)->dynamic_sections_created = true;
4615
4616   return true;
4617 }
4618
4619 /* Add an entry to the .dynamic table.  */
4620
4621 boolean
4622 elf_add_dynamic_entry (info, tag, val)
4623      struct bfd_link_info *info;
4624      bfd_vma tag;
4625      bfd_vma val;
4626 {
4627   Elf_Internal_Dyn dyn;
4628   bfd *dynobj;
4629   asection *s;
4630   size_t newsize;
4631   bfd_byte *newcontents;
4632
4633   dynobj = elf_hash_table (info)->dynobj;
4634
4635   s = bfd_get_section_by_name (dynobj, ".dynamic");
4636   BFD_ASSERT (s != NULL);
4637
4638   newsize = s->_raw_size + sizeof (Elf_External_Dyn);
4639   if (s->contents == NULL)
4640     newcontents = (bfd_byte *) malloc (newsize);
4641   else
4642     newcontents = (bfd_byte *) realloc (s->contents, newsize);
4643   if (newcontents == NULL)
4644     {
4645       bfd_set_error (bfd_error_no_memory);
4646       return false;
4647     }
4648
4649   dyn.d_tag = tag;
4650   dyn.d_un.d_val = val;
4651   elf_swap_dyn_out (dynobj, &dyn,
4652                     (Elf_External_Dyn *) (newcontents + s->_raw_size));
4653
4654   s->_raw_size = newsize;
4655   s->contents = newcontents;
4656
4657   return true;
4658 }
4659
4660 /* Read and swap the relocs for a section.  They may have been cached.
4661    If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
4662    they are used as buffers to read into.  They are known to be large
4663    enough.  If the INTERNAL_RELOCS relocs argument is NULL, the return
4664    value is allocated using either malloc or bfd_alloc, according to
4665    the KEEP_MEMORY argument.  */
4666
4667 static Elf_Internal_Rela *
4668 elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
4669      bfd *abfd;
4670      asection *o;
4671      PTR external_relocs;
4672      Elf_Internal_Rela *internal_relocs;
4673      boolean keep_memory;
4674 {
4675   Elf_Internal_Shdr *rel_hdr;
4676   PTR alloc1 = NULL;
4677   Elf_Internal_Rela *alloc2 = NULL;
4678
4679   if (elf_section_data (o)->relocs != NULL)
4680     return elf_section_data (o)->relocs;
4681
4682   if (o->reloc_count == 0)
4683     return NULL;
4684
4685   rel_hdr = &elf_section_data (o)->rel_hdr;
4686
4687   if (internal_relocs == NULL)
4688     {
4689       size_t size;
4690
4691       size = o->reloc_count * sizeof (Elf_Internal_Rela);
4692       if (keep_memory)
4693         internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
4694       else
4695         internal_relocs = alloc2 = (Elf_Internal_Rela *) malloc (size);
4696       if (internal_relocs == NULL)
4697         {
4698           bfd_set_error (bfd_error_no_memory);
4699           goto error_return;
4700         }
4701     }
4702
4703   if (external_relocs == NULL)
4704     {
4705       alloc1 = (PTR) malloc (rel_hdr->sh_size);
4706       if (alloc1 == NULL)
4707         {
4708           bfd_set_error (bfd_error_no_memory);
4709           goto error_return;
4710         }
4711       external_relocs = alloc1;
4712     }
4713
4714   if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
4715       || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
4716           != rel_hdr->sh_size))
4717     goto error_return;
4718
4719   /* Swap in the relocs.  For convenience, we always produce an
4720      Elf_Internal_Rela array; if the relocs are Rel, we set the addend
4721      to 0.  */
4722   if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
4723     {
4724       Elf_External_Rel *erel;
4725       Elf_External_Rel *erelend;
4726       Elf_Internal_Rela *irela;
4727
4728       erel = (Elf_External_Rel *) external_relocs;
4729       erelend = erel + o->reloc_count;
4730       irela = internal_relocs;
4731       for (; erel < erelend; erel++, irela++)
4732         {
4733           Elf_Internal_Rel irel;
4734
4735           elf_swap_reloc_in (abfd, erel, &irel);
4736           irela->r_offset = irel.r_offset;
4737           irela->r_info = irel.r_info;
4738           irela->r_addend = 0;
4739         }
4740     }
4741   else
4742     {
4743       Elf_External_Rela *erela;
4744       Elf_External_Rela *erelaend;
4745       Elf_Internal_Rela *irela;
4746
4747       BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
4748
4749       erela = (Elf_External_Rela *) external_relocs;
4750       erelaend = erela + o->reloc_count;
4751       irela = internal_relocs;
4752       for (; erela < erelaend; erela++, irela++)
4753         elf_swap_reloca_in (abfd, erela, irela);
4754     }
4755
4756   /* Cache the results for next time, if we can.  */
4757   if (keep_memory)
4758     elf_section_data (o)->relocs = internal_relocs;
4759
4760   if (alloc1 != NULL)
4761     free (alloc1);
4762
4763   /* Don't free alloc2, since if it was allocated we are passing it
4764      back (under the name of internal_relocs).  */
4765
4766   return internal_relocs;
4767
4768  error_return:
4769   if (alloc1 != NULL)
4770     free (alloc1);
4771   if (alloc2 != NULL)
4772     free (alloc2);
4773   return NULL;
4774 }
4775
4776 /* Record an assignment to a symbol made by a linker script.  We need
4777    this in case some dynamic object refers to this symbol.  */
4778
4779 /*ARGSUSED*/
4780 boolean
4781 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name)
4782      bfd *output_bfd;
4783      struct bfd_link_info *info;
4784      const char *name;
4785 {
4786   struct elf_link_hash_entry *h;
4787
4788   h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
4789   if (h == NULL)
4790     return false;
4791
4792   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4793   h->type = STT_OBJECT;
4794
4795   if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
4796                                   | ELF_LINK_HASH_REF_DYNAMIC)) != 0
4797        || info->shared)
4798       && h->dynindx == -1)
4799     {
4800       if (! elf_link_record_dynamic_symbol (info, h))
4801         return false;
4802
4803       /* If this is a weak defined symbol, and we know a corresponding
4804          real symbol from the same dynamic object, make sure the real
4805          symbol is also made into a dynamic symbol.  */
4806       if (h->weakdef != NULL
4807           && h->weakdef->dynindx == -1)
4808         {
4809           if (! elf_link_record_dynamic_symbol (info, h->weakdef))
4810             return false;
4811         }
4812     }
4813
4814   return true;
4815 }
4816
4817 /* Array used to determine the number of hash table buckets to use
4818    based on the number of symbols there are.  If there are fewer than
4819    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
4820    fewer than 37 we use 17 buckets, and so forth.  We never use more
4821    than 521 buckets.  */
4822
4823 static const size_t elf_buckets[] =
4824 {
4825   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
4826 };
4827
4828 /* Set up the sizes and contents of the ELF dynamic sections.  This is
4829    called by the ELF linker emulation before_allocation routine.  We
4830    must set the sizes of the sections before the linker sets the
4831    addresses of the various sections.  */
4832
4833 boolean
4834 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
4835                                      export_dynamic, info, sinterpptr)
4836      bfd *output_bfd;
4837      const char *soname;
4838      const char *rpath;
4839      boolean export_dynamic;
4840      struct bfd_link_info *info;
4841      asection **sinterpptr;
4842 {
4843   bfd *dynobj;
4844   asection *s;
4845   Elf_Internal_Sym isym;
4846   size_t i;
4847   size_t bucketcount;
4848   struct elf_backend_data *bed;
4849
4850   *sinterpptr = NULL;
4851
4852   dynobj = elf_hash_table (info)->dynobj;
4853
4854   /* If there were no dynamic objects in the link, there is nothing to
4855      do here.  */
4856   if (dynobj == NULL)
4857     return true;
4858
4859   /* If we are supposed to export all symbols into the dynamic symbol
4860      table (this is not the normal case), then do so.  */
4861   if (export_dynamic)
4862     elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
4863                             (PTR) info);
4864
4865   if (elf_hash_table (info)->dynamic_sections_created)
4866     {
4867       bfd_size_type strsize;
4868
4869       *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
4870       BFD_ASSERT (*sinterpptr != NULL || info->shared);
4871
4872       if (soname != NULL)
4873         {
4874           bfd_size_type indx;
4875
4876           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, soname,
4877                                      true, true);
4878           if (indx == (bfd_size_type) -1
4879               || ! elf_add_dynamic_entry (info, DT_SONAME, indx))
4880             return false;
4881         }
4882
4883       if (rpath != NULL)
4884         {
4885           bfd_size_type indx;
4886
4887           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
4888                                      true, true);
4889           if (indx == (bfd_size_type) -1
4890               || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
4891             return false;
4892         }
4893
4894       /* Find all symbols which were defined in a dynamic object and make
4895          the backend pick a reasonable value for them.  */
4896       elf_link_hash_traverse (elf_hash_table (info),
4897                               elf_adjust_dynamic_symbol,
4898                               (PTR) info);
4899
4900       /* Add some entries to the .dynamic section.  We fill in some of the
4901          values later, in elf_bfd_final_link, but we must add the entries
4902          now so that we know the final size of the .dynamic section.  */
4903       if (elf_link_hash_lookup (elf_hash_table (info), "_init", false,
4904                                 false, false) != NULL)
4905         {
4906           if (! elf_add_dynamic_entry (info, DT_INIT, 0))
4907             return false;
4908         }
4909       if (elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
4910                                 false, false) != NULL)
4911         {
4912           if (! elf_add_dynamic_entry (info, DT_FINI, 0))
4913             return false;
4914         }
4915       strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
4916       if (! elf_add_dynamic_entry (info, DT_HASH, 0)
4917           || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
4918           || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
4919           || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
4920           || ! elf_add_dynamic_entry (info, DT_SYMENT,
4921                                       sizeof (Elf_External_Sym)))
4922         return false;
4923     }
4924
4925   /* The backend must work out the sizes of all the other dynamic
4926      sections.  */
4927   bed = get_elf_backend_data (output_bfd);
4928   if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
4929     return false;
4930
4931   if (elf_hash_table (info)->dynamic_sections_created)
4932     {
4933       size_t dynsymcount;
4934
4935       /* Set the size of the .dynsym and .hash sections.  We counted
4936          the number of dynamic symbols in elf_link_add_object_symbols.
4937          We will build the contents of .dynsym and .hash when we build
4938          the final symbol table, because until then we do not know the
4939          correct value to give the symbols.  We built the .dynstr
4940          section as we went along in elf_link_add_object_symbols.  */
4941       dynsymcount = elf_hash_table (info)->dynsymcount;
4942       s = bfd_get_section_by_name (dynobj, ".dynsym");
4943       BFD_ASSERT (s != NULL);
4944       s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
4945       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
4946       if (s->contents == NULL && s->_raw_size != 0)
4947         {
4948           bfd_set_error (bfd_error_no_memory);
4949           return false;
4950         }
4951
4952       /* The first entry in .dynsym is a dummy symbol.  */
4953       isym.st_value = 0;
4954       isym.st_size = 0;
4955       isym.st_name = 0;
4956       isym.st_info = 0;
4957       isym.st_other = 0;
4958       isym.st_shndx = 0;
4959       elf_swap_symbol_out (output_bfd, &isym,
4960                            (Elf_External_Sym *) s->contents);
4961
4962       for (i = 0; elf_buckets[i] != 0; i++)
4963         {
4964           bucketcount = elf_buckets[i];
4965           if (dynsymcount < elf_buckets[i + 1])
4966             break;
4967         }
4968
4969       s = bfd_get_section_by_name (dynobj, ".hash");
4970       BFD_ASSERT (s != NULL);
4971       s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
4972       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
4973       if (s->contents == NULL)
4974         {
4975           bfd_set_error (bfd_error_no_memory);
4976           return false;
4977         }
4978       memset (s->contents, 0, s->_raw_size);
4979
4980       put_word (output_bfd, bucketcount, s->contents);
4981       put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
4982
4983       elf_hash_table (info)->bucketcount = bucketcount;
4984
4985       s = bfd_get_section_by_name (dynobj, ".dynstr");
4986       BFD_ASSERT (s != NULL);
4987       s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
4988
4989       if (! elf_add_dynamic_entry (info, DT_NULL, 0))
4990         return false;
4991     }
4992
4993   return true;
4994 }
4995
4996 /* This routine is used to export all defined symbols into the dynamic
4997    symbol table.  It is called via elf_link_hash_traverse.  */
4998
4999 static boolean
5000 elf_export_symbol (h, data)
5001      struct elf_link_hash_entry *h;
5002      PTR data;
5003 {
5004   struct bfd_link_info *info = (struct bfd_link_info *) data;
5005
5006   if (h->dynindx == -1
5007       && (h->elf_link_hash_flags
5008           & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
5009     {
5010       if (! elf_link_record_dynamic_symbol (info, h))
5011         {
5012           /* FIXME: No way to report error.  */
5013           abort ();
5014         }
5015     }
5016
5017   return true;
5018 }
5019
5020 /* Make the backend pick a good value for a dynamic symbol.  This is
5021    called via elf_link_hash_traverse, and also calls itself
5022    recursively.  */
5023
5024 static boolean
5025 elf_adjust_dynamic_symbol (h, data)
5026      struct elf_link_hash_entry *h;
5027      PTR data;
5028 {
5029   struct bfd_link_info *info = (struct bfd_link_info *) data;
5030   bfd *dynobj;
5031   struct elf_backend_data *bed;
5032
5033   /* If this symbol does not require a PLT entry, and it is not
5034      defined by a dynamic object, or is not referenced by a regular
5035      object, ignore it.  FIXME: Do we need to worry about symbols
5036      which are defined by one dynamic object and referenced by another
5037      one?  */
5038   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
5039       && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
5040           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
5041           || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0))
5042     return true;
5043
5044   /* If we've already adjusted this symbol, don't do it again.  This
5045      can happen via a recursive call.  */
5046   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
5047     return true;
5048
5049   /* Don't look at this symbol again.  Note that we must set this
5050      after checking the above conditions, because we may look at a
5051      symbol once, decide not to do anything, and then get called
5052      recursively later after REF_REGULAR is set below.  */
5053   h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
5054
5055   /* If this is a weak definition, and we know a real definition, and
5056      the real symbol is not itself defined by a regular object file,
5057      then get a good value for the real definition.  We handle the
5058      real symbol first, for the convenience of the backend routine.
5059
5060      Note that there is a confusing case here.  If the real definition
5061      is defined by a regular object file, we don't get the real symbol
5062      from the dynamic object, but we do get the weak symbol.  If the
5063      processor backend uses a COPY reloc, then if some routine in the
5064      dynamic object changes the real symbol, we will not see that
5065      change in the corresponding weak symbol.  This is the way other
5066      ELF linkers work as well, and seems to be a result of the shared
5067      library model.
5068
5069      I will clarify this issue.  Most SVR4 shared libraries define the
5070      variable _timezone and define timezone as a weak synonym.  The
5071      tzset call changes _timezone.  If you write
5072        extern int timezone;
5073        int _timezone = 5;
5074        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
5075      you might expect that, since timezone is a synonym for _timezone,
5076      the same number will print both times.  However, if the processor
5077      backend uses a COPY reloc, then actually timezone will be copied
5078      into your process image, and, since you define _timezone
5079      yourself, _timezone will not.  Thus timezone and _timezone will
5080      wind up at different memory locations.  The tzset call will set
5081      _timezone, leaving timezone unchanged.  */
5082
5083   if (h->weakdef != NULL)
5084     {
5085       struct elf_link_hash_entry *weakdef;
5086
5087       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5088       weakdef = h->weakdef;
5089       BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined);
5090       BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
5091       if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
5092         {
5093           /* This symbol is defined by a regular object file, so we
5094              will not do anything special.  Clear weakdef for the
5095              convenience of the processor backend.  */
5096           h->weakdef = NULL;
5097         }
5098       else
5099         {
5100           /* There is an implicit reference by a regular object file
5101              via the weak symbol.  */
5102           weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
5103           if (! elf_adjust_dynamic_symbol (weakdef, (PTR) info))
5104             return false;
5105         }
5106     }
5107
5108   dynobj = elf_hash_table (info)->dynobj;
5109   bed = get_elf_backend_data (dynobj);
5110   if (! (*bed->elf_backend_adjust_dynamic_symbol) (info, h))
5111     {
5112       /* FIXME: No way to return error.  */
5113       abort ();
5114     }
5115
5116   return true;
5117 }
5118 \f
5119 /* Final phase of ELF linker.  */
5120
5121 /* A structure we use to avoid passing large numbers of arguments.  */
5122
5123 struct elf_final_link_info
5124 {
5125   /* General link information.  */
5126   struct bfd_link_info *info;
5127   /* Output BFD.  */
5128   bfd *output_bfd;
5129   /* Symbol string table.  */
5130   struct bfd_strtab_hash *symstrtab;
5131   /* .dynsym section.  */
5132   asection *dynsym_sec;
5133   /* .hash section.  */
5134   asection *hash_sec;
5135   /* Buffer large enough to hold contents of any section.  */
5136   bfd_byte *contents;
5137   /* Buffer large enough to hold external relocs of any section.  */
5138   PTR external_relocs;
5139   /* Buffer large enough to hold internal relocs of any section.  */
5140   Elf_Internal_Rela *internal_relocs;
5141   /* Buffer large enough to hold external local symbols of any input
5142      BFD.  */
5143   Elf_External_Sym *external_syms;
5144   /* Buffer large enough to hold internal local symbols of any input
5145      BFD.  */
5146   Elf_Internal_Sym *internal_syms;
5147   /* Array large enough to hold a symbol index for each local symbol
5148      of any input BFD.  */
5149   long *indices;
5150   /* Array large enough to hold a section pointer for each local
5151      symbol of any input BFD.  */
5152   asection **sections;
5153   /* Buffer to hold swapped out symbols.  */
5154   Elf_External_Sym *symbuf;
5155   /* Number of swapped out symbols in buffer.  */
5156   size_t symbuf_count;
5157   /* Number of symbols which fit in symbuf.  */
5158   size_t symbuf_size;
5159 };
5160
5161 static boolean elf_link_output_sym
5162   PARAMS ((struct elf_final_link_info *, const char *,
5163            Elf_Internal_Sym *, asection *));
5164 static boolean elf_link_flush_output_syms
5165   PARAMS ((struct elf_final_link_info *));
5166 static boolean elf_link_output_extsym
5167   PARAMS ((struct elf_link_hash_entry *, PTR));
5168 static boolean elf_link_input_bfd
5169   PARAMS ((struct elf_final_link_info *, bfd *));
5170 static boolean elf_reloc_link_order
5171   PARAMS ((bfd *, struct bfd_link_info *, asection *,
5172            struct bfd_link_order *));
5173
5174 /* Do the final step of an ELF link.  */
5175
5176 boolean
5177 elf_bfd_final_link (abfd, info)
5178      bfd *abfd;
5179      struct bfd_link_info *info;
5180 {
5181   boolean dynamic;
5182   bfd *dynobj;
5183   struct elf_final_link_info finfo;
5184   register asection *o;
5185   register struct bfd_link_order *p;
5186   register bfd *sub;
5187   size_t max_contents_size;
5188   size_t max_external_reloc_size;
5189   size_t max_internal_reloc_count;
5190   size_t max_sym_count;
5191   file_ptr off;
5192   Elf_Internal_Sym elfsym;
5193   unsigned int i;
5194   Elf_Internal_Shdr *symtab_hdr;
5195   Elf_Internal_Shdr *symstrtab_hdr;
5196   struct elf_backend_data *bed = get_elf_backend_data (abfd);
5197
5198   if (info->shared)
5199     abfd->flags |= DYNAMIC;
5200
5201   dynamic = elf_hash_table (info)->dynamic_sections_created;
5202   dynobj = elf_hash_table (info)->dynobj;
5203
5204   finfo.info = info;
5205   finfo.output_bfd = abfd;
5206   finfo.symstrtab = elf_stringtab_init ();
5207   if (finfo.symstrtab == NULL)
5208     return false;
5209   if (! dynamic)
5210     {
5211       finfo.dynsym_sec = NULL;
5212       finfo.hash_sec = NULL;
5213     }
5214   else
5215     {
5216       finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
5217       finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
5218       if (finfo.dynsym_sec == NULL
5219           || finfo.hash_sec == NULL)
5220         abort ();
5221     }
5222   finfo.contents = NULL;
5223   finfo.external_relocs = NULL;
5224   finfo.internal_relocs = NULL;
5225   finfo.external_syms = NULL;
5226   finfo.internal_syms = NULL;
5227   finfo.indices = NULL;
5228   finfo.sections = NULL;
5229   finfo.symbuf = NULL;
5230   finfo.symbuf_count = 0;
5231
5232   /* Count up the number of relocations we will output for each output
5233      section, so that we know the sizes of the reloc sections.  We
5234      also figure out some maximum sizes.  */
5235   max_contents_size = 0;
5236   max_external_reloc_size = 0;
5237   max_internal_reloc_count = 0;
5238   max_sym_count = 0;
5239   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5240     {
5241       o->reloc_count = 0;
5242
5243       for (p = o->link_order_head; p != NULL; p = p->next)
5244         {
5245           if (p->type == bfd_section_reloc_link_order
5246               || p->type == bfd_symbol_reloc_link_order)
5247             ++o->reloc_count;
5248           else if (p->type == bfd_indirect_link_order)
5249             {
5250               asection *sec;
5251
5252               sec = p->u.indirect.section;
5253
5254               if (info->relocateable)
5255                 o->reloc_count += sec->reloc_count;
5256
5257               if (sec->_raw_size > max_contents_size)
5258                 max_contents_size = sec->_raw_size;
5259               if (sec->_cooked_size > max_contents_size)
5260                 max_contents_size = sec->_cooked_size;
5261
5262               /* We are interested in just local symbols, not all
5263                  symbols.  */
5264               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour)
5265                 {
5266                   size_t sym_count;
5267
5268                   if (elf_bad_symtab (sec->owner))
5269                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
5270                                  / sizeof (Elf_External_Sym));
5271                   else
5272                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
5273
5274                   if (sym_count > max_sym_count)
5275                     max_sym_count = sym_count;
5276
5277                   if ((sec->flags & SEC_RELOC) != 0)
5278                     {
5279                       size_t ext_size;
5280
5281                       ext_size = elf_section_data (sec)->rel_hdr.sh_size;
5282                       if (ext_size > max_external_reloc_size)
5283                         max_external_reloc_size = ext_size;
5284                       if (sec->reloc_count > max_internal_reloc_count)
5285                         max_internal_reloc_count = sec->reloc_count;
5286                     }
5287                 }
5288             }
5289         }
5290
5291       if (o->reloc_count > 0)
5292         o->flags |= SEC_RELOC;
5293       else
5294         {
5295           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
5296              set it (this is probably a bug) and if it is set
5297              assign_section_numbers will create a reloc section.  */
5298           o->flags &=~ SEC_RELOC;
5299         }
5300
5301       /* If the SEC_ALLOC flag is not set, force the section VMA to
5302          zero.  This is done in elf_fake_sections as well, but forcing
5303          the VMA to 0 here will ensure that relocs against these
5304          sections are handled correctly.  */
5305       if ((o->flags & SEC_ALLOC) == 0)
5306         o->vma = 0;
5307     }
5308
5309   /* Figure out the file positions for everything but the symbol table
5310      and the relocs.  We set symcount to force assign_section_numbers
5311      to create a symbol table.  */
5312   abfd->symcount = info->strip == strip_all ? 0 : 1;
5313   BFD_ASSERT (! abfd->output_has_begun);
5314   if (! elf_compute_section_file_positions (abfd, info))
5315     goto error_return;
5316
5317   /* That created the reloc sections.  Set their sizes, and assign
5318      them file positions, and allocate some buffers.  */
5319   for (o = abfd->sections; o != NULL; o = o->next)
5320     {
5321       if ((o->flags & SEC_RELOC) != 0)
5322         {
5323           Elf_Internal_Shdr *rel_hdr;
5324           register struct elf_link_hash_entry **p, **pend;
5325
5326           rel_hdr = &elf_section_data (o)->rel_hdr;
5327
5328           rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
5329
5330           /* The contents field must last into write_object_contents,
5331              so we allocate it with bfd_alloc rather than malloc.  */
5332           rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
5333           if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
5334             {
5335               bfd_set_error (bfd_error_no_memory);
5336               goto error_return;
5337             }
5338
5339           p = ((struct elf_link_hash_entry **)
5340                malloc (o->reloc_count
5341                        * sizeof (struct elf_link_hash_entry *)));
5342           if (p == NULL && o->reloc_count != 0)
5343             {
5344               bfd_set_error (bfd_error_no_memory);
5345               goto error_return;
5346             }
5347           elf_section_data (o)->rel_hashes = p;
5348           pend = p + o->reloc_count;
5349           for (; p < pend; p++)
5350             *p = NULL;
5351
5352           /* Use the reloc_count field as an index when outputting the
5353              relocs.  */
5354           o->reloc_count = 0;
5355         }
5356     }
5357
5358   assign_file_positions_for_relocs (abfd);
5359
5360   /* We have now assigned file positions for all the sections except
5361      .symtab and .strtab.  We start the .symtab section at the current
5362      file position, and write directly to it.  We build the .strtab
5363      section in memory.  When we add .dynsym support, we will build
5364      that in memory as well (.dynsym is smaller than .symtab).  */
5365   abfd->symcount = 0;
5366   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5367   /* sh_name is set in prep_headers.  */
5368   symtab_hdr->sh_type = SHT_SYMTAB;
5369   symtab_hdr->sh_flags = 0;
5370   symtab_hdr->sh_addr = 0;
5371   symtab_hdr->sh_size = 0;
5372   symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
5373   /* sh_link is set in assign_section_numbers.  */
5374   /* sh_info is set below.  */
5375   /* sh_offset is set just below.  */
5376   symtab_hdr->sh_addralign = 4;  /* FIXME: system dependent?  */
5377
5378   off = elf_tdata (abfd)->next_file_pos;
5379   off = assign_file_position_for_section (symtab_hdr, off, true);
5380
5381   /* Note that at this point elf_tdata (abfd)->next_file_pos is
5382      incorrect.  We do not yet know the size of the .symtab section.
5383      We correct next_file_pos below, after we do know the size.  */
5384
5385   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
5386      continuously seeking to the right position in the file.  */
5387   if (! info->keep_memory || max_sym_count < 20)
5388     finfo.symbuf_size = 20;
5389   else
5390     finfo.symbuf_size = max_sym_count;
5391   finfo.symbuf = ((Elf_External_Sym *)
5392                   malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
5393   if (finfo.symbuf == NULL)
5394     {
5395       bfd_set_error (bfd_error_no_memory);
5396       goto error_return;
5397     }
5398
5399   /* Start writing out the symbol table.  The first symbol is always a
5400      dummy symbol.  */
5401   elfsym.st_value = 0;
5402   elfsym.st_size = 0;
5403   elfsym.st_info = 0;
5404   elfsym.st_other = 0;
5405   elfsym.st_shndx = SHN_UNDEF;
5406   if (! elf_link_output_sym (&finfo, (const char *) NULL,
5407                              &elfsym, bfd_und_section_ptr))
5408     goto error_return;
5409
5410 #if 0
5411   /* Some standard ELF linkers do this, but we don't because it causes
5412      bootstrap comparison failures.  */
5413   /* Output a file symbol for the output file as the second symbol.
5414      We output this even if we are discarding local symbols, although
5415      I'm not sure if this is correct.  */
5416   elfsym.st_value = 0;
5417   elfsym.st_size = 0;
5418   elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5419   elfsym.st_other = 0;
5420   elfsym.st_shndx = SHN_ABS;
5421   if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
5422                              &elfsym, bfd_abs_section_ptr))
5423     goto error_return;
5424 #endif
5425
5426   /* Output a symbol for each section.  We output these even if we are
5427      discarding local symbols, since they are used for relocs.  These
5428      symbols have no names.  We store the index of each one in the
5429      index field of the section, so that we can find it again when
5430      outputting relocs.  */
5431   elfsym.st_value = 0;
5432   elfsym.st_size = 0;
5433   elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5434   elfsym.st_other = 0;
5435   for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
5436     {
5437       o = section_from_elf_index (abfd, i);
5438       if (o != NULL)
5439         o->target_index = abfd->symcount;
5440       elfsym.st_shndx = i;
5441       if (! elf_link_output_sym (&finfo, (const char *) NULL,
5442                                  &elfsym, o))
5443         goto error_return;
5444     }
5445
5446   /* Allocate some memory to hold information read in from the input
5447      files.  */
5448   finfo.contents = (bfd_byte *) malloc (max_contents_size);
5449   finfo.external_relocs = (PTR) malloc (max_external_reloc_size);
5450   finfo.internal_relocs = ((Elf_Internal_Rela *)
5451                            malloc (max_internal_reloc_count
5452                                    * sizeof (Elf_Internal_Rela)));
5453   finfo.external_syms = ((Elf_External_Sym *)
5454                          malloc (max_sym_count * sizeof (Elf_External_Sym)));
5455   finfo.internal_syms = ((Elf_Internal_Sym *)
5456                          malloc (max_sym_count * sizeof (Elf_Internal_Sym)));
5457   finfo.indices = (long *) malloc (max_sym_count * sizeof (long));
5458   finfo.sections = (asection **) malloc (max_sym_count * sizeof (asection *));
5459   if ((finfo.contents == NULL && max_contents_size != 0)
5460       || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
5461       || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
5462       || (finfo.external_syms == NULL && max_sym_count != 0)
5463       || (finfo.internal_syms == NULL && max_sym_count != 0)
5464       || (finfo.indices == NULL && max_sym_count != 0)
5465       || (finfo.sections == NULL && max_sym_count != 0))
5466     {
5467       bfd_set_error (bfd_error_no_memory);
5468       goto error_return;
5469     }
5470
5471   /* Since ELF permits relocations to be against local symbols, we
5472      must have the local symbols available when we do the relocations.
5473      Since we would rather only read the local symbols once, and we
5474      would rather not keep them in memory, we handle all the
5475      relocations for a single input file at the same time.
5476
5477      Unfortunately, there is no way to know the total number of local
5478      symbols until we have seen all of them, and the local symbol
5479      indices precede the global symbol indices.  This means that when
5480      we are generating relocateable output, and we see a reloc against
5481      a global symbol, we can not know the symbol index until we have
5482      finished examining all the local symbols to see which ones we are
5483      going to output.  To deal with this, we keep the relocations in
5484      memory, and don't output them until the end of the link.  This is
5485      an unfortunate waste of memory, but I don't see a good way around
5486      it.  Fortunately, it only happens when performing a relocateable
5487      link, which is not the common case.  FIXME: If keep_memory is set
5488      we could write the relocs out and then read them again; I don't
5489      know how bad the memory loss will be.  */
5490
5491   for (sub = info->input_bfds; sub != NULL; sub = sub->next)
5492     sub->output_has_begun = false;
5493   for (o = abfd->sections; o != NULL; o = o->next)
5494     {
5495       for (p = o->link_order_head; p != NULL; p = p->next)
5496         {
5497           if (p->type == bfd_indirect_link_order
5498               && (bfd_get_flavour (p->u.indirect.section->owner)
5499                   == bfd_target_elf_flavour))
5500             {
5501               sub = p->u.indirect.section->owner;
5502               if (! sub->output_has_begun)
5503                 {
5504                   if (! elf_link_input_bfd (&finfo, sub))
5505                     goto error_return;
5506                   sub->output_has_begun = true;
5507                 }
5508             }
5509           else if (p->type == bfd_section_reloc_link_order
5510                    || p->type == bfd_symbol_reloc_link_order)
5511             {
5512               if (! elf_reloc_link_order (abfd, info, o, p))
5513                 goto error_return;
5514             }
5515           else
5516             {
5517               if (! _bfd_default_link_order (abfd, info, o, p))
5518                 goto error_return;
5519             }
5520         }
5521     }
5522
5523   /* That wrote out all the local symbols.  Finish up the symbol table
5524      with the global symbols.  */
5525
5526   /* The sh_info field records the index of the first non local
5527      symbol.  */
5528   symtab_hdr->sh_info = abfd->symcount;
5529   if (dynamic)
5530     elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
5531
5532   /* We get the global symbols from the hash table.  */
5533   elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
5534                           (PTR) &finfo);
5535
5536   /* Flush all symbols to the file.  */
5537   if (! elf_link_flush_output_syms (&finfo))
5538     return false;
5539
5540   /* Now we know the size of the symtab section.  */
5541   off += symtab_hdr->sh_size;
5542
5543   /* Finish up and write out the symbol string table (.strtab)
5544      section.  */
5545   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5546   /* sh_name was set in prep_headers.  */
5547   symstrtab_hdr->sh_type = SHT_STRTAB;
5548   symstrtab_hdr->sh_flags = 0;
5549   symstrtab_hdr->sh_addr = 0;
5550   symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
5551   symstrtab_hdr->sh_entsize = 0;
5552   symstrtab_hdr->sh_link = 0;
5553   symstrtab_hdr->sh_info = 0;
5554   /* sh_offset is set just below.  */
5555   symstrtab_hdr->sh_addralign = 1;
5556
5557   off = assign_file_position_for_section (symstrtab_hdr, off, true);
5558   elf_tdata (abfd)->next_file_pos = off;
5559
5560   if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
5561       || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
5562     return false;
5563
5564   /* Adjust the relocs to have the correct symbol indices.  */
5565   for (o = abfd->sections; o != NULL; o = o->next)
5566     {
5567       struct elf_link_hash_entry **rel_hash;
5568       Elf_Internal_Shdr *rel_hdr;
5569
5570       if ((o->flags & SEC_RELOC) == 0)
5571         continue;
5572
5573       rel_hash = elf_section_data (o)->rel_hashes;
5574       rel_hdr = &elf_section_data (o)->rel_hdr;
5575       for (i = 0; i < o->reloc_count; i++, rel_hash++)
5576         {
5577           if (*rel_hash == NULL)
5578             continue;
5579
5580           BFD_ASSERT ((*rel_hash)->indx >= 0);
5581
5582           if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
5583             {
5584               Elf_External_Rel *erel;
5585               Elf_Internal_Rel irel;
5586
5587               erel = (Elf_External_Rel *) rel_hdr->contents + i;
5588               elf_swap_reloc_in (abfd, erel, &irel);
5589               irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
5590                                         ELF_R_TYPE (irel.r_info));
5591               elf_swap_reloc_out (abfd, &irel, erel);
5592             }
5593           else
5594             {
5595               Elf_External_Rela *erela;
5596               Elf_Internal_Rela irela;
5597
5598               BFD_ASSERT (rel_hdr->sh_entsize
5599                           == sizeof (Elf_External_Rela));
5600
5601               erela = (Elf_External_Rela *) rel_hdr->contents + i;
5602               elf_swap_reloca_in (abfd, erela, &irela);
5603               irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
5604                                          ELF_R_TYPE (irela.r_info));
5605               elf_swap_reloca_out (abfd, &irela, erela);
5606             }
5607         }
5608
5609       /* Set the reloc_count field to 0 to prevent write_relocs from
5610          trying to swap the relocs out itself.  */
5611       o->reloc_count = 0;
5612     }
5613
5614   /* If we are linking against a dynamic object, or generating a
5615      shared library, finish up the dynamic linking information.  */
5616   if (dynamic)
5617     {
5618       Elf_External_Dyn *dyncon, *dynconend;
5619
5620       /* Fix up .dynamic entries.  */
5621       o = bfd_get_section_by_name (dynobj, ".dynamic");
5622       BFD_ASSERT (o != NULL);
5623
5624       dyncon = (Elf_External_Dyn *) o->contents;
5625       dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
5626       for (; dyncon < dynconend; dyncon++)
5627         {
5628           Elf_Internal_Dyn dyn;
5629           const char *name;
5630           unsigned int type;
5631
5632           elf_swap_dyn_in (dynobj, dyncon, &dyn);
5633
5634           switch (dyn.d_tag)
5635             {
5636             default:
5637               break;
5638
5639               /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
5640                  magic _init and _fini symbols.  This is pretty ugly,
5641                  but we are compatible.  */
5642             case DT_INIT:
5643               name = "_init";
5644               goto get_sym;
5645             case DT_FINI:
5646               name = "_fini";
5647             get_sym:
5648               {
5649                 struct elf_link_hash_entry *h;
5650
5651                 h = elf_link_hash_lookup (elf_hash_table (info), name,
5652                                           false, false, true);
5653                 BFD_ASSERT (h != NULL);
5654                 if (h->root.type == bfd_link_hash_defined)
5655                   {
5656                     dyn.d_un.d_val = h->root.u.def.value;
5657                     o = h->root.u.def.section;
5658                     if (o->output_section != NULL)
5659                       dyn.d_un.d_val += (o->output_section->vma
5660                                          + o->output_offset);
5661                     else
5662                       dyn.d_un.d_val += o->vma;
5663                   }
5664                 elf_swap_dyn_out (dynobj, &dyn, dyncon);
5665               }
5666               break;
5667
5668             case DT_HASH:
5669               name = ".hash";
5670               goto get_vma;
5671             case DT_STRTAB:
5672               name = ".dynstr";
5673               goto get_vma;
5674             case DT_SYMTAB:
5675               name = ".dynsym";
5676             get_vma:
5677               o = bfd_get_section_by_name (abfd, name);
5678               BFD_ASSERT (o != NULL);
5679               dyn.d_un.d_ptr = o->vma;
5680               elf_swap_dyn_out (dynobj, &dyn, dyncon);
5681               break;
5682
5683             case DT_REL:
5684             case DT_RELA:
5685             case DT_RELSZ:
5686             case DT_RELASZ:
5687               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
5688                 type = SHT_REL;
5689               else
5690                 type = SHT_RELA;
5691               dyn.d_un.d_val = 0;
5692               for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
5693                 {
5694                   Elf_Internal_Shdr *hdr;
5695
5696                   hdr = elf_elfsections (abfd)[i];
5697                   if (hdr->sh_type == type
5698                       && (hdr->sh_flags & SHF_ALLOC) != 0)
5699                     {
5700                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
5701                         dyn.d_un.d_val += hdr->sh_size;
5702                       else
5703                         {
5704                           if (dyn.d_un.d_val == 0
5705                               || hdr->sh_addr < dyn.d_un.d_val)
5706                             dyn.d_un.d_val = hdr->sh_addr;
5707                         }
5708                     }
5709                 }
5710               elf_swap_dyn_out (dynobj, &dyn, dyncon);
5711               break;
5712             }
5713         }
5714     }
5715
5716   /* If we have created any dynamic sections, then output them.  */
5717   if (dynobj != NULL)
5718     {
5719       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
5720         goto error_return;
5721
5722       for (o = dynobj->sections; o != NULL; o = o->next)
5723         {
5724           if ((o->flags & SEC_HAS_CONTENTS) == 0
5725               || o->_raw_size == 0)
5726             continue;
5727           if ((o->flags & SEC_IN_MEMORY) == 0)
5728             {
5729               /* At this point, we are only interested in sections
5730                  created by elf_link_create_dynamic_sections.  FIXME:
5731                  This test is fragile.  */
5732               continue;
5733             }
5734           if ((elf_section_data (o->output_section)->this_hdr.sh_type
5735                != SHT_STRTAB)
5736               || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
5737             {
5738               if (! bfd_set_section_contents (abfd, o->output_section,
5739                                               o->contents, o->output_offset,
5740                                               o->_raw_size))
5741                 goto error_return;
5742             }
5743           else
5744             {
5745               file_ptr off;
5746
5747               /* The contents of the .dynstr section are actually in a
5748                  stringtab.  */
5749               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
5750               if (bfd_seek (abfd, off, SEEK_SET) != 0
5751                   || ! _bfd_stringtab_emit (abfd,
5752                                             elf_hash_table (info)->dynstr))
5753                 goto error_return;
5754             }
5755         }
5756     }
5757
5758   if (finfo.symstrtab != NULL)
5759     _bfd_stringtab_free (finfo.symstrtab);
5760   if (finfo.contents != NULL)
5761     free (finfo.contents);
5762   if (finfo.external_relocs != NULL)
5763     free (finfo.external_relocs);
5764   if (finfo.internal_relocs != NULL)
5765     free (finfo.internal_relocs);
5766   if (finfo.external_syms != NULL)
5767     free (finfo.external_syms);
5768   if (finfo.internal_syms != NULL)
5769     free (finfo.internal_syms);
5770   if (finfo.indices != NULL)
5771     free (finfo.indices);
5772   if (finfo.sections != NULL)
5773     free (finfo.sections);
5774   if (finfo.symbuf != NULL)
5775     free (finfo.symbuf);
5776   for (o = abfd->sections; o != NULL; o = o->next)
5777     {
5778       if ((o->flags & SEC_RELOC) != 0
5779           && elf_section_data (o)->rel_hashes != NULL)
5780         free (elf_section_data (o)->rel_hashes);
5781     }
5782
5783   elf_tdata (abfd)->linker = true;
5784
5785   return true;
5786
5787  error_return:
5788   if (finfo.symstrtab != NULL)
5789     _bfd_stringtab_free (finfo.symstrtab);
5790   if (finfo.contents != NULL)
5791     free (finfo.contents);
5792   if (finfo.external_relocs != NULL)
5793     free (finfo.external_relocs);
5794   if (finfo.internal_relocs != NULL)
5795     free (finfo.internal_relocs);
5796   if (finfo.external_syms != NULL)
5797     free (finfo.external_syms);
5798   if (finfo.internal_syms != NULL)
5799     free (finfo.internal_syms);
5800   if (finfo.indices != NULL)
5801     free (finfo.indices);
5802   if (finfo.sections != NULL)
5803     free (finfo.sections);
5804   if (finfo.symbuf != NULL)
5805     free (finfo.symbuf);
5806   for (o = abfd->sections; o != NULL; o = o->next)
5807     {
5808       if ((o->flags & SEC_RELOC) != 0
5809           && elf_section_data (o)->rel_hashes != NULL)
5810         free (elf_section_data (o)->rel_hashes);
5811     }
5812
5813   return false;
5814 }
5815
5816 /* Add a symbol to the output symbol table.  */
5817
5818 static boolean
5819 elf_link_output_sym (finfo, name, elfsym, input_sec)
5820      struct elf_final_link_info *finfo;
5821      const char *name;
5822      Elf_Internal_Sym *elfsym;
5823      asection *input_sec;
5824 {
5825   boolean (*output_symbol_hook) PARAMS ((bfd *,
5826                                          struct bfd_link_info *info,
5827                                          const char *,
5828                                          Elf_Internal_Sym *,
5829                                          asection *));
5830
5831   output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
5832     elf_backend_link_output_symbol_hook;
5833   if (output_symbol_hook != NULL)
5834     {
5835       if (! ((*output_symbol_hook)
5836              (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
5837         return false;
5838     }
5839
5840   if (name == (const char *) NULL || *name == '\0')
5841     elfsym->st_name = 0;
5842   else
5843     {
5844       elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
5845                                                             name, true,
5846                                                             false);
5847       if (elfsym->st_name == (unsigned long) -1)
5848         return false;
5849     }
5850
5851   if (finfo->symbuf_count >= finfo->symbuf_size)
5852     {
5853       if (! elf_link_flush_output_syms (finfo))
5854         return false;
5855     }
5856
5857   elf_swap_symbol_out (finfo->output_bfd, elfsym,
5858                        finfo->symbuf + finfo->symbuf_count);
5859   ++finfo->symbuf_count;
5860
5861   ++finfo->output_bfd->symcount;
5862
5863   return true;
5864 }
5865
5866 /* Flush the output symbols to the file.  */
5867
5868 static boolean
5869 elf_link_flush_output_syms (finfo)
5870      struct elf_final_link_info *finfo;
5871 {
5872   Elf_Internal_Shdr *symtab;
5873
5874   symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
5875
5876   if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
5877                 SEEK_SET) != 0
5878       || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
5879                      sizeof (Elf_External_Sym), finfo->output_bfd)
5880           != finfo->symbuf_count * sizeof (Elf_External_Sym)))
5881     return false;
5882
5883   symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
5884
5885   finfo->symbuf_count = 0;
5886
5887   return true;
5888 }
5889
5890 /* Add an external symbol to the symbol table.  This is called from
5891    the hash table traversal routine.  */
5892
5893 static boolean
5894 elf_link_output_extsym (h, data)
5895      struct elf_link_hash_entry *h;
5896      PTR data;
5897 {
5898   struct elf_final_link_info *finfo = (struct elf_final_link_info *) data;
5899   boolean strip;
5900   Elf_Internal_Sym sym;
5901   asection *input_sec;
5902
5903   /* We don't want to output symbols that have never been mentioned by
5904      a regular file, or that we have been told to strip.  However, if
5905      h->indx is set to -2, the symbol is used by a reloc and we must
5906      output it.  */
5907   if (h->indx == -2)
5908     strip = false;
5909   else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5910             || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
5911            && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
5912            && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
5913     strip = true;
5914   else if (finfo->info->strip == strip_all
5915            || (finfo->info->strip == strip_some
5916                && bfd_hash_lookup (finfo->info->keep_hash,
5917                                    h->root.root.string,
5918                                    false, false) == NULL))
5919     strip = true;
5920   else
5921     strip = false;
5922
5923   /* If we're stripping it, and it's not a dynamic symbol, there's
5924      nothing else to do.  */
5925   if (strip && h->dynindx == -1)
5926     return true;
5927
5928   sym.st_value = 0;
5929   sym.st_size = h->size;
5930   sym.st_other = 0;
5931   if (h->root.type == bfd_link_hash_weak
5932       || (h->elf_link_hash_flags & ELF_LINK_HASH_DEFINED_WEAK) != 0)
5933     sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
5934   else
5935     sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
5936
5937   switch (h->root.type)
5938     {
5939     default:
5940     case bfd_link_hash_new:
5941       abort ();
5942       return false;
5943
5944     case bfd_link_hash_undefined:
5945       input_sec = bfd_und_section_ptr;
5946       sym.st_shndx = SHN_UNDEF;
5947       break;
5948
5949     case bfd_link_hash_weak:
5950       input_sec = bfd_und_section_ptr;
5951       sym.st_shndx = SHN_UNDEF;
5952       break;
5953
5954     case bfd_link_hash_defined:
5955       {
5956         input_sec = h->root.u.def.section;
5957         if (input_sec->output_section != NULL)
5958           {
5959             sym.st_shndx =
5960               elf_section_from_bfd_section (finfo->output_bfd,
5961                                             input_sec->output_section);
5962             if (sym.st_shndx == (unsigned short) -1)
5963               {
5964                 /* FIXME: No way to handle errors.  */
5965                 abort ();
5966               }
5967
5968             /* ELF symbols in relocateable files are section relative,
5969                but in nonrelocateable files they are virtual
5970                addresses.  */
5971             sym.st_value = h->root.u.def.value + input_sec->output_offset;
5972             if (! finfo->info->relocateable)
5973               sym.st_value += input_sec->output_section->vma;
5974           }
5975         else
5976           {
5977             BFD_ASSERT ((bfd_get_flavour (input_sec->owner)
5978                          == bfd_target_elf_flavour)
5979                         && elf_elfheader (input_sec->owner)->e_type == ET_DYN);
5980             sym.st_shndx = SHN_UNDEF;
5981             input_sec = bfd_und_section_ptr;
5982           }
5983       }
5984       break;
5985
5986     case bfd_link_hash_common:
5987       input_sec = bfd_com_section_ptr;
5988       sym.st_shndx = SHN_COMMON;
5989       sym.st_value = 1 << h->root.u.c.alignment_power;
5990       break;
5991
5992     case bfd_link_hash_indirect:
5993     case bfd_link_hash_warning:
5994       /* I have no idea how these should be handled.  */
5995       return true;
5996     }
5997
5998   /* If this symbol should be put in the .dynsym section, then put it
5999      there now.  We have already know the symbol index.  We also fill
6000      in the entry in the .hash section.  */
6001   if (h->dynindx != -1
6002       && elf_hash_table (finfo->info)->dynamic_sections_created)
6003     {
6004       struct elf_backend_data *bed;
6005       size_t bucketcount;
6006       size_t bucket;
6007       bfd_byte *bucketpos;
6008       bfd_vma chain;
6009
6010       sym.st_name = h->dynstr_index;
6011
6012       /* Give the processor backend a chance to tweak the symbol
6013          value, and also to finish up anything that needs to be done
6014          for this symbol.  */
6015       bed = get_elf_backend_data (finfo->output_bfd);
6016       if (! ((*bed->elf_backend_finish_dynamic_symbol)
6017              (finfo->output_bfd, finfo->info, h, &sym)))
6018         {
6019           /* FIXME: No way to return error.  */
6020           abort ();
6021         }
6022
6023       elf_swap_symbol_out (finfo->output_bfd, &sym,
6024                            ((Elf_External_Sym *) finfo->dynsym_sec->contents
6025                             + h->dynindx));
6026
6027       bucketcount = elf_hash_table (finfo->info)->bucketcount;
6028       bucket = (bfd_elf_hash ((const unsigned char *) h->root.root.string)
6029                 % bucketcount);
6030       bucketpos = ((bfd_byte *) finfo->hash_sec->contents
6031                    + (bucket + 2) * (ARCH_SIZE / 8));
6032       chain = get_word (finfo->output_bfd, bucketpos);
6033       put_word (finfo->output_bfd, h->dynindx, bucketpos);
6034       put_word (finfo->output_bfd, chain,
6035                 ((bfd_byte *) finfo->hash_sec->contents
6036                  + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
6037     }
6038
6039   /* If we're stripping it, then it was just a dynamic symbol, and
6040      there's nothing else to do.  */
6041   if (strip)
6042     return true;
6043
6044   h->indx = finfo->output_bfd->symcount;
6045
6046   if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
6047     {
6048       /* FIXME: No way to return error.  */
6049       abort ();
6050     }
6051
6052   return true;
6053 }
6054
6055 /* Link an input file into the linker output file.  This function
6056    handles all the sections and relocations of the input file at once.
6057    This is so that we only have to read the local symbols once, and
6058    don't have to keep them in memory.  */
6059
6060 static boolean
6061 elf_link_input_bfd (finfo, input_bfd)
6062      struct elf_final_link_info *finfo;
6063      bfd *input_bfd;
6064 {
6065   boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
6066                                        bfd *, asection *, bfd_byte *,
6067                                        Elf_Internal_Rela *,
6068                                        Elf_Internal_Sym *, asection **));
6069   bfd *output_bfd;
6070   Elf_Internal_Shdr *symtab_hdr;
6071   size_t locsymcount;
6072   size_t extsymoff;
6073   Elf_External_Sym *esym;
6074   Elf_External_Sym *esymend;
6075   Elf_Internal_Sym *isym;
6076   long *pindex;
6077   asection **ppsection;
6078   asection *o;
6079
6080   output_bfd = finfo->output_bfd;
6081   relocate_section =
6082     get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
6083
6084   /* If this is a dynamic object, we don't want to do anything here:
6085      we don't want the local symbols, and we don't want the section
6086      contents.  */
6087   if (elf_elfheader (input_bfd)->e_type == ET_DYN)
6088     return true;
6089
6090   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6091   if (elf_bad_symtab (input_bfd))
6092     {
6093       locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
6094       extsymoff = 0;
6095     }
6096   else
6097     {
6098       locsymcount = symtab_hdr->sh_info;
6099       extsymoff = symtab_hdr->sh_info;
6100     }
6101
6102   /* Read the local symbols.  */
6103   if (locsymcount > 0
6104       && (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
6105           || (bfd_read (finfo->external_syms, sizeof (Elf_External_Sym),
6106                         locsymcount, input_bfd)
6107               != locsymcount * sizeof (Elf_External_Sym))))
6108     return false;
6109
6110   /* Swap in the local symbols and write out the ones which we know
6111      are going into the output file.  */
6112   esym = finfo->external_syms;
6113   esymend = esym + locsymcount;
6114   isym = finfo->internal_syms;
6115   pindex = finfo->indices;
6116   ppsection = finfo->sections;
6117   for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
6118     {
6119       asection *isec;
6120       const char *name;
6121       Elf_Internal_Sym osym;
6122
6123       elf_swap_symbol_in (input_bfd, esym, isym);
6124       *pindex = -1;
6125
6126       if (elf_bad_symtab (input_bfd))
6127         {
6128           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
6129             {
6130               *ppsection = NULL;
6131               continue;
6132             }
6133         }
6134
6135       if (isym->st_shndx == SHN_UNDEF)
6136         isec = bfd_und_section_ptr;
6137       else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
6138         isec = section_from_elf_index (input_bfd, isym->st_shndx);
6139       else if (isym->st_shndx == SHN_ABS)
6140         isec = bfd_abs_section_ptr;
6141       else if (isym->st_shndx == SHN_COMMON)
6142         isec = bfd_com_section_ptr;
6143       else
6144         {
6145           /* Who knows?  */
6146           isec = NULL;
6147         }
6148
6149       *ppsection = isec;
6150
6151       /* Don't output the first, undefined, symbol.  */
6152       if (esym == finfo->external_syms)
6153         continue;
6154
6155       /* If we are stripping all symbols, we don't want to output this
6156          one.  */
6157       if (finfo->info->strip == strip_all)
6158         continue;
6159
6160       /* We never output section symbols.  Instead, we use the section
6161          symbol of the corresponding section in the output file.  */
6162       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
6163         continue;
6164
6165       /* If we are discarding all local symbols, we don't want to
6166          output this one.  If we are generating a relocateable output
6167          file, then some of the local symbols may be required by
6168          relocs; we output them below as we discover that they are
6169          needed.  */
6170       if (finfo->info->discard == discard_all)
6171         continue;
6172
6173       /* Get the name of the symbol.  */
6174       name = elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
6175                                           isym->st_name);
6176       if (name == NULL)
6177         return false;
6178
6179       /* See if we are discarding symbols with this name.  */
6180       if ((finfo->info->strip == strip_some
6181            && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
6182                == NULL))
6183           || (finfo->info->discard == discard_l
6184               && strncmp (name, finfo->info->lprefix,
6185                           finfo->info->lprefix_len) == 0))
6186         continue;
6187
6188       /* If we get here, we are going to output this symbol.  */
6189
6190       osym = *isym;
6191
6192       /* Adjust the section index for the output file.  */
6193       osym.st_shndx = elf_section_from_bfd_section (output_bfd,
6194                                                     isec->output_section);
6195       if (osym.st_shndx == (unsigned short) -1)
6196         return false;
6197
6198       *pindex = output_bfd->symcount;
6199
6200       /* ELF symbols in relocateable files are section relative, but
6201          in executable files they are virtual addresses.  Note that
6202          this code assumes that all ELF sections have an associated
6203          BFD section with a reasonable value for output_offset; below
6204          we assume that they also have a reasonable value for
6205          output_section.  Any special sections must be set up to meet
6206          these requirements.  */
6207       osym.st_value += isec->output_offset;
6208       if (! finfo->info->relocateable)
6209         osym.st_value += isec->output_section->vma;
6210
6211       if (! elf_link_output_sym (finfo, name, &osym, isec))
6212         return false;
6213     }
6214
6215   /* Relocate the contents of each section.  */
6216   for (o = input_bfd->sections; o != NULL; o = o->next)
6217     {
6218       if ((o->flags & SEC_HAS_CONTENTS) == 0)
6219         continue;
6220
6221       if ((o->flags & SEC_IN_MEMORY) != 0
6222           && input_bfd == elf_hash_table (finfo->info)->dynobj)
6223         {
6224           /* Section was created by elf_link_create_dynamic_sections.
6225              FIXME: This test is fragile.  */
6226           continue;
6227         }
6228
6229       /* Read the contents of the section.  */
6230       if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
6231                                       (file_ptr) 0, o->_raw_size))
6232         return false;
6233
6234       if ((o->flags & SEC_RELOC) != 0)
6235         {
6236           Elf_Internal_Rela *internal_relocs;
6237
6238           /* Get the swapped relocs.  */
6239           internal_relocs = elf_link_read_relocs (input_bfd, o,
6240                                                   finfo->external_relocs,
6241                                                   finfo->internal_relocs,
6242                                                   false);
6243           if (internal_relocs == NULL
6244               && o->reloc_count > 0)
6245             return false;
6246
6247           /* Relocate the section by invoking a back end routine.
6248
6249              The back end routine is responsible for adjusting the
6250              section contents as necessary, and (if using Rela relocs
6251              and generating a relocateable output file) adjusting the
6252              reloc addend as necessary.
6253
6254              The back end routine does not have to worry about setting
6255              the reloc address or the reloc symbol index.
6256
6257              The back end routine is given a pointer to the swapped in
6258              internal symbols, and can access the hash table entries
6259              for the external symbols via elf_sym_hashes (input_bfd).
6260
6261              When generating relocateable output, the back end routine
6262              must handle STB_LOCAL/STT_SECTION symbols specially.  The
6263              output symbol is going to be a section symbol
6264              corresponding to the output section, which will require
6265              the addend to be adjusted.  */
6266
6267           if (! (*relocate_section) (output_bfd, finfo->info,
6268                                      input_bfd, o,
6269                                      finfo->contents,
6270                                      internal_relocs,
6271                                      finfo->internal_syms,
6272                                      finfo->sections))
6273             return false;
6274
6275           if (finfo->info->relocateable)
6276             {
6277               Elf_Internal_Rela *irela;
6278               Elf_Internal_Rela *irelaend;
6279               struct elf_link_hash_entry **rel_hash;
6280               Elf_Internal_Shdr *input_rel_hdr;
6281               Elf_Internal_Shdr *output_rel_hdr;
6282
6283               /* Adjust the reloc addresses and symbol indices.  */
6284
6285               irela = internal_relocs;
6286               irelaend = irela + o->reloc_count;
6287               rel_hash = (elf_section_data (o->output_section)->rel_hashes
6288                           + o->output_section->reloc_count);
6289               for (; irela < irelaend; irela++, rel_hash++)
6290                 {
6291                   long r_symndx;
6292                   Elf_Internal_Sym *isym;
6293                   asection *sec;
6294
6295                   irela->r_offset += o->output_offset;
6296
6297                   r_symndx = ELF_R_SYM (irela->r_info);
6298
6299                   if (r_symndx == 0)
6300                     continue;
6301
6302                   if (r_symndx >= locsymcount
6303                       || (elf_bad_symtab (input_bfd)
6304                           && finfo->sections[r_symndx] == NULL))
6305                     {
6306                       long indx;
6307
6308                       /* This is a reloc against a global symbol.  We
6309                          have not yet output all the local symbols, so
6310                          we do not know the symbol index of any global
6311                          symbol.  We set the rel_hash entry for this
6312                          reloc to point to the global hash table entry
6313                          for this symbol.  The symbol index is then
6314                          set at the end of elf_bfd_final_link.  */
6315                       indx = r_symndx - extsymoff;
6316                       *rel_hash = elf_sym_hashes (input_bfd)[indx];
6317
6318                       /* Setting the index to -2 tells
6319                          elf_link_output_extsym that this symbol is
6320                          used by a reloc.  */
6321                       BFD_ASSERT ((*rel_hash)->indx < 0);
6322                       (*rel_hash)->indx = -2;
6323
6324                       continue;
6325                     }
6326
6327                   /* This is a reloc against a local symbol. */
6328
6329                   *rel_hash = NULL;
6330                   isym = finfo->internal_syms + r_symndx;
6331                   sec = finfo->sections[r_symndx];
6332                   if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
6333                     {
6334                       /* I suppose the backend ought to fill in the
6335                          section of any STT_SECTION symbol against a
6336                          processor specific section.  */
6337                       if (sec != NULL && bfd_is_abs_section (sec))
6338                         r_symndx = 0;
6339                       else if (sec == NULL || sec->owner == NULL)
6340                         {
6341                           bfd_set_error (bfd_error_bad_value);
6342                           return false;
6343                         }
6344                       else
6345                         {
6346                           r_symndx = sec->output_section->target_index;
6347                           if (r_symndx == 0)
6348                             abort ();
6349                         }
6350                     }
6351                   else
6352                     {
6353                       if (finfo->indices[r_symndx] == -1)
6354                         {
6355                           unsigned long link;
6356                           const char *name;
6357                           asection *osec;
6358
6359                           if (finfo->info->strip == strip_all)
6360                             {
6361                               /* You can't do ld -r -s.  */
6362                               bfd_set_error (bfd_error_invalid_operation);
6363                               return false;
6364                             }
6365
6366                           /* This symbol was skipped earlier, but
6367                              since it is needed by a reloc, we
6368                              must output it now.  */
6369                           link = symtab_hdr->sh_link;
6370                           name = elf_string_from_elf_section (input_bfd,
6371                                                               link,
6372                                                               isym->st_name);
6373                           if (name == NULL)
6374                             return false;
6375
6376                           osec = sec->output_section;
6377                           isym->st_shndx =
6378                             elf_section_from_bfd_section (output_bfd,
6379                                                           osec);
6380                           if (isym->st_shndx == (unsigned short) -1)
6381                             return false;
6382
6383                           isym->st_value += sec->output_offset;
6384                           if (! finfo->info->relocateable)
6385                             isym->st_value += osec->vma;
6386
6387                           finfo->indices[r_symndx] = output_bfd->symcount;
6388
6389                           if (! elf_link_output_sym (finfo, name, isym, sec))
6390                             return false;
6391                         }
6392
6393                       r_symndx = finfo->indices[r_symndx];
6394                     }
6395
6396                   irela->r_info = ELF_R_INFO (r_symndx,
6397                                               ELF_R_TYPE (irela->r_info));
6398                 }
6399
6400               /* Swap out the relocs.  */
6401               input_rel_hdr = &elf_section_data (o)->rel_hdr;
6402               output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
6403               BFD_ASSERT (output_rel_hdr->sh_entsize
6404                           == input_rel_hdr->sh_entsize);
6405               irela = internal_relocs;
6406               irelaend = irela + o->reloc_count;
6407               if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
6408                 {
6409                   Elf_External_Rel *erel;
6410
6411                   erel = ((Elf_External_Rel *) output_rel_hdr->contents
6412                           + o->output_section->reloc_count);
6413                   for (; irela < irelaend; irela++, erel++)
6414                     {
6415                       Elf_Internal_Rel irel;
6416
6417                       irel.r_offset = irela->r_offset;
6418                       irel.r_info = irela->r_info;
6419                       BFD_ASSERT (irela->r_addend == 0);
6420                       elf_swap_reloc_out (output_bfd, &irel, erel);
6421                     }
6422                 }
6423               else
6424                 {
6425                   Elf_External_Rela *erela;
6426
6427                   BFD_ASSERT (input_rel_hdr->sh_entsize
6428                               == sizeof (Elf_External_Rela));
6429                   erela = ((Elf_External_Rela *) output_rel_hdr->contents
6430                            + o->output_section->reloc_count);
6431                   for (; irela < irelaend; irela++, erela++)
6432                     elf_swap_reloca_out (output_bfd, irela, erela);
6433                 }
6434
6435               o->output_section->reloc_count += o->reloc_count;
6436             }
6437         }
6438
6439       /* Write out the modified section contents.  */
6440       if (! bfd_set_section_contents (output_bfd, o->output_section,
6441                                       finfo->contents, o->output_offset,
6442                                       (o->_cooked_size != 0
6443                                        ? o->_cooked_size
6444                                        : o->_raw_size)))
6445         return false;
6446     }
6447
6448   return true;
6449 }
6450
6451 /* Generate a reloc when linking an ELF file.  This is a reloc
6452    requested by the linker, and does come from any input file.  This
6453    is used to build constructor and destructor tables when linking
6454    with -Ur.  */
6455
6456 static boolean
6457 elf_reloc_link_order (output_bfd, info, output_section, link_order)
6458      bfd *output_bfd;
6459      struct bfd_link_info *info;
6460      asection *output_section;
6461      struct bfd_link_order *link_order;
6462 {
6463   const reloc_howto_type *howto;
6464   long indx;
6465   bfd_vma offset;
6466   struct elf_link_hash_entry **rel_hash_ptr;
6467   Elf_Internal_Shdr *rel_hdr;
6468
6469   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
6470   if (howto == NULL)
6471     {
6472       bfd_set_error (bfd_error_bad_value);
6473       return false;
6474     }
6475
6476   /* If this is an inplace reloc, we must write the addend into the
6477      object file.  */
6478   if (howto->partial_inplace
6479       && link_order->u.reloc.p->addend != 0)
6480     {
6481       bfd_size_type size;
6482       bfd_reloc_status_type rstat;
6483       bfd_byte *buf;
6484       boolean ok;
6485
6486       size = bfd_get_reloc_size (howto);
6487       buf = (bfd_byte *) bfd_zmalloc (size);
6488       if (buf == (bfd_byte *) NULL)
6489         {
6490           bfd_set_error (bfd_error_no_memory);
6491           return false;
6492         }
6493       rstat = _bfd_relocate_contents (howto, output_bfd,
6494                                       link_order->u.reloc.p->addend, buf);
6495       switch (rstat)
6496         {
6497         case bfd_reloc_ok:
6498           break;
6499         default:
6500         case bfd_reloc_outofrange:
6501           abort ();
6502         case bfd_reloc_overflow:
6503           if (! ((*info->callbacks->reloc_overflow)
6504                  (info,
6505                   (link_order->type == bfd_section_reloc_link_order
6506                    ? bfd_section_name (output_bfd,
6507                                        link_order->u.reloc.p->u.section)
6508                    : link_order->u.reloc.p->u.name),
6509                   howto->name, link_order->u.reloc.p->addend,
6510                   (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
6511             {
6512               free (buf);
6513               return false;
6514             }
6515           break;
6516         }
6517       ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
6518                                      (file_ptr) link_order->offset, size);
6519       free (buf);
6520       if (! ok)
6521         return false;
6522     }
6523
6524   /* Figure out the symbol index.  */
6525   rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
6526                   + output_section->reloc_count);
6527   if (link_order->type == bfd_section_reloc_link_order)
6528     {
6529       indx = link_order->u.reloc.p->u.section->target_index;
6530       if (indx == 0)
6531         abort ();
6532       *rel_hash_ptr = NULL;
6533     }
6534   else
6535     {
6536       struct elf_link_hash_entry *h;
6537
6538       h = elf_link_hash_lookup (elf_hash_table (info),
6539                                 link_order->u.reloc.p->u.name,
6540                                 false, false, true);
6541       if (h != NULL)
6542         {
6543           /* Setting the index to -2 tells elf_link_output_extsym that
6544              this symbol is used by a reloc.  */
6545           h->indx = -2;
6546           *rel_hash_ptr = h;
6547           indx = 0;
6548         }
6549       else
6550         {
6551           if (! ((*info->callbacks->unattached_reloc)
6552                  (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
6553                   (asection *) NULL, (bfd_vma) 0)))
6554             return false;
6555           indx = 0;
6556         }
6557     }
6558
6559   /* The address of a reloc is relative to the section in a
6560      relocateable file, and is a virtual address in an executable
6561      file.  */
6562   offset = link_order->offset;
6563   if (! info->relocateable)
6564     offset += output_section->vma;
6565
6566   rel_hdr = &elf_section_data (output_section)->rel_hdr;
6567
6568   if (rel_hdr->sh_type == SHT_REL)
6569     {
6570       Elf_Internal_Rel irel;
6571       Elf_External_Rel *erel;
6572
6573       irel.r_offset = offset;
6574       irel.r_info = ELF_R_INFO (indx, howto->type);
6575       erel = ((Elf_External_Rel *) rel_hdr->contents
6576               + output_section->reloc_count);
6577       elf_swap_reloc_out (output_bfd, &irel, erel);
6578     }
6579   else
6580     {
6581       Elf_Internal_Rela irela;
6582       Elf_External_Rela *erela;
6583
6584       irela.r_offset = offset;
6585       irela.r_info = ELF_R_INFO (indx, howto->type);
6586       irela.r_addend = link_order->u.reloc.p->addend;
6587       erela = ((Elf_External_Rela *) rel_hdr->contents
6588                + output_section->reloc_count);
6589       elf_swap_reloca_out (output_bfd, &irela, erela);
6590     }
6591
6592   ++output_section->reloc_count;
6593
6594   return true;
6595 }