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