contrib/binutils/bfd/elf32-i386.c

   1 /* Intel 80386/80486-specific support for 32-bit ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* $FreeBSD: src/contrib/binutils/bfd/elf32-i386.c,v 1.4.2.7 2002/09/01 23:43:37 obrien Exp $ */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28
  29 static reloc_howto_type *elf_i386_reloc_type_lookup
  30   PARAMS ((bfd *, bfd_reloc_code_real_type));
  31 static void elf_i386_info_to_howto
  32   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
  33 static void elf_i386_info_to_howto_rel
  34   PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
  35 static boolean elf_i386_is_local_label_name
  36   PARAMS ((bfd *, const char *));
  37 static boolean elf_i386_grok_prstatus
  38   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
  39 static boolean elf_i386_grok_psinfo
  40   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
  41 static struct bfd_hash_entry *link_hash_newfunc
  42   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  43 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
  44   PARAMS ((bfd *));
  45 static boolean create_got_section
  46   PARAMS((bfd *, struct bfd_link_info *));
  47 static boolean elf_i386_create_dynamic_sections
  48   PARAMS((bfd *, struct bfd_link_info *));
  49 static void elf_i386_copy_indirect_symbol
  50   PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
  51 static boolean elf_i386_check_relocs
  52   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  53            const Elf_Internal_Rela *));
  54 static asection *elf_i386_gc_mark_hook
  55   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
  56            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  57 static boolean elf_i386_gc_sweep_hook
  58   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  59            const Elf_Internal_Rela *));
  60 static boolean elf_i386_adjust_dynamic_symbol
  61   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  62 static boolean allocate_dynrelocs
  63   PARAMS ((struct elf_link_hash_entry *, PTR));
  64 static boolean readonly_dynrelocs
  65   PARAMS ((struct elf_link_hash_entry *, PTR));
  66 static boolean elf_i386_fake_sections
  67   PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
  68 static boolean elf_i386_size_dynamic_sections
  69   PARAMS ((bfd *, struct bfd_link_info *));
  70 static boolean elf_i386_relocate_section
  71   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  72            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  73 static boolean elf_i386_finish_dynamic_symbol
  74   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  75            Elf_Internal_Sym *));
  76 static enum elf_reloc_type_class elf_i386_reloc_type_class
  77   PARAMS ((const Elf_Internal_Rela *));
  78 static boolean elf_i386_finish_dynamic_sections
  79   PARAMS ((bfd *, struct bfd_link_info *));
  80
  81 #define USE_REL 1               /* 386 uses REL relocations instead of RELA */
  82
  83 #include "elf/i386.h"
  84
  85 static reloc_howto_type elf_howto_table[]=
  86 {
  87   HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
  88         bfd_elf_generic_reloc, "R_386_NONE",
  89         true, 0x00000000, 0x00000000, false),
  90   HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
  91         bfd_elf_generic_reloc, "R_386_32",
  92         true, 0xffffffff, 0xffffffff, false),
  93   HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
  94         bfd_elf_generic_reloc, "R_386_PC32",
  95         true, 0xffffffff, 0xffffffff, true),
  96   HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
  97         bfd_elf_generic_reloc, "R_386_GOT32",
  98         true, 0xffffffff, 0xffffffff, false),
  99   HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
 100         bfd_elf_generic_reloc, "R_386_PLT32",
 101         true, 0xffffffff, 0xffffffff, true),
 102   HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
 103         bfd_elf_generic_reloc, "R_386_COPY",
 104         true, 0xffffffff, 0xffffffff, false),
 105   HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
 106         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
 107         true, 0xffffffff, 0xffffffff, false),
 108   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
 109         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
 110         true, 0xffffffff, 0xffffffff, false),
 111   HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
 112         bfd_elf_generic_reloc, "R_386_RELATIVE",
 113         true, 0xffffffff, 0xffffffff, false),
 114   HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
 115         bfd_elf_generic_reloc, "R_386_GOTOFF",
 116         true, 0xffffffff, 0xffffffff, false),
 117   HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
 118         bfd_elf_generic_reloc, "R_386_GOTPC",
 119         true, 0xffffffff, 0xffffffff, true),
 120
 121   /* We have a gap in the reloc numbers here.
 122      R_386_standard counts the number up to this point, and
 123      R_386_ext_offset is the value to subtract from a reloc type of
 124      R_386_16 thru R_386_PC8 to form an index into this table.  */
 125 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
 126 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
 127
 128   /* The remaining relocs are a GNU extension.  */
 129   HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
 130         bfd_elf_generic_reloc, "R_386_16",
 131         true, 0xffff, 0xffff, false),
 132   HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
 133         bfd_elf_generic_reloc, "R_386_PC16",
 134         true, 0xffff, 0xffff, true),
 135   HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
 136         bfd_elf_generic_reloc, "R_386_8",
 137         true, 0xff, 0xff, false),
 138   HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
 139         bfd_elf_generic_reloc, "R_386_PC8",
 140         true, 0xff, 0xff, true),
 141
 142   /* Another gap.  */
 143 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
 144 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
 145
 146 /* GNU extension to record C++ vtable hierarchy.  */
 147   HOWTO (R_386_GNU_VTINHERIT,   /* type */
 148          0,                     /* rightshift */
 149          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 150          0,                     /* bitsize */
 151          false,                 /* pc_relative */
 152          0,                     /* bitpos */
 153          complain_overflow_dont, /* complain_on_overflow */
 154          NULL,                  /* special_function */
 155          "R_386_GNU_VTINHERIT", /* name */
 156          false,                 /* partial_inplace */
 157          0,                     /* src_mask */
 158          0,                     /* dst_mask */
 159          false),
 160
 161 /* GNU extension to record C++ vtable member usage.  */
 162   HOWTO (R_386_GNU_VTENTRY,     /* type */
 163          0,                     /* rightshift */
 164          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 165          0,                     /* bitsize */
 166          false,                 /* pc_relative */
 167          0,                     /* bitpos */
 168          complain_overflow_dont, /* complain_on_overflow */
 169          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 170          "R_386_GNU_VTENTRY",   /* name */
 171          false,                 /* partial_inplace */
 172          0,                     /* src_mask */
 173          0,                     /* dst_mask */
 174          false)
 175
 176 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
 177
 178 };
 179
 180 #ifdef DEBUG_GEN_RELOC
 181 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 182 #else
 183 #define TRACE(str)
 184 #endif
 185
 186 static reloc_howto_type *
 187 elf_i386_reloc_type_lookup (abfd, code)
 188      bfd *abfd ATTRIBUTE_UNUSED;
 189      bfd_reloc_code_real_type code;
 190 {
 191   switch (code)
 192     {
 193     case BFD_RELOC_NONE:
 194       TRACE ("BFD_RELOC_NONE");
 195       return &elf_howto_table[(unsigned int) R_386_NONE ];
 196
 197     case BFD_RELOC_32:
 198       TRACE ("BFD_RELOC_32");
 199       return &elf_howto_table[(unsigned int) R_386_32 ];
 200
 201     case BFD_RELOC_CTOR:
 202       TRACE ("BFD_RELOC_CTOR");
 203       return &elf_howto_table[(unsigned int) R_386_32 ];
 204
 205     case BFD_RELOC_32_PCREL:
 206       TRACE ("BFD_RELOC_PC32");
 207       return &elf_howto_table[(unsigned int) R_386_PC32 ];
 208
 209     case BFD_RELOC_386_GOT32:
 210       TRACE ("BFD_RELOC_386_GOT32");
 211       return &elf_howto_table[(unsigned int) R_386_GOT32 ];
 212
 213     case BFD_RELOC_386_PLT32:
 214       TRACE ("BFD_RELOC_386_PLT32");
 215       return &elf_howto_table[(unsigned int) R_386_PLT32 ];
 216
 217     case BFD_RELOC_386_COPY:
 218       TRACE ("BFD_RELOC_386_COPY");
 219       return &elf_howto_table[(unsigned int) R_386_COPY ];
 220
 221     case BFD_RELOC_386_GLOB_DAT:
 222       TRACE ("BFD_RELOC_386_GLOB_DAT");
 223       return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
 224
 225     case BFD_RELOC_386_JUMP_SLOT:
 226       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 227       return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
 228
 229     case BFD_RELOC_386_RELATIVE:
 230       TRACE ("BFD_RELOC_386_RELATIVE");
 231       return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
 232
 233     case BFD_RELOC_386_GOTOFF:
 234       TRACE ("BFD_RELOC_386_GOTOFF");
 235       return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
 236
 237     case BFD_RELOC_386_GOTPC:
 238       TRACE ("BFD_RELOC_386_GOTPC");
 239       return &elf_howto_table[(unsigned int) R_386_GOTPC ];
 240
 241       /* The remaining relocs are a GNU extension.  */
 242     case BFD_RELOC_16:
 243       TRACE ("BFD_RELOC_16");
 244       return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
 245
 246     case BFD_RELOC_16_PCREL:
 247       TRACE ("BFD_RELOC_16_PCREL");
 248       return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
 249
 250     case BFD_RELOC_8:
 251       TRACE ("BFD_RELOC_8");
 252       return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
 253
 254     case BFD_RELOC_8_PCREL:
 255       TRACE ("BFD_RELOC_8_PCREL");
 256       return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
 257
 258     case BFD_RELOC_VTABLE_INHERIT:
 259       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 260       return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
 261                              - R_386_vt_offset];
 262
 263     case BFD_RELOC_VTABLE_ENTRY:
 264       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 265       return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
 266                              - R_386_vt_offset];
 267
 268     default:
 269       break;
 270     }
 271
 272   TRACE ("Unknown");
 273   return 0;
 274 }
 275
 276 static void
 277 elf_i386_info_to_howto (abfd, cache_ptr, dst)
 278      bfd                *abfd ATTRIBUTE_UNUSED;
 279      arelent            *cache_ptr ATTRIBUTE_UNUSED;
 280      Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
 281 {
 282   abort ();
 283 }
 284
 285 static void
 286 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
 287      bfd *abfd ATTRIBUTE_UNUSED;
 288      arelent *cache_ptr;
 289      Elf32_Internal_Rel *dst;
 290 {
 291   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 292   unsigned int indx;
 293
 294   if ((indx = r_type) >= R_386_standard
 295       && ((indx = r_type - R_386_ext_offset) - R_386_standard
 296           >= R_386_ext - R_386_standard)
 297       && ((indx = r_type - R_386_vt_offset) - R_386_ext
 298           >= R_386_vt - R_386_ext))
 299     {
 300       (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
 301                              bfd_archive_filename (abfd), (int) r_type);
 302       indx = (unsigned int) R_386_NONE;
 303     }
 304   cache_ptr->howto = &elf_howto_table[indx];
 305 }
 306
 307 /* Return whether a symbol name implies a local label.  The UnixWare
 308    2.1 cc generates temporary symbols that start with .X, so we
 309    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
 310    If so, we should move the .X recognition into
 311    _bfd_elf_is_local_label_name.  */
 312
 313 static boolean
 314 elf_i386_is_local_label_name (abfd, name)
 315      bfd *abfd;
 316      const char *name;
 317 {
 318   if (name[0] == '.' && name[1] == 'X')
 319     return true;
 320
 321   return _bfd_elf_is_local_label_name (abfd, name);
 322 }
 323 \f
 324 /* Support for core dump NOTE sections.  */
 325 static boolean
 326 elf_i386_grok_prstatus (abfd, note)
 327      bfd *abfd;
 328      Elf_Internal_Note *note;
 329 {
 330   int offset;
 331   size_t raw_size;
 332
 333   switch (note->descsz)
 334     {
 335       default:
 336         return false;
 337
 338       case 144:         /* Linux/i386 */
 339         /* pr_cursig */
 340         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
 341
 342         /* pr_pid */
 343         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
 344
 345         /* pr_reg */
 346         offset = 72;
 347         raw_size = 68;
 348
 349         break;
 350     }
 351
 352   /* Make a ".reg/999" section.  */
 353   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 354                                           raw_size, note->descpos + offset);
 355 }
 356
 357 static boolean
 358 elf_i386_grok_psinfo (abfd, note)
 359      bfd *abfd;
 360      Elf_Internal_Note *note;
 361 {
 362   switch (note->descsz)
 363     {
 364       default:
 365         return false;
 366
 367       case 124:         /* Linux/i386 elf_prpsinfo */
 368         elf_tdata (abfd)->core_program
 369          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 370         elf_tdata (abfd)->core_command
 371          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 372     }
 373
 374   /* Note that for some reason, a spurious space is tacked
 375      onto the end of the args in some (at least one anyway)
 376      implementations, so strip it off if it exists.  */
 377
 378   {
 379     char *command = elf_tdata (abfd)->core_command;
 380     int n = strlen (command);
 381
 382     if (0 < n && command[n - 1] == ' ')
 383       command[n - 1] = '\0';
 384   }
 385
 386   return true;
 387 }
 388 \f
 389 /* Functions for the i386 ELF linker.
 390
 391    In order to gain some understanding of code in this file without
 392    knowing all the intricate details of the linker, note the
 393    following:
 394
 395    Functions named elf_i386_* are called by external routines, other
 396    functions are only called locally.  elf_i386_* functions appear
 397    in this file more or less in the order in which they are called
 398    from external routines.  eg. elf_i386_check_relocs is called
 399    early in the link process, elf_i386_finish_dynamic_sections is
 400    one of the last functions.  */
 401
 402
 403 /* The name of the dynamic interpreter.  This is put in the .interp
 404    section.  */
 405
 406
 407 #ifndef ELF_DYNAMIC_INTERPRETER
 408 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 409 #endif
 410
 411
 412 /* The size in bytes of an entry in the procedure linkage table.  */
 413
 414 #define PLT_ENTRY_SIZE 16
 415
 416 /* The first entry in an absolute procedure linkage table looks like
 417    this.  See the SVR4 ABI i386 supplement to see how this works.  */
 418
 419 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
 420 {
 421   0xff, 0x35,   /* pushl contents of address */
 422   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 423   0xff, 0x25,   /* jmp indirect */
 424   0, 0, 0, 0,   /* replaced with address of .got + 8.  */
 425   0, 0, 0, 0    /* pad out to 16 bytes.  */
 426 };
 427
 428 /* Subsequent entries in an absolute procedure linkage table look like
 429    this.  */
 430
 431 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
 432 {
 433   0xff, 0x25,   /* jmp indirect */
 434   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 435   0x68,         /* pushl immediate */
 436   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 437   0xe9,         /* jmp relative */
 438   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 439 };
 440
 441 /* The first entry in a PIC procedure linkage table look like this.  */
 442
 443 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
 444 {
 445   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 446   0xff, 0xa3, 8, 0, 0, 0,       /* jmp *8(%ebx) */
 447   0, 0, 0, 0                    /* pad out to 16 bytes.  */
 448 };
 449
 450 /* Subsequent entries in a PIC procedure linkage table look like this.  */
 451
 452 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
 453 {
 454   0xff, 0xa3,   /* jmp *offset(%ebx) */
 455   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 456   0x68,         /* pushl immediate */
 457   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 458   0xe9,         /* jmp relative */
 459   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 460 };
 461
 462 /* The i386 linker needs to keep track of the number of relocs that it
 463    decides to copy as dynamic relocs in check_relocs for each symbol.
 464    This is so that it can later discard them if they are found to be
 465    unnecessary.  We store the information in a field extending the
 466    regular ELF linker hash table.  */
 467
 468 struct elf_i386_dyn_relocs
 469 {
 470   struct elf_i386_dyn_relocs *next;
 471
 472   /* The input section of the reloc.  */
 473   asection *sec;
 474
 475   /* Total number of relocs copied for the input section.  */
 476   bfd_size_type count;
 477
 478   /* Number of pc-relative relocs copied for the input section.  */
 479   bfd_size_type pc_count;
 480 };
 481
 482 /* i386 ELF linker hash entry.  */
 483
 484 struct elf_i386_link_hash_entry
 485 {
 486   struct elf_link_hash_entry elf;
 487
 488   /* Track dynamic relocs copied for this symbol.  */
 489   struct elf_i386_dyn_relocs *dyn_relocs;
 490 };
 491
 492 /* i386 ELF linker hash table.  */
 493
 494 struct elf_i386_link_hash_table
 495 {
 496   struct elf_link_hash_table elf;
 497
 498   /* Short-cuts to get to dynamic linker sections.  */
 499   asection *sgot;
 500   asection *sgotplt;
 501   asection *srelgot;
 502   asection *splt;
 503   asection *srelplt;
 504   asection *sdynbss;
 505   asection *srelbss;
 506
 507   /* Small local sym to section mapping cache.  */
 508   struct sym_sec_cache sym_sec;
 509 };
 510
 511 /* Get the i386 ELF linker hash table from a link_info structure.  */
 512
 513 #define elf_i386_hash_table(p) \
 514   ((struct elf_i386_link_hash_table *) ((p)->hash))
 515
 516 /* Create an entry in an i386 ELF linker hash table.  */
 517
 518 static struct bfd_hash_entry *
 519 link_hash_newfunc (entry, table, string)
 520      struct bfd_hash_entry *entry;
 521      struct bfd_hash_table *table;
 522      const char *string;
 523 {
 524   /* Allocate the structure if it has not already been allocated by a
 525      subclass.  */
 526   if (entry == NULL)
 527     {
 528       entry = bfd_hash_allocate (table,
 529                                  sizeof (struct elf_i386_link_hash_entry));
 530       if (entry == NULL)
 531         return entry;
 532     }
 533
 534   /* Call the allocation method of the superclass.  */
 535   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 536   if (entry != NULL)
 537     {
 538       struct elf_i386_link_hash_entry *eh;
 539
 540       eh = (struct elf_i386_link_hash_entry *) entry;
 541       eh->dyn_relocs = NULL;
 542     }
 543
 544   return entry;
 545 }
 546
 547 /* Create an i386 ELF linker hash table.  */
 548
 549 static struct bfd_link_hash_table *
 550 elf_i386_link_hash_table_create (abfd)
 551      bfd *abfd;
 552 {
 553   struct elf_i386_link_hash_table *ret;
 554   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
 555
 556   ret = (struct elf_i386_link_hash_table *) bfd_alloc (abfd, amt);
 557   if (ret == NULL)
 558     return NULL;
 559
 560   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
 561     {
 562       bfd_release (abfd, ret);
 563       return NULL;
 564     }
 565
 566   ret->sgot = NULL;
 567   ret->sgotplt = NULL;
 568   ret->srelgot = NULL;
 569   ret->splt = NULL;
 570   ret->srelplt = NULL;
 571   ret->sdynbss = NULL;
 572   ret->srelbss = NULL;
 573   ret->sym_sec.abfd = NULL;
 574
 575   return &ret->elf.root;
 576 }
 577
 578 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
 579    shortcuts to them in our hash table.  */
 580
 581 static boolean
 582 create_got_section (dynobj, info)
 583      bfd *dynobj;
 584      struct bfd_link_info *info;
 585 {
 586   struct elf_i386_link_hash_table *htab;
 587
 588   if (! _bfd_elf_create_got_section (dynobj, info))
 589     return false;
 590
 591   htab = elf_i386_hash_table (info);
 592   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 593   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 594   if (!htab->sgot || !htab->sgotplt)
 595     abort ();
 596
 597   htab->srelgot = bfd_make_section (dynobj, ".rel.got");
 598   if (htab->srelgot == NULL
 599       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 600                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 601                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 602                                    | SEC_READONLY))
 603       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 604     return false;
 605   return true;
 606 }
 607
 608 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 609    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 610    hash table.  */
 611
 612 static boolean
 613 elf_i386_create_dynamic_sections (dynobj, info)
 614      bfd *dynobj;
 615      struct bfd_link_info *info;
 616 {
 617   struct elf_i386_link_hash_table *htab;
 618
 619   htab = elf_i386_hash_table (info);
 620   if (!htab->sgot && !create_got_section (dynobj, info))
 621     return false;
 622
 623   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 624     return false;
 625
 626   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 627   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
 628   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 629   if (!info->shared)
 630     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
 631
 632   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 633       || (!info->shared && !htab->srelbss))
 634     abort ();
 635
 636   return true;
 637 }
 638
 639 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 640
 641 static void
 642 elf_i386_copy_indirect_symbol (dir, ind)
 643      struct elf_link_hash_entry *dir, *ind;
 644 {
 645   struct elf_i386_link_hash_entry *edir, *eind;
 646
 647   edir = (struct elf_i386_link_hash_entry *) dir;
 648   eind = (struct elf_i386_link_hash_entry *) ind;
 649
 650   if (eind->dyn_relocs != NULL)
 651     {
 652       if (edir->dyn_relocs != NULL)
 653         {
 654           struct elf_i386_dyn_relocs **pp;
 655           struct elf_i386_dyn_relocs *p;
 656
 657           if (ind->root.type == bfd_link_hash_indirect)
 658             abort ();
 659
 660           /* Add reloc counts against the weak sym to the strong sym
 661              list.  Merge any entries against the same section.  */
 662           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 663             {
 664               struct elf_i386_dyn_relocs *q;
 665
 666               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 667                 if (q->sec == p->sec)
 668                   {
 669                     q->pc_count += p->pc_count;
 670                     q->count += p->count;
 671                     *pp = p->next;
 672                     break;
 673                   }
 674               if (q == NULL)
 675                 pp = &p->next;
 676             }
 677           *pp = edir->dyn_relocs;
 678         }
 679
 680       edir->dyn_relocs = eind->dyn_relocs;
 681       eind->dyn_relocs = NULL;
 682     }
 683
 684   _bfd_elf_link_hash_copy_indirect (dir, ind);
 685 }
 686
 687 /* Look through the relocs for a section during the first phase, and
 688    calculate needed space in the global offset table, procedure linkage
 689    table, and dynamic reloc sections.  */
 690
 691 static boolean
 692 elf_i386_check_relocs (abfd, info, sec, relocs)
 693      bfd *abfd;
 694      struct bfd_link_info *info;
 695      asection *sec;
 696      const Elf_Internal_Rela *relocs;
 697 {
 698   struct elf_i386_link_hash_table *htab;
 699   Elf_Internal_Shdr *symtab_hdr;
 700   struct elf_link_hash_entry **sym_hashes;
 701   const Elf_Internal_Rela *rel;
 702   const Elf_Internal_Rela *rel_end;
 703   asection *sreloc;
 704
 705   if (info->relocateable)
 706     return true;
 707
 708   htab = elf_i386_hash_table (info);
 709   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 710   sym_hashes = elf_sym_hashes (abfd);
 711
 712   sreloc = NULL;
 713
 714   rel_end = relocs + sec->reloc_count;
 715   for (rel = relocs; rel < rel_end; rel++)
 716     {
 717       unsigned long r_symndx;
 718       struct elf_link_hash_entry *h;
 719
 720       r_symndx = ELF32_R_SYM (rel->r_info);
 721
 722       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 723         {
 724           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
 725                                  bfd_archive_filename (abfd),
 726                                  r_symndx);
 727           return false;
 728         }
 729
 730       if (r_symndx < symtab_hdr->sh_info)
 731         h = NULL;
 732       else
 733         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 734
 735       switch (ELF32_R_TYPE (rel->r_info))
 736         {
 737         case R_386_GOT32:
 738           /* This symbol requires a global offset table entry.  */
 739           if (h != NULL)
 740             {
 741               h->got.refcount += 1;
 742             }
 743           else
 744             {
 745               bfd_signed_vma *local_got_refcounts;
 746
 747               /* This is a global offset table entry for a local symbol.  */
 748               local_got_refcounts = elf_local_got_refcounts (abfd);
 749               if (local_got_refcounts == NULL)
 750                 {
 751                   bfd_size_type size;
 752
 753                   size = symtab_hdr->sh_info;
 754                   size *= sizeof (bfd_signed_vma);
 755                   local_got_refcounts = ((bfd_signed_vma *)
 756                                          bfd_zalloc (abfd, size));
 757                   if (local_got_refcounts == NULL)
 758                     return false;
 759                   elf_local_got_refcounts (abfd) = local_got_refcounts;
 760                 }
 761               local_got_refcounts[r_symndx] += 1;
 762             }
 763           /* Fall through */
 764
 765         case R_386_GOTOFF:
 766         case R_386_GOTPC:
 767           if (htab->sgot == NULL)
 768             {
 769               if (htab->elf.dynobj == NULL)
 770                 htab->elf.dynobj = abfd;
 771               if (!create_got_section (htab->elf.dynobj, info))
 772                 return false;
 773             }
 774           break;
 775
 776         case R_386_PLT32:
 777           /* This symbol requires a procedure linkage table entry.  We
 778              actually build the entry in adjust_dynamic_symbol,
 779              because this might be a case of linking PIC code which is
 780              never referenced by a dynamic object, in which case we
 781              don't need to generate a procedure linkage table entry
 782              after all.  */
 783
 784           /* If this is a local symbol, we resolve it directly without
 785              creating a procedure linkage table entry.  */
 786           if (h == NULL)
 787             continue;
 788
 789           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 790           h->plt.refcount += 1;
 791           break;
 792
 793         case R_386_32:
 794         case R_386_PC32:
 795           if (h != NULL && !info->shared)
 796             {
 797               /* If this reloc is in a read-only section, we might
 798                  need a copy reloc.  We can't check reliably at this
 799                  stage whether the section is read-only, as input
 800                  sections have not yet been mapped to output sections.
 801                  Tentatively set the flag for now, and correct in
 802                  adjust_dynamic_symbol.  */
 803               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 804
 805               /* We may need a .plt entry if the function this reloc
 806                  refers to is in a shared lib.  */
 807               h->plt.refcount += 1;
 808             }
 809
 810           /* If we are creating a shared library, and this is a reloc
 811              against a global symbol, or a non PC relative reloc
 812              against a local symbol, then we need to copy the reloc
 813              into the shared library.  However, if we are linking with
 814              -Bsymbolic, we do not need to copy a reloc against a
 815              global symbol which is defined in an object we are
 816              including in the link (i.e., DEF_REGULAR is set).  At
 817              this point we have not seen all the input files, so it is
 818              possible that DEF_REGULAR is not set now but will be set
 819              later (it is never cleared).  In case of a weak definition,
 820              DEF_REGULAR may be cleared later by a strong definition in
 821              a shared library.  We account for that possibility below by
 822              storing information in the relocs_copied field of the hash
 823              table entry.  A similar situation occurs when creating
 824              shared libraries and symbol visibility changes render the
 825              symbol local.
 826
 827              If on the other hand, we are creating an executable, we
 828              may need to keep relocations for symbols satisfied by a
 829              dynamic library if we manage to avoid copy relocs for the
 830              symbol.  */
 831           if ((info->shared
 832                && (sec->flags & SEC_ALLOC) != 0
 833                && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
 834                    || (h != NULL
 835                        && (! info->symbolic
 836                            || h->root.type == bfd_link_hash_defweak
 837                            || (h->elf_link_hash_flags
 838                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 839               || (!info->shared
 840                   && (sec->flags & SEC_ALLOC) != 0
 841                   && h != NULL
 842                   && (h->root.type == bfd_link_hash_defweak
 843                       || (h->elf_link_hash_flags
 844                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
 845             {
 846               struct elf_i386_dyn_relocs *p;
 847               struct elf_i386_dyn_relocs **head;
 848
 849               /* We must copy these reloc types into the output file.
 850                  Create a reloc section in dynobj and make room for
 851                  this reloc.  */
 852               if (sreloc == NULL)
 853                 {
 854                   const char *name;
 855                   bfd *dynobj;
 856                   unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
 857                   unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
 858
 859                   name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
 860                   if (name == NULL)
 861                     return false;
 862
 863                   if (strncmp (name, ".rel", 4) != 0
 864                       || strcmp (bfd_get_section_name (abfd, sec),
 865                                  name + 4) != 0)
 866                     {
 867                       (*_bfd_error_handler)
 868                         (_("%s: bad relocation section name `%s\'"),
 869                          bfd_archive_filename (abfd), name);
 870                     }
 871
 872                   if (htab->elf.dynobj == NULL)
 873                     htab->elf.dynobj = abfd;
 874
 875                   dynobj = htab->elf.dynobj;
 876                   sreloc = bfd_get_section_by_name (dynobj, name);
 877                   if (sreloc == NULL)
 878                     {
 879                       flagword flags;
 880
 881                       sreloc = bfd_make_section (dynobj, name);
 882                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 883                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 884                       if ((sec->flags & SEC_ALLOC) != 0)
 885                         flags |= SEC_ALLOC | SEC_LOAD;
 886                       if (sreloc == NULL
 887                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 888                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 889                         return false;
 890                     }
 891                   elf_section_data (sec)->sreloc = sreloc;
 892                 }
 893
 894               /* If this is a global symbol, we count the number of
 895                  relocations we need for this symbol.  */
 896               if (h != NULL)
 897                 {
 898                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
 899                 }
 900               else
 901                 {
 902                   /* Track dynamic relocs needed for local syms too.
 903                      We really need local syms available to do this
 904                      easily.  Oh well.  */
 905
 906                   asection *s;
 907                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
 908                                                  sec, r_symndx);
 909                   if (s == NULL)
 910                     return false;
 911
 912                   head = ((struct elf_i386_dyn_relocs **)
 913                           &elf_section_data (s)->local_dynrel);
 914                 }
 915
 916               p = *head;
 917               if (p == NULL || p->sec != sec)
 918                 {
 919                   bfd_size_type amt = sizeof *p;
 920                   p = ((struct elf_i386_dyn_relocs *)
 921                        bfd_alloc (htab->elf.dynobj, amt));
 922                   if (p == NULL)
 923                     return false;
 924                   p->next = *head;
 925                   *head = p;
 926                   p->sec = sec;
 927                   p->count = 0;
 928                   p->pc_count = 0;
 929                 }
 930
 931               p->count += 1;
 932               if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
 933                 p->pc_count += 1;
 934             }
 935           break;
 936
 937           /* This relocation describes the C++ object vtable hierarchy.
 938              Reconstruct it for later use during GC.  */
 939         case R_386_GNU_VTINHERIT:
 940           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 941             return false;
 942           break;
 943
 944           /* This relocation describes which C++ vtable entries are actually
 945              used.  Record for later use during GC.  */
 946         case R_386_GNU_VTENTRY:
 947           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
 948             return false;
 949           break;
 950
 951         default:
 952           break;
 953         }
 954     }
 955
 956   return true;
 957 }
 958
 959 /* Return the section that should be marked against GC for a given
 960    relocation.  */
 961
 962 static asection *
 963 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
 964      bfd *abfd;
 965      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 966      Elf_Internal_Rela *rel;
 967      struct elf_link_hash_entry *h;
 968      Elf_Internal_Sym *sym;
 969 {
 970   if (h != NULL)
 971     {
 972       switch (ELF32_R_TYPE (rel->r_info))
 973         {
 974         case R_386_GNU_VTINHERIT:
 975         case R_386_GNU_VTENTRY:
 976           break;
 977
 978         default:
 979           switch (h->root.type)
 980             {
 981             case bfd_link_hash_defined:
 982             case bfd_link_hash_defweak:
 983               return h->root.u.def.section;
 984
 985             case bfd_link_hash_common:
 986               return h->root.u.c.p->section;
 987
 988             default:
 989               break;
 990             }
 991         }
 992     }
 993   else
 994     {
 995       return bfd_section_from_elf_index (abfd, sym->st_shndx);
 996     }
 997
 998   return NULL;
 999 }
1000
1001 /* Update the got entry reference counts for the section being removed.  */
1002
1003 static boolean
1004 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
1005      bfd *abfd;
1006      struct bfd_link_info *info;
1007      asection *sec;
1008      const Elf_Internal_Rela *relocs;
1009 {
1010   Elf_Internal_Shdr *symtab_hdr;
1011   struct elf_link_hash_entry **sym_hashes;
1012   bfd_signed_vma *local_got_refcounts;
1013   const Elf_Internal_Rela *rel, *relend;
1014   unsigned long r_symndx;
1015   struct elf_link_hash_entry *h;
1016
1017   elf_section_data (sec)->local_dynrel = NULL;
1018
1019   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1020   sym_hashes = elf_sym_hashes (abfd);
1021   local_got_refcounts = elf_local_got_refcounts (abfd);
1022
1023   relend = relocs + sec->reloc_count;
1024   for (rel = relocs; rel < relend; rel++)
1025     switch (ELF32_R_TYPE (rel->r_info))
1026       {
1027       case R_386_GOT32:
1028       case R_386_GOTOFF:
1029       case R_386_GOTPC:
1030         r_symndx = ELF32_R_SYM (rel->r_info);
1031         if (r_symndx >= symtab_hdr->sh_info)
1032           {
1033             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1034             if (h->got.refcount > 0)
1035               h->got.refcount -= 1;
1036           }
1037         else if (local_got_refcounts != NULL)
1038           {
1039             if (local_got_refcounts[r_symndx] > 0)
1040               local_got_refcounts[r_symndx] -= 1;
1041           }
1042         break;
1043
1044       case R_386_32:
1045       case R_386_PC32:
1046         r_symndx = ELF32_R_SYM (rel->r_info);
1047         if (r_symndx >= symtab_hdr->sh_info)
1048           {
1049             struct elf_i386_link_hash_entry *eh;
1050             struct elf_i386_dyn_relocs **pp;
1051             struct elf_i386_dyn_relocs *p;
1052
1053             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1054
1055             if (!info->shared && h->plt.refcount > 0)
1056               h->plt.refcount -= 1;
1057
1058             eh = (struct elf_i386_link_hash_entry *) h;
1059
1060             for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1061               if (p->sec == sec)
1062                 {
1063                   if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
1064                     p->pc_count -= 1;
1065                   p->count -= 1;
1066                   if (p->count == 0)
1067                     *pp = p->next;
1068                   break;
1069                 }
1070           }
1071         break;
1072
1073       case R_386_PLT32:
1074         r_symndx = ELF32_R_SYM (rel->r_info);
1075         if (r_symndx >= symtab_hdr->sh_info)
1076           {
1077             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1078             if (h->plt.refcount > 0)
1079               h->plt.refcount -= 1;
1080           }
1081         break;
1082
1083       default:
1084         break;
1085       }
1086
1087   return true;
1088 }
1089
1090 /* Adjust a symbol defined by a dynamic object and referenced by a
1091    regular object.  The current definition is in some section of the
1092    dynamic object, but we're not including those sections.  We have to
1093    change the definition to something the rest of the link can
1094    understand.  */
1095
1096 static boolean
1097 elf_i386_adjust_dynamic_symbol (info, h)
1098      struct bfd_link_info *info;
1099      struct elf_link_hash_entry *h;
1100 {
1101   struct elf_i386_link_hash_table *htab;
1102   struct elf_i386_link_hash_entry * eh;
1103   struct elf_i386_dyn_relocs *p;
1104   asection *s;
1105   unsigned int power_of_two;
1106
1107   /* If this is a function, put it in the procedure linkage table.  We
1108      will fill in the contents of the procedure linkage table later,
1109      when we know the address of the .got section.  */
1110   if (h->type == STT_FUNC
1111       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1112     {
1113       if (h->plt.refcount <= 0
1114           || (! info->shared
1115               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1116               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1117               && h->root.type != bfd_link_hash_undefweak
1118               && h->root.type != bfd_link_hash_undefined))
1119         {
1120           /* This case can occur if we saw a PLT32 reloc in an input
1121              file, but the symbol was never referred to by a dynamic
1122              object, or if all references were garbage collected.  In
1123              such a case, we don't actually need to build a procedure
1124              linkage table, and we can just do a PC32 reloc instead.  */
1125           h->plt.offset = (bfd_vma) -1;
1126           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1127         }
1128
1129       return true;
1130     }
1131   else
1132     /* It's possible that we incorrectly decided a .plt reloc was
1133        needed for an R_386_PC32 reloc to a non-function sym in
1134        check_relocs.  We can't decide accurately between function and
1135        non-function syms in check-relocs;  Objects loaded later in
1136        the link may change h->type.  So fix it now.  */
1137     h->plt.offset = (bfd_vma) -1;
1138
1139   /* If this is a weak symbol, and there is a real definition, the
1140      processor independent code will have arranged for us to see the
1141      real definition first, and we can just use the same value.  */
1142   if (h->weakdef != NULL)
1143     {
1144       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1145                   || h->weakdef->root.type == bfd_link_hash_defweak);
1146       h->root.u.def.section = h->weakdef->root.u.def.section;
1147       h->root.u.def.value = h->weakdef->root.u.def.value;
1148       return true;
1149     }
1150
1151   /* This is a reference to a symbol defined by a dynamic object which
1152      is not a function.  */
1153
1154   /* If we are creating a shared library, we must presume that the
1155      only references to the symbol are via the global offset table.
1156      For such cases we need not do anything here; the relocations will
1157      be handled correctly by relocate_section.  */
1158   if (info->shared)
1159     return true;
1160
1161   /* If there are no references to this symbol that do not use the
1162      GOT, we don't need to generate a copy reloc.  */
1163   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1164     return true;
1165
1166   /* If -z nocopyreloc was given, we won't generate them either.  */
1167   if (info->nocopyreloc)
1168     {
1169       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1170       return true;
1171     }
1172
1173   eh = (struct elf_i386_link_hash_entry *) h;
1174   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1175     {
1176       s = p->sec->output_section;
1177       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1178         break;
1179     }
1180
1181   /* If we didn't find any dynamic relocs in read-only sections, then
1182      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1183   if (p == NULL)
1184     {
1185       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1186       return true;
1187     }
1188
1189   /* We must allocate the symbol in our .dynbss section, which will
1190      become part of the .bss section of the executable.  There will be
1191      an entry for this symbol in the .dynsym section.  The dynamic
1192      object will contain position independent code, so all references
1193      from the dynamic object to this symbol will go through the global
1194      offset table.  The dynamic linker will use the .dynsym entry to
1195      determine the address it must put in the global offset table, so
1196      both the dynamic object and the regular object will refer to the
1197      same memory location for the variable.  */
1198
1199   htab = elf_i386_hash_table (info);
1200
1201   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1202      copy the initial value out of the dynamic object and into the
1203      runtime process image.  */
1204   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1205     {
1206       htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
1207       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1208     }
1209
1210   /* We need to figure out the alignment required for this symbol.  I
1211      have no idea how ELF linkers handle this.  */
1212   power_of_two = bfd_log2 (h->size);
1213   if (power_of_two > 3)
1214     power_of_two = 3;
1215
1216   /* Apply the required alignment.  */
1217   s = htab->sdynbss;
1218   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1219   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1220     {
1221       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1222         return false;
1223     }
1224
1225   /* Define the symbol as being at this point in the section.  */
1226   h->root.u.def.section = s;
1227   h->root.u.def.value = s->_raw_size;
1228
1229   /* Increment the section size to make room for the symbol.  */
1230   s->_raw_size += h->size;
1231
1232   return true;
1233 }
1234
1235 /* This is the condition under which elf_i386_finish_dynamic_symbol
1236    will be called from elflink.h.  If elflink.h doesn't call our
1237    finish_dynamic_symbol routine, we'll need to do something about
1238    initializing any .plt and .got entries in elf_i386_relocate_section.  */
1239 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1240   ((DYN)                                                                \
1241    && ((INFO)->shared                                                   \
1242        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
1243    && ((H)->dynindx != -1                                               \
1244        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1245
1246 /* Allocate space in .plt, .got and associated reloc sections for
1247    dynamic relocs.  */
1248
1249 static boolean
1250 allocate_dynrelocs (h, inf)
1251      struct elf_link_hash_entry *h;
1252      PTR inf;
1253 {
1254   struct bfd_link_info *info;
1255   struct elf_i386_link_hash_table *htab;
1256   struct elf_i386_link_hash_entry *eh;
1257   struct elf_i386_dyn_relocs *p;
1258
1259   if (h->root.type == bfd_link_hash_indirect)
1260     return true;
1261
1262   if (h->root.type == bfd_link_hash_warning)
1263     /* When warning symbols are created, they **replace** the "real"
1264        entry in the hash table, thus we never get to see the real
1265        symbol in a hash traversal.  So look at it now.  */
1266     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1267
1268   info = (struct bfd_link_info *) inf;
1269   htab = elf_i386_hash_table (info);
1270
1271   if (htab->elf.dynamic_sections_created
1272       && h->plt.refcount > 0)
1273     {
1274       /* Make sure this symbol is output as a dynamic symbol.
1275          Undefined weak syms won't yet be marked as dynamic.  */
1276       if (h->dynindx == -1
1277           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1278         {
1279           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1280             return false;
1281         }
1282
1283       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1284         {
1285           asection *s = htab->splt;
1286
1287           /* If this is the first .plt entry, make room for the special
1288              first entry.  */
1289           if (s->_raw_size == 0)
1290             s->_raw_size += PLT_ENTRY_SIZE;
1291
1292           h->plt.offset = s->_raw_size;
1293
1294           /* If this symbol is not defined in a regular file, and we are
1295              not generating a shared library, then set the symbol to this
1296              location in the .plt.  This is required to make function
1297              pointers compare as equal between the normal executable and
1298              the shared library.  */
1299           if (! info->shared
1300               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1301             {
1302               h->root.u.def.section = s;
1303               h->root.u.def.value = h->plt.offset;
1304             }
1305
1306           /* Make room for this entry.  */
1307           s->_raw_size += PLT_ENTRY_SIZE;
1308
1309           /* We also need to make an entry in the .got.plt section, which
1310              will be placed in the .got section by the linker script.  */
1311           htab->sgotplt->_raw_size += 4;
1312
1313           /* We also need to make an entry in the .rel.plt section.  */
1314           htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
1315         }
1316       else
1317         {
1318           h->plt.offset = (bfd_vma) -1;
1319           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1320         }
1321     }
1322   else
1323     {
1324       h->plt.offset = (bfd_vma) -1;
1325       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1326     }
1327
1328   if (h->got.refcount > 0)
1329     {
1330       asection *s;
1331       boolean dyn;
1332
1333       /* Make sure this symbol is output as a dynamic symbol.
1334          Undefined weak syms won't yet be marked as dynamic.  */
1335       if (h->dynindx == -1
1336           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1337         {
1338           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1339             return false;
1340         }
1341
1342       s = htab->sgot;
1343       h->got.offset = s->_raw_size;
1344       s->_raw_size += 4;
1345       dyn = htab->elf.dynamic_sections_created;
1346       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1347         htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1348     }
1349   else
1350     h->got.offset = (bfd_vma) -1;
1351
1352   eh = (struct elf_i386_link_hash_entry *) h;
1353   if (eh->dyn_relocs == NULL)
1354     return true;
1355
1356   /* In the shared -Bsymbolic case, discard space allocated for
1357      dynamic pc-relative relocs against symbols which turn out to be
1358      defined in regular objects.  For the normal shared case, discard
1359      space for pc-relative relocs that have become local due to symbol
1360      visibility changes.  */
1361
1362   if (info->shared)
1363     {
1364       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1365           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1366               || info->symbolic))
1367         {
1368           struct elf_i386_dyn_relocs **pp;
1369
1370           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1371             {
1372               p->count -= p->pc_count;
1373               p->pc_count = 0;
1374               if (p->count == 0)
1375                 *pp = p->next;
1376               else
1377                 pp = &p->next;
1378             }
1379         }
1380     }
1381   else
1382     {
1383       /* For the non-shared case, discard space for relocs against
1384          symbols which turn out to need copy relocs or are not
1385          dynamic.  */
1386
1387       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1388           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1389                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1390               || (htab->elf.dynamic_sections_created
1391                   && (h->root.type == bfd_link_hash_undefweak
1392                       || h->root.type == bfd_link_hash_undefined))))
1393         {
1394           /* Make sure this symbol is output as a dynamic symbol.
1395              Undefined weak syms won't yet be marked as dynamic.  */
1396           if (h->dynindx == -1
1397               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1398             {
1399               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1400                 return false;
1401             }
1402
1403           /* If that succeeded, we know we'll be keeping all the
1404              relocs.  */
1405           if (h->dynindx != -1)
1406             goto keep;
1407         }
1408
1409       eh->dyn_relocs = NULL;
1410
1411     keep: ;
1412     }
1413
1414   /* Finally, allocate space.  */
1415   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1416     {
1417       asection *sreloc = elf_section_data (p->sec)->sreloc;
1418       sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1419     }
1420
1421   return true;
1422 }
1423
1424 /* Find any dynamic relocs that apply to read-only sections.  */
1425
1426 static boolean
1427 readonly_dynrelocs (h, inf)
1428      struct elf_link_hash_entry *h;
1429      PTR inf;
1430 {
1431   struct elf_i386_link_hash_entry *eh;
1432   struct elf_i386_dyn_relocs *p;
1433
1434   if (h->root.type == bfd_link_hash_warning)
1435     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1436
1437   eh = (struct elf_i386_link_hash_entry *) h;
1438   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1439     {
1440       asection *s = p->sec->output_section;
1441
1442       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1443         {
1444           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1445
1446           info->flags |= DF_TEXTREL;
1447
1448           /* Not an error, just cut short the traversal.  */
1449           return false;
1450         }
1451     }
1452   return true;
1453 }
1454
1455 /* Set the sizes of the dynamic sections.  */
1456
1457 static boolean
1458 elf_i386_size_dynamic_sections (output_bfd, info)
1459      bfd *output_bfd ATTRIBUTE_UNUSED;
1460      struct bfd_link_info *info;
1461 {
1462   struct elf_i386_link_hash_table *htab;
1463   bfd *dynobj;
1464   asection *s;
1465   boolean relocs;
1466   bfd *ibfd;
1467
1468   htab = elf_i386_hash_table (info);
1469   dynobj = htab->elf.dynobj;
1470   if (dynobj == NULL)
1471     abort ();
1472
1473   if (htab->elf.dynamic_sections_created)
1474     {
1475       /* Set the contents of the .interp section to the interpreter.  */
1476       if (! info->shared)
1477         {
1478           s = bfd_get_section_by_name (dynobj, ".interp");
1479           if (s == NULL)
1480             abort ();
1481           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1482           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1483         }
1484     }
1485
1486   /* Set up .got offsets for local syms, and space for local dynamic
1487      relocs.  */
1488   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1489     {
1490       bfd_signed_vma *local_got;
1491       bfd_signed_vma *end_local_got;
1492       bfd_size_type locsymcount;
1493       Elf_Internal_Shdr *symtab_hdr;
1494       asection *srel;
1495
1496       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1497         continue;
1498
1499       for (s = ibfd->sections; s != NULL; s = s->next)
1500         {
1501           struct elf_i386_dyn_relocs *p;
1502
1503           for (p = *((struct elf_i386_dyn_relocs **)
1504                      &elf_section_data (s)->local_dynrel);
1505                p != NULL;
1506                p = p->next)
1507             {
1508               if (!bfd_is_abs_section (p->sec)
1509                   && bfd_is_abs_section (p->sec->output_section))
1510                 {
1511                   /* Input section has been discarded, either because
1512                      it is a copy of a linkonce section or due to
1513                      linker script /DISCARD/, so we'll be discarding
1514                      the relocs too.  */
1515                 }
1516               else if (p->count != 0)
1517                 {
1518                   srel = elf_section_data (p->sec)->sreloc;
1519                   srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
1520                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1521                     info->flags |= DF_TEXTREL;
1522                 }
1523             }
1524         }
1525
1526       local_got = elf_local_got_refcounts (ibfd);
1527       if (!local_got)
1528         continue;
1529
1530       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1531       locsymcount = symtab_hdr->sh_info;
1532       end_local_got = local_got + locsymcount;
1533       s = htab->sgot;
1534       srel = htab->srelgot;
1535       for (; local_got < end_local_got; ++local_got)
1536         {
1537           if (*local_got > 0)
1538             {
1539               *local_got = s->_raw_size;
1540               s->_raw_size += 4;
1541               if (info->shared)
1542                 srel->_raw_size += sizeof (Elf32_External_Rel);
1543             }
1544           else
1545             *local_got = (bfd_vma) -1;
1546         }
1547     }
1548
1549   /* Allocate global sym .plt and .got entries, and space for global
1550      sym dynamic relocs.  */
1551   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1552
1553   /* We now have determined the sizes of the various dynamic sections.
1554      Allocate memory for them.  */
1555   relocs = false;
1556   for (s = dynobj->sections; s != NULL; s = s->next)
1557     {
1558       if ((s->flags & SEC_LINKER_CREATED) == 0)
1559         continue;
1560
1561       if (s == htab->splt
1562           || s == htab->sgot
1563           || s == htab->sgotplt)
1564         {
1565           /* Strip this section if we don't need it; see the
1566              comment below.  */
1567         }
1568       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1569         {
1570           if (s->_raw_size != 0 && s != htab->srelplt)
1571             relocs = true;
1572
1573           /* We use the reloc_count field as a counter if we need
1574              to copy relocs into the output file.  */
1575           s->reloc_count = 0;
1576         }
1577       else
1578         {
1579           /* It's not one of our sections, so don't allocate space.  */
1580           continue;
1581         }
1582
1583       if (s->_raw_size == 0)
1584         {
1585           /* If we don't need this section, strip it from the
1586              output file.  This is mostly to handle .rel.bss and
1587              .rel.plt.  We must create both sections in
1588              create_dynamic_sections, because they must be created
1589              before the linker maps input sections to output
1590              sections.  The linker does that before
1591              adjust_dynamic_symbol is called, and it is that
1592              function which decides whether anything needs to go
1593              into these sections.  */
1594
1595           _bfd_strip_section_from_output (info, s);
1596           continue;
1597         }
1598
1599       /* Allocate memory for the section contents.  We use bfd_zalloc
1600          here in case unused entries are not reclaimed before the
1601          section's contents are written out.  This should not happen,
1602          but this way if it does, we get a R_386_NONE reloc instead
1603          of garbage.  */
1604       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1605       if (s->contents == NULL)
1606         return false;
1607     }
1608
1609   if (htab->elf.dynamic_sections_created)
1610     {
1611       /* Add some entries to the .dynamic section.  We fill in the
1612          values later, in elf_i386_finish_dynamic_sections, but we
1613          must add the entries now so that we get the correct size for
1614          the .dynamic section.  The DT_DEBUG entry is filled in by the
1615          dynamic linker and used by the debugger.  */
1616 #define add_dynamic_entry(TAG, VAL) \
1617   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1618
1619       if (! info->shared)
1620         {
1621           if (!add_dynamic_entry (DT_DEBUG, 0))
1622             return false;
1623         }
1624
1625       if (htab->splt->_raw_size != 0)
1626         {
1627           if (!add_dynamic_entry (DT_PLTGOT, 0)
1628               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1629               || !add_dynamic_entry (DT_PLTREL, DT_REL)
1630               || !add_dynamic_entry (DT_JMPREL, 0))
1631             return false;
1632         }
1633
1634       if (relocs)
1635         {
1636           if (!add_dynamic_entry (DT_REL, 0)
1637               || !add_dynamic_entry (DT_RELSZ, 0)
1638               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1639             return false;
1640
1641           /* If any dynamic relocs apply to a read-only section,
1642              then we need a DT_TEXTREL entry.  */
1643           if ((info->flags & DF_TEXTREL) == 0)
1644             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1645                                     (PTR) info);
1646
1647           if ((info->flags & DF_TEXTREL) != 0)
1648             {
1649               if (!add_dynamic_entry (DT_TEXTREL, 0))
1650                 return false;
1651             }
1652         }
1653     }
1654 #undef add_dynamic_entry
1655
1656   return true;
1657 }
1658
1659 /* Set the correct type for an x86 ELF section.  We do this by the
1660    section name, which is a hack, but ought to work.  */
1661
1662 static boolean
1663 elf_i386_fake_sections (abfd, hdr, sec)
1664      bfd *abfd ATTRIBUTE_UNUSED;
1665      Elf32_Internal_Shdr *hdr;
1666      asection *sec;
1667 {
1668   register const char *name;
1669
1670   name = bfd_get_section_name (abfd, sec);
1671
1672   /* This is an ugly, but unfortunately necessary hack that is
1673      needed when producing EFI binaries on x86. It tells
1674      elf.c:elf_fake_sections() not to consider ".reloc" as a section
1675      containing ELF relocation info.  We need this hack in order to
1676      be able to generate ELF binaries that can be translated into
1677      EFI applications (which are essentially COFF objects).  Those
1678      files contain a COFF ".reloc" section inside an ELFNN object,
1679      which would normally cause BFD to segfault because it would
1680      attempt to interpret this section as containing relocation
1681      entries for section "oc".  With this hack enabled, ".reloc"
1682      will be treated as a normal data section, which will avoid the
1683      segfault.  However, you won't be able to create an ELFNN binary
1684      with a section named "oc" that needs relocations, but that's
1685      the kind of ugly side-effects you get when detecting section
1686      types based on their names...  In practice, this limitation is
1687      unlikely to bite.  */
1688   if (strcmp (name, ".reloc") == 0)
1689     hdr->sh_type = SHT_PROGBITS;
1690
1691   return true;
1692 }
1693
1694 /* Relocate an i386 ELF section.  */
1695
1696 static boolean
1697 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1698                            contents, relocs, local_syms, local_sections)
1699      bfd *output_bfd;
1700      struct bfd_link_info *info;
1701      bfd *input_bfd;
1702      asection *input_section;
1703      bfd_byte *contents;
1704      Elf_Internal_Rela *relocs;
1705      Elf_Internal_Sym *local_syms;
1706      asection **local_sections;
1707 {
1708   struct elf_i386_link_hash_table *htab;
1709   Elf_Internal_Shdr *symtab_hdr;
1710   struct elf_link_hash_entry **sym_hashes;
1711   bfd_vma *local_got_offsets;
1712   Elf_Internal_Rela *rel;
1713   Elf_Internal_Rela *relend;
1714
1715   htab = elf_i386_hash_table (info);
1716   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1717   sym_hashes = elf_sym_hashes (input_bfd);
1718   local_got_offsets = elf_local_got_offsets (input_bfd);
1719
1720   rel = relocs;
1721   relend = relocs + input_section->reloc_count;
1722   for (; rel < relend; rel++)
1723     {
1724       int r_type;
1725       reloc_howto_type *howto;
1726       unsigned long r_symndx;
1727       struct elf_link_hash_entry *h;
1728       Elf_Internal_Sym *sym;
1729       asection *sec;
1730       bfd_vma off;
1731       bfd_vma relocation;
1732       boolean unresolved_reloc;
1733       bfd_reloc_status_type r;
1734       unsigned int indx;
1735
1736       r_type = ELF32_R_TYPE (rel->r_info);
1737       if (r_type == (int) R_386_GNU_VTINHERIT
1738           || r_type == (int) R_386_GNU_VTENTRY)
1739         continue;
1740
1741       if ((indx = (unsigned) r_type) >= R_386_standard
1742           && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1743               >= R_386_ext - R_386_standard))
1744         {
1745           bfd_set_error (bfd_error_bad_value);
1746           return false;
1747         }
1748       howto = elf_howto_table + indx;
1749
1750       r_symndx = ELF32_R_SYM (rel->r_info);
1751
1752       if (info->relocateable)
1753         {
1754           /* This is a relocatable link.  We don't have to change
1755              anything, unless the reloc is against a section symbol,
1756              in which case we have to adjust according to where the
1757              section symbol winds up in the output section.  */
1758           if (r_symndx < symtab_hdr->sh_info)
1759             {
1760               sym = local_syms + r_symndx;
1761               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1762                 {
1763                   bfd_vma val;
1764
1765                   sec = local_sections[r_symndx];
1766                   val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1767                   val += sec->output_offset + sym->st_value;
1768                   bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1769                 }
1770             }
1771           continue;
1772         }
1773
1774       /* This is a final link.  */
1775       h = NULL;
1776       sym = NULL;
1777       sec = NULL;
1778       unresolved_reloc = false;
1779       if (r_symndx < symtab_hdr->sh_info)
1780         {
1781           sym = local_syms + r_symndx;
1782           sec = local_sections[r_symndx];
1783           relocation = (sec->output_section->vma
1784                         + sec->output_offset
1785                         + sym->st_value);
1786           if ((sec->flags & SEC_MERGE)
1787               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1788             {
1789               asection *msec;
1790               bfd_vma addend;
1791
1792               if (howto->src_mask != 0xffffffff)
1793                 {
1794                   (*_bfd_error_handler)
1795                     (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1796                      bfd_archive_filename (input_bfd),
1797                      bfd_get_section_name (input_bfd, input_section),
1798                      (long) rel->r_offset, howto->name);
1799                   return false;
1800                 }
1801
1802               addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
1803               msec = sec;
1804               addend =
1805                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1806                 - relocation;
1807               addend += msec->output_section->vma + msec->output_offset;
1808               bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
1809             }
1810         }
1811       else
1812         {
1813           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1814           while (h->root.type == bfd_link_hash_indirect
1815                  || h->root.type == bfd_link_hash_warning)
1816             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1817
1818           relocation = 0;
1819           if (h->root.type == bfd_link_hash_defined
1820               || h->root.type == bfd_link_hash_defweak)
1821             {
1822               sec = h->root.u.def.section;
1823               if (sec->output_section == NULL)
1824                 /* Set a flag that will be cleared later if we find a
1825                    relocation value for this symbol.  output_section
1826                    is typically NULL for symbols satisfied by a shared
1827                    library.  */
1828                 unresolved_reloc = true;
1829               else
1830                 relocation = (h->root.u.def.value
1831                               + sec->output_section->vma
1832                               + sec->output_offset);
1833             }
1834           else if (h->root.type == bfd_link_hash_undefweak)
1835             ;
1836           else if (info->shared
1837                    && (!info->symbolic || info->allow_shlib_undefined)
1838                    && !info->no_undefined
1839                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1840             ;
1841           else
1842             {
1843               if (! ((*info->callbacks->undefined_symbol)
1844                      (info, h->root.root.string, input_bfd,
1845                       input_section, rel->r_offset,
1846                       (!info->shared || info->no_undefined
1847                        || ELF_ST_VISIBILITY (h->other)))))
1848                 return false;
1849             }
1850         }
1851
1852       switch (r_type)
1853         {
1854         case R_386_GOT32:
1855           /* Relocation is to the entry for this symbol in the global
1856              offset table.  */
1857           if (htab->sgot == NULL)
1858             abort ();
1859
1860           if (h != NULL)
1861             {
1862               boolean dyn;
1863
1864               off = h->got.offset;
1865               dyn = htab->elf.dynamic_sections_created;
1866               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1867                   || (info->shared
1868                       && (info->symbolic
1869                           || h->dynindx == -1
1870                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1871                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1872                 {
1873                   /* This is actually a static link, or it is a
1874                      -Bsymbolic link and the symbol is defined
1875                      locally, or the symbol was forced to be local
1876                      because of a version file.  We must initialize
1877                      this entry in the global offset table.  Since the
1878                      offset must always be a multiple of 4, we use the
1879                      least significant bit to record whether we have
1880                      initialized it already.
1881
1882                      When doing a dynamic link, we create a .rel.got
1883                      relocation entry to initialize the value.  This
1884                      is done in the finish_dynamic_symbol routine.  */
1885                   if ((off & 1) != 0)
1886                     off &= ~1;
1887                   else
1888                     {
1889                       bfd_put_32 (output_bfd, relocation,
1890                                   htab->sgot->contents + off);
1891                       h->got.offset |= 1;
1892                     }
1893                 }
1894               else
1895                 unresolved_reloc = false;
1896             }
1897           else
1898             {
1899               if (local_got_offsets == NULL)
1900                 abort ();
1901
1902               off = local_got_offsets[r_symndx];
1903
1904               /* The offset must always be a multiple of 4.  We use
1905                  the least significant bit to record whether we have
1906                  already generated the necessary reloc.  */
1907               if ((off & 1) != 0)
1908                 off &= ~1;
1909               else
1910                 {
1911                   bfd_put_32 (output_bfd, relocation,
1912                               htab->sgot->contents + off);
1913
1914                   if (info->shared)
1915                     {
1916                       asection *srelgot;
1917                       Elf_Internal_Rel outrel;
1918                       Elf32_External_Rel *loc;
1919
1920                       srelgot = htab->srelgot;
1921                       if (srelgot == NULL)
1922                         abort ();
1923
1924                       outrel.r_offset = (htab->sgot->output_section->vma
1925                                          + htab->sgot->output_offset
1926                                          + off);
1927                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1928                       loc = (Elf32_External_Rel *) srelgot->contents;
1929                       loc += srelgot->reloc_count++;
1930                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
1931                     }
1932
1933                   local_got_offsets[r_symndx] |= 1;
1934                 }
1935             }
1936
1937           if (off >= (bfd_vma) -2)
1938             abort ();
1939
1940           relocation = htab->sgot->output_offset + off;
1941           break;
1942
1943         case R_386_GOTOFF:
1944           /* Relocation is relative to the start of the global offset
1945              table.  */
1946
1947           /* Note that sgot->output_offset is not involved in this
1948              calculation.  We always want the start of .got.  If we
1949              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1950              permitted by the ABI, we might have to change this
1951              calculation.  */
1952           relocation -= htab->sgot->output_section->vma;
1953           break;
1954
1955         case R_386_GOTPC:
1956           /* Use global offset table as symbol value.  */
1957           relocation = htab->sgot->output_section->vma;
1958           unresolved_reloc = false;
1959           break;
1960
1961         case R_386_PLT32:
1962           /* Relocation is to the entry for this symbol in the
1963              procedure linkage table.  */
1964
1965           /* Resolve a PLT32 reloc against a local symbol directly,
1966              without using the procedure linkage table.  */
1967           if (h == NULL)
1968             break;
1969
1970           if (h->plt.offset == (bfd_vma) -1
1971               || htab->splt == NULL)
1972             {
1973               /* We didn't make a PLT entry for this symbol.  This
1974                  happens when statically linking PIC code, or when
1975                  using -Bsymbolic.  */
1976               break;
1977             }
1978
1979           relocation = (htab->splt->output_section->vma
1980                         + htab->splt->output_offset
1981                         + h->plt.offset);
1982           unresolved_reloc = false;
1983           break;
1984
1985         case R_386_32:
1986         case R_386_PC32:
1987           /* r_symndx will be zero only for relocs against symbols
1988              from removed linkonce sections, or sections discarded by
1989              a linker script.  */
1990           if (r_symndx == 0
1991               || (input_section->flags & SEC_ALLOC) == 0)
1992             break;
1993
1994           if ((info->shared
1995                && (r_type != R_386_PC32
1996                    || (h != NULL
1997                        && h->dynindx != -1
1998                        && (! info->symbolic
1999                            || (h->elf_link_hash_flags
2000                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2001               || (!info->shared
2002                   && h != NULL
2003                   && h->dynindx != -1
2004                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2005                   && (((h->elf_link_hash_flags
2006                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2007                        && (h->elf_link_hash_flags
2008                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2009                       || h->root.type == bfd_link_hash_undefweak
2010                       || h->root.type == bfd_link_hash_undefined)))
2011             {
2012               Elf_Internal_Rel outrel;
2013               boolean skip, relocate;
2014               asection *sreloc;
2015               Elf32_External_Rel *loc;
2016
2017               /* When generating a shared object, these relocations
2018                  are copied into the output file to be resolved at run
2019                  time.  */
2020
2021               skip = false;
2022               relocate = false;
2023
2024               outrel.r_offset =
2025                 _bfd_elf_section_offset (output_bfd, info, input_section,
2026                                          rel->r_offset);
2027               if (outrel.r_offset == (bfd_vma) -1)
2028                 skip = true;
2029               else if (outrel.r_offset == (bfd_vma) -2)
2030                 skip = true, relocate = true;
2031               outrel.r_offset += (input_section->output_section->vma
2032                                   + input_section->output_offset);
2033
2034               if (skip)
2035                 memset (&outrel, 0, sizeof outrel);
2036               else if (h != NULL
2037                        && h->dynindx != -1
2038                        && (r_type == R_386_PC32
2039                            || !info->shared
2040                            || !info->symbolic
2041                            || (h->elf_link_hash_flags
2042                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2043                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2044               else
2045                 {
2046                   /* This symbol is local, or marked to become local.  */
2047                   relocate = true;
2048                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2049                 }
2050
2051               sreloc = elf_section_data (input_section)->sreloc;
2052               if (sreloc == NULL)
2053                 abort ();
2054
2055               loc = (Elf32_External_Rel *) sreloc->contents;
2056               loc += sreloc->reloc_count++;
2057               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2058
2059               /* If this reloc is against an external symbol, we do
2060                  not want to fiddle with the addend.  Otherwise, we
2061                  need to include the symbol value so that it becomes
2062                  an addend for the dynamic reloc.  */
2063               if (! relocate)
2064                 continue;
2065             }
2066           break;
2067
2068         default:
2069           break;
2070         }
2071
2072       /* FIXME: Why do we allow debugging sections to escape this error?
2073          More importantly, why do we not emit dynamic relocs for
2074          R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
2075          If we had emitted the dynamic reloc, we could remove the
2076          fudge here.  */
2077       if (unresolved_reloc
2078           && !(info->shared
2079                && (input_section->flags & SEC_DEBUGGING) != 0
2080                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2081         (*_bfd_error_handler)
2082           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2083            bfd_archive_filename (input_bfd),
2084            bfd_get_section_name (input_bfd, input_section),
2085            (long) rel->r_offset,
2086            h->root.root.string);
2087
2088       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2089                                     contents, rel->r_offset,
2090                                     relocation, (bfd_vma) 0);
2091
2092       if (r != bfd_reloc_ok)
2093         {
2094           const char *name;
2095
2096           if (h != NULL)
2097             name = h->root.root.string;
2098           else
2099             {
2100               name = bfd_elf_string_from_elf_section (input_bfd,
2101                                                       symtab_hdr->sh_link,
2102                                                       sym->st_name);
2103               if (name == NULL)
2104                 return false;
2105               if (*name == '\0')
2106                 name = bfd_section_name (input_bfd, sec);
2107             }
2108
2109           if (r == bfd_reloc_overflow)
2110             {
2111
2112               if (! ((*info->callbacks->reloc_overflow)
2113                      (info, name, howto->name, (bfd_vma) 0,
2114                       input_bfd, input_section, rel->r_offset)))
2115                 return false;
2116             }
2117           else
2118             {
2119               (*_bfd_error_handler)
2120                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2121                  bfd_archive_filename (input_bfd),
2122                  bfd_get_section_name (input_bfd, input_section),
2123                  (long) rel->r_offset, name, (int) r);
2124               return false;
2125             }
2126         }
2127     }
2128
2129   return true;
2130 }
2131
2132 /* Finish up dynamic symbol handling.  We set the contents of various
2133    dynamic sections here.  */
2134
2135 static boolean
2136 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2137      bfd *output_bfd;
2138      struct bfd_link_info *info;
2139      struct elf_link_hash_entry *h;
2140      Elf_Internal_Sym *sym;
2141 {
2142   struct elf_i386_link_hash_table *htab;
2143
2144   htab = elf_i386_hash_table (info);
2145
2146   if (h->plt.offset != (bfd_vma) -1)
2147     {
2148       bfd_vma plt_index;
2149       bfd_vma got_offset;
2150       Elf_Internal_Rel rel;
2151       Elf32_External_Rel *loc;
2152
2153       /* This symbol has an entry in the procedure linkage table.  Set
2154          it up.  */
2155
2156       if (h->dynindx == -1
2157           || htab->splt == NULL
2158           || htab->sgotplt == NULL
2159           || htab->srelplt == NULL)
2160         abort ();
2161
2162       /* Get the index in the procedure linkage table which
2163          corresponds to this symbol.  This is the index of this symbol
2164          in all the symbols for which we are making plt entries.  The
2165          first entry in the procedure linkage table is reserved.  */
2166       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2167
2168       /* Get the offset into the .got table of the entry that
2169          corresponds to this function.  Each .got entry is 4 bytes.
2170          The first three are reserved.  */
2171       got_offset = (plt_index + 3) * 4;
2172
2173       /* Fill in the entry in the procedure linkage table.  */
2174       if (! info->shared)
2175         {
2176           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
2177                   PLT_ENTRY_SIZE);
2178           bfd_put_32 (output_bfd,
2179                       (htab->sgotplt->output_section->vma
2180                        + htab->sgotplt->output_offset
2181                        + got_offset),
2182                       htab->splt->contents + h->plt.offset + 2);
2183         }
2184       else
2185         {
2186           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
2187                   PLT_ENTRY_SIZE);
2188           bfd_put_32 (output_bfd, got_offset,
2189                       htab->splt->contents + h->plt.offset + 2);
2190         }
2191
2192       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
2193                   htab->splt->contents + h->plt.offset + 7);
2194       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2195                   htab->splt->contents + h->plt.offset + 12);
2196
2197       /* Fill in the entry in the global offset table.  */
2198       bfd_put_32 (output_bfd,
2199                   (htab->splt->output_section->vma
2200                    + htab->splt->output_offset
2201                    + h->plt.offset
2202                    + 6),
2203                   htab->sgotplt->contents + got_offset);
2204
2205       /* Fill in the entry in the .rel.plt section.  */
2206       rel.r_offset = (htab->sgotplt->output_section->vma
2207                       + htab->sgotplt->output_offset
2208                       + got_offset);
2209       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
2210       loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2211       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2212
2213       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2214         {
2215           /* Mark the symbol as undefined, rather than as defined in
2216              the .plt section.  Leave the value alone.  This is a clue
2217              for the dynamic linker, to make function pointer
2218              comparisons work between an application and shared
2219              library.  */
2220           sym->st_shndx = SHN_UNDEF;
2221         }
2222     }
2223
2224   if (h->got.offset != (bfd_vma) -1)
2225     {
2226       Elf_Internal_Rel rel;
2227       Elf32_External_Rel *loc;
2228
2229       /* This symbol has an entry in the global offset table.  Set it
2230          up.  */
2231
2232       if (htab->sgot == NULL || htab->srelgot == NULL)
2233         abort ();
2234
2235       rel.r_offset = (htab->sgot->output_section->vma
2236                       + htab->sgot->output_offset
2237                       + (h->got.offset & ~(bfd_vma) 1));
2238
2239       /* If this is a static link, or it is a -Bsymbolic link and the
2240          symbol is defined locally or was forced to be local because
2241          of a version file, we just want to emit a RELATIVE reloc.
2242          The entry in the global offset table will already have been
2243          initialized in the relocate_section function.  */
2244       if (info->shared
2245           && (info->symbolic
2246               || h->dynindx == -1
2247               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2248           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2249         {
2250           BFD_ASSERT((h->got.offset & 1) != 0);
2251           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2252         }
2253       else
2254         {
2255           BFD_ASSERT((h->got.offset & 1) == 0);
2256           bfd_put_32 (output_bfd, (bfd_vma) 0,
2257                       htab->sgot->contents + h->got.offset);
2258           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2259         }
2260
2261       loc = (Elf32_External_Rel *) htab->srelgot->contents;
2262       loc += htab->srelgot->reloc_count++;
2263       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2264     }
2265
2266   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2267     {
2268       Elf_Internal_Rel rel;
2269       Elf32_External_Rel *loc;
2270
2271       /* This symbol needs a copy reloc.  Set it up.  */
2272
2273       if (h->dynindx == -1
2274           || (h->root.type != bfd_link_hash_defined
2275               && h->root.type != bfd_link_hash_defweak)
2276           || htab->srelbss == NULL)
2277         abort ();
2278
2279       rel.r_offset = (h->root.u.def.value
2280                       + h->root.u.def.section->output_section->vma
2281                       + h->root.u.def.section->output_offset);
2282       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2283       loc = (Elf32_External_Rel *) htab->srelbss->contents;
2284       loc += htab->srelbss->reloc_count++;
2285       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2286     }
2287
2288   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2289   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2290       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2291     sym->st_shndx = SHN_ABS;
2292
2293   return true;
2294 }
2295
2296 /* Used to decide how to sort relocs in an optimal manner for the
2297    dynamic linker, before writing them out.  */
2298
2299 static enum elf_reloc_type_class
2300 elf_i386_reloc_type_class (rela)
2301      const Elf_Internal_Rela *rela;
2302 {
2303   switch ((int) ELF32_R_TYPE (rela->r_info))
2304     {
2305     case R_386_RELATIVE:
2306       return reloc_class_relative;
2307     case R_386_JUMP_SLOT:
2308       return reloc_class_plt;
2309     case R_386_COPY:
2310       return reloc_class_copy;
2311     default:
2312       return reloc_class_normal;
2313     }
2314 }
2315
2316 /* Finish up the dynamic sections.  */
2317
2318 static boolean
2319 elf_i386_finish_dynamic_sections (output_bfd, info)
2320      bfd *output_bfd;
2321      struct bfd_link_info *info;
2322 {
2323   struct elf_i386_link_hash_table *htab;
2324   bfd *dynobj;
2325   asection *sdyn;
2326
2327   htab = elf_i386_hash_table (info);
2328   dynobj = htab->elf.dynobj;
2329   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2330
2331   if (htab->elf.dynamic_sections_created)
2332     {
2333       Elf32_External_Dyn *dyncon, *dynconend;
2334
2335       if (sdyn == NULL || htab->sgot == NULL)
2336         abort ();
2337
2338       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2339       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2340       for (; dyncon < dynconend; dyncon++)
2341         {
2342           Elf_Internal_Dyn dyn;
2343           asection *s;
2344
2345           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2346
2347           switch (dyn.d_tag)
2348             {
2349             default:
2350               continue;
2351
2352             case DT_PLTGOT:
2353               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2354               break;
2355
2356             case DT_JMPREL:
2357               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2358               break;
2359
2360             case DT_PLTRELSZ:
2361               s = htab->srelplt->output_section;
2362               if (s->_cooked_size != 0)
2363                 dyn.d_un.d_val = s->_cooked_size;
2364               else
2365                 dyn.d_un.d_val = s->_raw_size;
2366               break;
2367
2368             case DT_RELSZ:
2369               /* My reading of the SVR4 ABI indicates that the
2370                  procedure linkage table relocs (DT_JMPREL) should be
2371                  included in the overall relocs (DT_REL).  This is
2372                  what Solaris does.  However, UnixWare can not handle
2373                  that case.  Therefore, we override the DT_RELSZ entry
2374                  here to make it not include the JMPREL relocs.  Since
2375                  the linker script arranges for .rel.plt to follow all
2376                  other relocation sections, we don't have to worry
2377                  about changing the DT_REL entry.  */
2378               if (htab->srelplt != NULL)
2379                 {
2380                   s = htab->srelplt->output_section;
2381                   if (s->_cooked_size != 0)
2382                     dyn.d_un.d_val -= s->_cooked_size;
2383                   else
2384                     dyn.d_un.d_val -= s->_raw_size;
2385                 }
2386               break;
2387             }
2388
2389           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2390         }
2391
2392       /* Fill in the first entry in the procedure linkage table.  */
2393       if (htab->splt && htab->splt->_raw_size > 0)
2394         {
2395           if (info->shared)
2396             memcpy (htab->splt->contents,
2397                     elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2398           else
2399             {
2400               memcpy (htab->splt->contents,
2401                       elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2402               bfd_put_32 (output_bfd,
2403                           (htab->sgotplt->output_section->vma
2404                            + htab->sgotplt->output_offset
2405                            + 4),
2406                           htab->splt->contents + 2);
2407               bfd_put_32 (output_bfd,
2408                           (htab->sgotplt->output_section->vma
2409                            + htab->sgotplt->output_offset
2410                            + 8),
2411                           htab->splt->contents + 8);
2412             }
2413
2414           /* UnixWare sets the entsize of .plt to 4, although that doesn't
2415              really seem like the right value.  */
2416           elf_section_data (htab->splt->output_section)
2417             ->this_hdr.sh_entsize = 4;
2418         }
2419     }
2420
2421   if (htab->sgotplt)
2422     {
2423       /* Fill in the first three entries in the global offset table.  */
2424       if (htab->sgotplt->_raw_size > 0)
2425         {
2426           bfd_put_32 (output_bfd,
2427                       (sdyn == NULL ? (bfd_vma) 0
2428                        : sdyn->output_section->vma + sdyn->output_offset),
2429                       htab->sgotplt->contents);
2430           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
2431           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2432         }
2433
2434       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
2435     }
2436   return true;
2437 }
2438
2439 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
2440 #define TARGET_LITTLE_NAME              "elf32-i386"
2441 #define ELF_ARCH                        bfd_arch_i386
2442 #define ELF_MACHINE_CODE                EM_386
2443 #define ELF_MAXPAGESIZE                 0x1000
2444
2445 #define elf_backend_can_gc_sections     1
2446 #define elf_backend_can_refcount        1
2447 #define elf_backend_want_got_plt        1
2448 #define elf_backend_plt_readonly        1
2449 #define elf_backend_want_plt_sym        0
2450 #define elf_backend_got_header_size     12
2451 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
2452
2453 #define elf_info_to_howto                     elf_i386_info_to_howto
2454 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
2455
2456 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
2457 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
2458 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
2459
2460 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
2461 #define elf_backend_check_relocs              elf_i386_check_relocs
2462 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
2463 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
2464 #define elf_backend_fake_sections             elf_i386_fake_sections
2465 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
2466 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
2467 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
2468 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
2469 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
2470 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
2471 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
2472 #define elf_backend_relocate_section          elf_i386_relocate_section
2473 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
2474
2475 #include "elf32-target.h"