bfd/elf32-i386.c

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