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->sym_sec.abfd = NULL;
 701
 702   return &ret->elf.root;
 703 }
 704
 705 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
 706    shortcuts to them in our hash table.  */
 707
 708 static boolean
 709 create_got_section (dynobj, info)
 710      bfd *dynobj;
 711      struct bfd_link_info *info;
 712 {
 713   struct elf_i386_link_hash_table *htab;
 714
 715   if (! _bfd_elf_create_got_section (dynobj, info))
 716     return false;
 717
 718   htab = elf_i386_hash_table (info);
 719   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 720   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 721   if (!htab->sgot || !htab->sgotplt)
 722     abort ();
 723
 724   htab->srelgot = bfd_make_section (dynobj, ".rel.got");
 725   if (htab->srelgot == NULL
 726       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 727                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 728                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 729                                    | SEC_READONLY))
 730       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 731     return false;
 732   return true;
 733 }
 734
 735 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 736    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 737    hash table.  */
 738
 739 static boolean
 740 elf_i386_create_dynamic_sections (dynobj, info)
 741      bfd *dynobj;
 742      struct bfd_link_info *info;
 743 {
 744   struct elf_i386_link_hash_table *htab;
 745
 746   htab = elf_i386_hash_table (info);
 747   if (!htab->sgot && !create_got_section (dynobj, info))
 748     return false;
 749
 750   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 751     return false;
 752
 753   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 754   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
 755   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 756   if (!info->shared)
 757     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
 758
 759   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 760       || (!info->shared && !htab->srelbss))
 761     abort ();
 762
 763   return true;
 764 }
 765
 766 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 767
 768 static void
 769 elf_i386_copy_indirect_symbol (dir, ind)
 770      struct elf_link_hash_entry *dir, *ind;
 771 {
 772   struct elf_i386_link_hash_entry *edir, *eind;
 773
 774   edir = (struct elf_i386_link_hash_entry *) dir;
 775   eind = (struct elf_i386_link_hash_entry *) ind;
 776
 777   if (eind->dyn_relocs != NULL)
 778     {
 779       if (edir->dyn_relocs != NULL)
 780         {
 781           struct elf_i386_dyn_relocs **pp;
 782           struct elf_i386_dyn_relocs *p;
 783
 784           if (ind->root.type == bfd_link_hash_indirect)
 785             abort ();
 786
 787           /* Add reloc counts against the weak sym to the strong sym
 788              list.  Merge any entries against the same section.  */
 789           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 790             {
 791               struct elf_i386_dyn_relocs *q;
 792
 793               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 794                 if (q->sec == p->sec)
 795                   {
 796                     q->pc_count += p->pc_count;
 797                     q->count += p->count;
 798                     *pp = p->next;
 799                     break;
 800                   }
 801               if (q == NULL)
 802                 pp = &p->next;
 803             }
 804           *pp = edir->dyn_relocs;
 805         }
 806
 807       edir->dyn_relocs = eind->dyn_relocs;
 808       eind->dyn_relocs = NULL;
 809     }
 810
 811   _bfd_elf_link_hash_copy_indirect (dir, ind);
 812 }
 813
 814 static int
 815 elf_i386_tls_transition (info, r_type, is_local)
 816      struct bfd_link_info *info;
 817      int r_type;
 818      int is_local;
 819 {
 820   if (info->shared)
 821     return r_type;
 822
 823   switch (r_type)
 824     {
 825     case R_386_TLS_GD:
 826     case R_386_TLS_IE_32:
 827       if (is_local)
 828         return R_386_TLS_LE_32;
 829       return R_386_TLS_IE_32;
 830     case R_386_TLS_LDM:
 831       return R_386_TLS_LE_32;
 832     }
 833
 834   return r_type;
 835 }
 836
 837 /* Look through the relocs for a section during the first phase, and
 838    calculate needed space in the global offset table, procedure linkage
 839    table, and dynamic reloc sections.  */
 840
 841 static boolean
 842 elf_i386_check_relocs (abfd, info, sec, relocs)
 843      bfd *abfd;
 844      struct bfd_link_info *info;
 845      asection *sec;
 846      const Elf_Internal_Rela *relocs;
 847 {
 848   struct elf_i386_link_hash_table *htab;
 849   Elf_Internal_Shdr *symtab_hdr;
 850   struct elf_link_hash_entry **sym_hashes;
 851   const Elf_Internal_Rela *rel;
 852   const Elf_Internal_Rela *rel_end;
 853   asection *sreloc;
 854
 855   if (info->relocateable)
 856     return true;
 857
 858   htab = elf_i386_hash_table (info);
 859   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 860   sym_hashes = elf_sym_hashes (abfd);
 861
 862   sreloc = NULL;
 863
 864   rel_end = relocs + sec->reloc_count;
 865   for (rel = relocs; rel < rel_end; rel++)
 866     {
 867       unsigned int r_type;
 868       unsigned long r_symndx;
 869       struct elf_link_hash_entry *h;
 870
 871       r_symndx = ELF32_R_SYM (rel->r_info);
 872       r_type = ELF32_R_TYPE (rel->r_info);
 873
 874       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 875         {
 876           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
 877                                  bfd_archive_filename (abfd),
 878                                  r_symndx);
 879           return false;
 880         }
 881
 882       if (r_symndx < symtab_hdr->sh_info)
 883         h = NULL;
 884       else
 885         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 886
 887       r_type = elf_i386_tls_transition (info, r_type, h == NULL);
 888
 889       switch (r_type)
 890         {
 891         case R_386_TLS_IE_32:
 892           if (info->shared)
 893             info->flags |= DF_STATIC_TLS;
 894           /* FALLTHROUGH */
 895         case R_386_GOT32:
 896         case R_386_TLS_GD:
 897           /* This symbol requires a global offset table entry.  */
 898           {
 899             int tls_type, old_tls_type;
 900
 901             switch (r_type)
 902               {
 903               default:
 904               case R_386_GOT32: tls_type = GOT_NORMAL; break;
 905               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
 906               case R_386_TLS_IE_32: tls_type = GOT_TLS_IE; break;
 907               }
 908
 909             if (h != NULL)
 910               {
 911                 h->got.refcount += 1;
 912                 old_tls_type = elf_i386_hash_entry(h)->tls_type;
 913               }
 914             else
 915               {
 916                 bfd_signed_vma *local_got_refcounts;
 917
 918                 /* This is a global offset table entry for a local symbol.  */
 919                 local_got_refcounts = elf_local_got_refcounts (abfd);
 920                 if (local_got_refcounts == NULL)
 921                   {
 922                     bfd_size_type size;
 923
 924                     size = symtab_hdr->sh_info;
 925                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
 926                     local_got_refcounts = ((bfd_signed_vma *)
 927                                            bfd_zalloc (abfd, size));
 928                     if (local_got_refcounts == NULL)
 929                       return false;
 930                     elf_local_got_refcounts (abfd) = local_got_refcounts;
 931                     elf_i386_local_got_tls_type (abfd)
 932                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
 933                   }
 934                 local_got_refcounts[r_symndx] += 1;
 935                 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
 936               }
 937
 938             /* If a TLS symbol is accessed using IE at least once,
 939                there is no point to use dynamic model for it.  */
 940             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
 941                 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
 942               {
 943                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
 944                   tls_type = GOT_TLS_IE;
 945                 else
 946                   {
 947                     (*_bfd_error_handler)
 948                       (_("%s: `%s' accessed both as normal and thread local symbol"),
 949                        bfd_archive_filename (abfd), h->root.root.string);
 950                     return false;
 951                   }
 952               }
 953
 954             if (old_tls_type != tls_type)
 955               {
 956                 if (h != NULL)
 957                   elf_i386_hash_entry (h)->tls_type = tls_type;
 958                 else
 959                   elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
 960               }
 961           }
 962           /* Fall through */
 963
 964         case R_386_GOTOFF:
 965         case R_386_GOTPC:
 966         create_got:
 967           if (htab->sgot == NULL)
 968             {
 969               if (htab->elf.dynobj == NULL)
 970                 htab->elf.dynobj = abfd;
 971               if (!create_got_section (htab->elf.dynobj, info))
 972                 return false;
 973             }
 974           break;
 975
 976         case R_386_TLS_LDM:
 977           htab->tls_ldm_got.refcount += 1;
 978           goto create_got;
 979
 980         case R_386_PLT32:
 981           /* This symbol requires a procedure linkage table entry.  We
 982              actually build the entry in adjust_dynamic_symbol,
 983              because this might be a case of linking PIC code which is
 984              never referenced by a dynamic object, in which case we
 985              don't need to generate a procedure linkage table entry
 986              after all.  */
 987
 988           /* If this is a local symbol, we resolve it directly without
 989              creating a procedure linkage table entry.  */
 990           if (h == NULL)
 991             continue;
 992
 993           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 994           h->plt.refcount += 1;
 995           break;
 996
 997         case R_386_32:
 998         case R_386_PC32:
 999           if (h != NULL && !info->shared)
1000             {
1001               /* If this reloc is in a read-only section, we might
1002                  need a copy reloc.  We can't check reliably at this
1003                  stage whether the section is read-only, as input
1004                  sections have not yet been mapped to output sections.
1005                  Tentatively set the flag for now, and correct in
1006                  adjust_dynamic_symbol.  */
1007               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1008
1009               /* We may need a .plt entry if the function this reloc
1010                  refers to is in a shared lib.  */
1011               h->plt.refcount += 1;
1012             }
1013
1014           /* If we are creating a shared library, and this is a reloc
1015              against a global symbol, or a non PC relative reloc
1016              against a local symbol, then we need to copy the reloc
1017              into the shared library.  However, if we are linking with
1018              -Bsymbolic, we do not need to copy a reloc against a
1019              global symbol which is defined in an object we are
1020              including in the link (i.e., DEF_REGULAR is set).  At
1021              this point we have not seen all the input files, so it is
1022              possible that DEF_REGULAR is not set now but will be set
1023              later (it is never cleared).  In case of a weak definition,
1024              DEF_REGULAR may be cleared later by a strong definition in
1025              a shared library.  We account for that possibility below by
1026              storing information in the relocs_copied field of the hash
1027              table entry.  A similar situation occurs when creating
1028              shared libraries and symbol visibility changes render the
1029              symbol local.
1030
1031              If on the other hand, we are creating an executable, we
1032              may need to keep relocations for symbols satisfied by a
1033              dynamic library if we manage to avoid copy relocs for the
1034              symbol.  */
1035           if ((info->shared
1036                && (sec->flags & SEC_ALLOC) != 0
1037                && (r_type != R_386_PC32
1038                    || (h != NULL
1039                        && (! info->symbolic
1040                            || h->root.type == bfd_link_hash_defweak
1041                            || (h->elf_link_hash_flags
1042                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1043               || (!info->shared
1044                   && (sec->flags & SEC_ALLOC) != 0
1045                   && h != NULL
1046                   && (h->root.type == bfd_link_hash_defweak
1047                       || (h->elf_link_hash_flags
1048                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1049             {
1050               struct elf_i386_dyn_relocs *p;
1051               struct elf_i386_dyn_relocs **head;
1052
1053               /* We must copy these reloc types into the output file.
1054                  Create a reloc section in dynobj and make room for
1055                  this reloc.  */
1056               if (sreloc == NULL)
1057                 {
1058                   const char *name;
1059                   bfd *dynobj;
1060                   unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1061                   unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1062
1063                   name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1064                   if (name == NULL)
1065                     return false;
1066
1067                   if (strncmp (name, ".rel", 4) != 0
1068                       || strcmp (bfd_get_section_name (abfd, sec),
1069                                  name + 4) != 0)
1070                     {
1071                       (*_bfd_error_handler)
1072                         (_("%s: bad relocation section name `%s\'"),
1073                          bfd_archive_filename (abfd), name);
1074                     }
1075
1076                   if (htab->elf.dynobj == NULL)
1077                     htab->elf.dynobj = abfd;
1078
1079                   dynobj = htab->elf.dynobj;
1080                   sreloc = bfd_get_section_by_name (dynobj, name);
1081                   if (sreloc == NULL)
1082                     {
1083                       flagword flags;
1084
1085                       sreloc = bfd_make_section (dynobj, name);
1086                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1087                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1088                       if ((sec->flags & SEC_ALLOC) != 0)
1089                         flags |= SEC_ALLOC | SEC_LOAD;
1090                       if (sreloc == NULL
1091                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
1092                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1093                         return false;
1094                     }
1095                   elf_section_data (sec)->sreloc = sreloc;
1096                 }
1097
1098               /* If this is a global symbol, we count the number of
1099                  relocations we need for this symbol.  */
1100               if (h != NULL)
1101                 {
1102                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1103                 }
1104               else
1105                 {
1106                   /* Track dynamic relocs needed for local syms too.
1107                      We really need local syms available to do this
1108                      easily.  Oh well.  */
1109
1110                   asection *s;
1111                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1112                                                  sec, r_symndx);
1113                   if (s == NULL)
1114                     return false;
1115
1116                   head = ((struct elf_i386_dyn_relocs **)
1117                           &elf_section_data (s)->local_dynrel);
1118                 }
1119
1120               p = *head;
1121               if (p == NULL || p->sec != sec)
1122                 {
1123                   bfd_size_type amt = sizeof *p;
1124                   p = ((struct elf_i386_dyn_relocs *)
1125                        bfd_alloc (htab->elf.dynobj, amt));
1126                   if (p == NULL)
1127                     return false;
1128                   p->next = *head;
1129                   *head = p;
1130                   p->sec = sec;
1131                   p->count = 0;
1132                   p->pc_count = 0;
1133                 }
1134
1135               p->count += 1;
1136               if (r_type == R_386_PC32)
1137                 p->pc_count += 1;
1138             }
1139           break;
1140
1141           /* This relocation describes the C++ object vtable hierarchy.
1142              Reconstruct it for later use during GC.  */
1143         case R_386_GNU_VTINHERIT:
1144           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1145             return false;
1146           break;
1147
1148           /* This relocation describes which C++ vtable entries are actually
1149              used.  Record for later use during GC.  */
1150         case R_386_GNU_VTENTRY:
1151           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1152             return false;
1153           break;
1154
1155         case R_386_TLS_LE_32:
1156         case R_386_TLS_LE:
1157           if (info->shared)
1158             {
1159               (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
1160                                      bfd_archive_filename (abfd));
1161               return false;
1162             }
1163           break;
1164
1165         default:
1166           break;
1167         }
1168     }
1169
1170   return true;
1171 }
1172
1173 /* Return the section that should be marked against GC for a given
1174    relocation.  */
1175
1176 static asection *
1177 elf_i386_gc_mark_hook (sec, info, rel, h, sym)
1178      asection *sec;
1179      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1180      Elf_Internal_Rela *rel;
1181      struct elf_link_hash_entry *h;
1182      Elf_Internal_Sym *sym;
1183 {
1184   if (h != NULL)
1185     {
1186       switch (ELF32_R_TYPE (rel->r_info))
1187         {
1188         case R_386_GNU_VTINHERIT:
1189         case R_386_GNU_VTENTRY:
1190           break;
1191
1192         default:
1193           switch (h->root.type)
1194             {
1195             case bfd_link_hash_defined:
1196             case bfd_link_hash_defweak:
1197               return h->root.u.def.section;
1198
1199             case bfd_link_hash_common:
1200               return h->root.u.c.p->section;
1201
1202             default:
1203               break;
1204             }
1205         }
1206     }
1207   else
1208     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1209
1210   return NULL;
1211 }
1212
1213 /* Update the got entry reference counts for the section being removed.  */
1214
1215 static boolean
1216 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
1217      bfd *abfd;
1218      struct bfd_link_info *info;
1219      asection *sec;
1220      const Elf_Internal_Rela *relocs;
1221 {
1222   Elf_Internal_Shdr *symtab_hdr;
1223   struct elf_link_hash_entry **sym_hashes;
1224   bfd_signed_vma *local_got_refcounts;
1225   const Elf_Internal_Rela *rel, *relend;
1226   unsigned long r_symndx;
1227   struct elf_link_hash_entry *h;
1228
1229   elf_section_data (sec)->local_dynrel = NULL;
1230
1231   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1232   sym_hashes = elf_sym_hashes (abfd);
1233   local_got_refcounts = elf_local_got_refcounts (abfd);
1234
1235   relend = relocs + sec->reloc_count;
1236   for (rel = relocs; rel < relend; rel++)
1237     switch (elf_i386_tls_transition (info, ELF32_R_TYPE (rel->r_info),
1238                                      ELF32_R_SYM (rel->r_info)
1239                                      >= symtab_hdr->sh_info))
1240       {
1241       case R_386_TLS_LDM:
1242         if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1243           elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1244         break;
1245
1246       case R_386_TLS_GD:
1247       case R_386_TLS_IE_32:
1248       case R_386_GOT32:
1249         r_symndx = ELF32_R_SYM (rel->r_info);
1250         if (r_symndx >= symtab_hdr->sh_info)
1251           {
1252             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1253             if (h->got.refcount > 0)
1254               h->got.refcount -= 1;
1255           }
1256         else if (local_got_refcounts != NULL)
1257           {
1258             if (local_got_refcounts[r_symndx] > 0)
1259               local_got_refcounts[r_symndx] -= 1;
1260           }
1261         break;
1262
1263       case R_386_32:
1264       case R_386_PC32:
1265         r_symndx = ELF32_R_SYM (rel->r_info);
1266         if (r_symndx >= symtab_hdr->sh_info)
1267           {
1268             struct elf_i386_link_hash_entry *eh;
1269             struct elf_i386_dyn_relocs **pp;
1270             struct elf_i386_dyn_relocs *p;
1271
1272             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1273
1274             if (!info->shared && h->plt.refcount > 0)
1275               h->plt.refcount -= 1;
1276
1277             eh = (struct elf_i386_link_hash_entry *) h;
1278
1279             for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1280               if (p->sec == sec)
1281                 {
1282                   if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
1283                     p->pc_count -= 1;
1284                   p->count -= 1;
1285                   if (p->count == 0)
1286                     *pp = p->next;
1287                   break;
1288                 }
1289           }
1290         break;
1291
1292       case R_386_PLT32:
1293         r_symndx = ELF32_R_SYM (rel->r_info);
1294         if (r_symndx >= symtab_hdr->sh_info)
1295           {
1296             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1297             if (h->plt.refcount > 0)
1298               h->plt.refcount -= 1;
1299           }
1300         break;
1301
1302       default:
1303         break;
1304       }
1305
1306   return true;
1307 }
1308
1309 /* Adjust a symbol defined by a dynamic object and referenced by a
1310    regular object.  The current definition is in some section of the
1311    dynamic object, but we're not including those sections.  We have to
1312    change the definition to something the rest of the link can
1313    understand.  */
1314
1315 static boolean
1316 elf_i386_adjust_dynamic_symbol (info, h)
1317      struct bfd_link_info *info;
1318      struct elf_link_hash_entry *h;
1319 {
1320   struct elf_i386_link_hash_table *htab;
1321   struct elf_i386_link_hash_entry * eh;
1322   struct elf_i386_dyn_relocs *p;
1323   asection *s;
1324   unsigned int power_of_two;
1325
1326   /* If this is a function, put it in the procedure linkage table.  We
1327      will fill in the contents of the procedure linkage table later,
1328      when we know the address of the .got section.  */
1329   if (h->type == STT_FUNC
1330       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1331     {
1332       if (h->plt.refcount <= 0
1333           || (! info->shared
1334               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1335               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1336               && h->root.type != bfd_link_hash_undefweak
1337               && h->root.type != bfd_link_hash_undefined))
1338         {
1339           /* This case can occur if we saw a PLT32 reloc in an input
1340              file, but the symbol was never referred to by a dynamic
1341              object, or if all references were garbage collected.  In
1342              such a case, we don't actually need to build a procedure
1343              linkage table, and we can just do a PC32 reloc instead.  */
1344           h->plt.offset = (bfd_vma) -1;
1345           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1346         }
1347
1348       return true;
1349     }
1350   else
1351     /* It's possible that we incorrectly decided a .plt reloc was
1352        needed for an R_386_PC32 reloc to a non-function sym in
1353        check_relocs.  We can't decide accurately between function and
1354        non-function syms in check-relocs;  Objects loaded later in
1355        the link may change h->type.  So fix it now.  */
1356     h->plt.offset = (bfd_vma) -1;
1357
1358   /* If this is a weak symbol, and there is a real definition, the
1359      processor independent code will have arranged for us to see the
1360      real definition first, and we can just use the same value.  */
1361   if (h->weakdef != NULL)
1362     {
1363       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1364                   || h->weakdef->root.type == bfd_link_hash_defweak);
1365       h->root.u.def.section = h->weakdef->root.u.def.section;
1366       h->root.u.def.value = h->weakdef->root.u.def.value;
1367       return true;
1368     }
1369
1370   /* This is a reference to a symbol defined by a dynamic object which
1371      is not a function.  */
1372
1373   /* If we are creating a shared library, we must presume that the
1374      only references to the symbol are via the global offset table.
1375      For such cases we need not do anything here; the relocations will
1376      be handled correctly by relocate_section.  */
1377   if (info->shared)
1378     return true;
1379
1380   /* If there are no references to this symbol that do not use the
1381      GOT, we don't need to generate a copy reloc.  */
1382   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1383     return true;
1384
1385   /* If -z nocopyreloc was given, we won't generate them either.  */
1386   if (info->nocopyreloc)
1387     {
1388       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1389       return true;
1390     }
1391
1392   eh = (struct elf_i386_link_hash_entry *) h;
1393   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1394     {
1395       s = p->sec->output_section;
1396       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1397         break;
1398     }
1399
1400   /* If we didn't find any dynamic relocs in read-only sections, then
1401      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1402   if (p == NULL)
1403     {
1404       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1405       return true;
1406     }
1407
1408   /* We must allocate the symbol in our .dynbss section, which will
1409      become part of the .bss section of the executable.  There will be
1410      an entry for this symbol in the .dynsym section.  The dynamic
1411      object will contain position independent code, so all references
1412      from the dynamic object to this symbol will go through the global
1413      offset table.  The dynamic linker will use the .dynsym entry to
1414      determine the address it must put in the global offset table, so
1415      both the dynamic object and the regular object will refer to the
1416      same memory location for the variable.  */
1417
1418   htab = elf_i386_hash_table (info);
1419
1420   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1421      copy the initial value out of the dynamic object and into the
1422      runtime process image.  */
1423   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1424     {
1425       htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
1426       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1427     }
1428
1429   /* We need to figure out the alignment required for this symbol.  I
1430      have no idea how ELF linkers handle this.  */
1431   power_of_two = bfd_log2 (h->size);
1432   if (power_of_two > 3)
1433     power_of_two = 3;
1434
1435   /* Apply the required alignment.  */
1436   s = htab->sdynbss;
1437   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1438   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1439     {
1440       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1441         return false;
1442     }
1443
1444   /* Define the symbol as being at this point in the section.  */
1445   h->root.u.def.section = s;
1446   h->root.u.def.value = s->_raw_size;
1447
1448   /* Increment the section size to make room for the symbol.  */
1449   s->_raw_size += h->size;
1450
1451   return true;
1452 }
1453
1454 /* This is the condition under which elf_i386_finish_dynamic_symbol
1455    will be called from elflink.h.  If elflink.h doesn't call our
1456    finish_dynamic_symbol routine, we'll need to do something about
1457    initializing any .plt and .got entries in elf_i386_relocate_section.  */
1458 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1459   ((DYN)                                                                \
1460    && ((INFO)->shared                                                   \
1461        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
1462    && ((H)->dynindx != -1                                               \
1463        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1464
1465 /* Allocate space in .plt, .got and associated reloc sections for
1466    dynamic relocs.  */
1467
1468 static boolean
1469 allocate_dynrelocs (h, inf)
1470      struct elf_link_hash_entry *h;
1471      PTR inf;
1472 {
1473   struct bfd_link_info *info;
1474   struct elf_i386_link_hash_table *htab;
1475   struct elf_i386_link_hash_entry *eh;
1476   struct elf_i386_dyn_relocs *p;
1477
1478   if (h->root.type == bfd_link_hash_indirect)
1479     return true;
1480
1481   if (h->root.type == bfd_link_hash_warning)
1482     /* When warning symbols are created, they **replace** the "real"
1483        entry in the hash table, thus we never get to see the real
1484        symbol in a hash traversal.  So look at it now.  */
1485     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1486
1487   info = (struct bfd_link_info *) inf;
1488   htab = elf_i386_hash_table (info);
1489
1490   if (htab->elf.dynamic_sections_created
1491       && h->plt.refcount > 0)
1492     {
1493       /* Make sure this symbol is output as a dynamic symbol.
1494          Undefined weak syms won't yet be marked as dynamic.  */
1495       if (h->dynindx == -1
1496           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1497         {
1498           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1499             return false;
1500         }
1501
1502       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1503         {
1504           asection *s = htab->splt;
1505
1506           /* If this is the first .plt entry, make room for the special
1507              first entry.  */
1508           if (s->_raw_size == 0)
1509             s->_raw_size += PLT_ENTRY_SIZE;
1510
1511           h->plt.offset = s->_raw_size;
1512
1513           /* If this symbol is not defined in a regular file, and we are
1514              not generating a shared library, then set the symbol to this
1515              location in the .plt.  This is required to make function
1516              pointers compare as equal between the normal executable and
1517              the shared library.  */
1518           if (! info->shared
1519               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1520             {
1521               h->root.u.def.section = s;
1522               h->root.u.def.value = h->plt.offset;
1523             }
1524
1525           /* Make room for this entry.  */
1526           s->_raw_size += PLT_ENTRY_SIZE;
1527
1528           /* We also need to make an entry in the .got.plt section, which
1529              will be placed in the .got section by the linker script.  */
1530           htab->sgotplt->_raw_size += 4;
1531
1532           /* We also need to make an entry in the .rel.plt section.  */
1533           htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
1534         }
1535       else
1536         {
1537           h->plt.offset = (bfd_vma) -1;
1538           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1539         }
1540     }
1541   else
1542     {
1543       h->plt.offset = (bfd_vma) -1;
1544       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1545     }
1546
1547   /* If R_386_TLS_IE_32 symbol is now local to the binary,
1548      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
1549   if (h->got.refcount > 0
1550       && !info->shared
1551       && h->dynindx == -1
1552       && elf_i386_hash_entry(h)->tls_type == GOT_TLS_IE)
1553     h->got.offset = (bfd_vma) -1;
1554   else if (h->got.refcount > 0)
1555     {
1556       asection *s;
1557       boolean dyn;
1558       int tls_type = elf_i386_hash_entry(h)->tls_type;
1559
1560       /* Make sure this symbol is output as a dynamic symbol.
1561          Undefined weak syms won't yet be marked as dynamic.  */
1562       if (h->dynindx == -1
1563           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1564         {
1565           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1566             return false;
1567         }
1568
1569       s = htab->sgot;
1570       h->got.offset = s->_raw_size;
1571       s->_raw_size += 4;
1572       /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
1573       if (tls_type == GOT_TLS_GD)
1574         s->_raw_size += 4;
1575       dyn = htab->elf.dynamic_sections_created;
1576       /* R_386_TLS_IE_32 needs one dynamic relocation,
1577          R_386_TLS_GD needs one if local symbol and two if global.  */
1578       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1579           || tls_type == GOT_TLS_IE)
1580         htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1581       else if (tls_type == GOT_TLS_GD)
1582         htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1583       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1584         htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1585     }
1586   else
1587     h->got.offset = (bfd_vma) -1;
1588
1589   eh = (struct elf_i386_link_hash_entry *) h;
1590   if (eh->dyn_relocs == NULL)
1591     return true;
1592
1593   /* In the shared -Bsymbolic case, discard space allocated for
1594      dynamic pc-relative relocs against symbols which turn out to be
1595      defined in regular objects.  For the normal shared case, discard
1596      space for pc-relative relocs that have become local due to symbol
1597      visibility changes.  */
1598
1599   if (info->shared)
1600     {
1601       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1602           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1603               || info->symbolic))
1604         {
1605           struct elf_i386_dyn_relocs **pp;
1606
1607           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1608             {
1609               p->count -= p->pc_count;
1610               p->pc_count = 0;
1611               if (p->count == 0)
1612                 *pp = p->next;
1613               else
1614                 pp = &p->next;
1615             }
1616         }
1617     }
1618   else
1619     {
1620       /* For the non-shared case, discard space for relocs against
1621          symbols which turn out to need copy relocs or are not
1622          dynamic.  */
1623
1624       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1625           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1626                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1627               || (htab->elf.dynamic_sections_created
1628                   && (h->root.type == bfd_link_hash_undefweak
1629                       || h->root.type == bfd_link_hash_undefined))))
1630         {
1631           /* Make sure this symbol is output as a dynamic symbol.
1632              Undefined weak syms won't yet be marked as dynamic.  */
1633           if (h->dynindx == -1
1634               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1635             {
1636               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1637                 return false;
1638             }
1639
1640           /* If that succeeded, we know we'll be keeping all the
1641              relocs.  */
1642           if (h->dynindx != -1)
1643             goto keep;
1644         }
1645
1646       eh->dyn_relocs = NULL;
1647
1648     keep: ;
1649     }
1650
1651   /* Finally, allocate space.  */
1652   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1653     {
1654       asection *sreloc = elf_section_data (p->sec)->sreloc;
1655       sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1656     }
1657
1658   return true;
1659 }
1660
1661 /* Find any dynamic relocs that apply to read-only sections.  */
1662
1663 static boolean
1664 readonly_dynrelocs (h, inf)
1665      struct elf_link_hash_entry *h;
1666      PTR inf;
1667 {
1668   struct elf_i386_link_hash_entry *eh;
1669   struct elf_i386_dyn_relocs *p;
1670
1671   if (h->root.type == bfd_link_hash_warning)
1672     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1673
1674   eh = (struct elf_i386_link_hash_entry *) h;
1675   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1676     {
1677       asection *s = p->sec->output_section;
1678
1679       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1680         {
1681           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1682
1683           info->flags |= DF_TEXTREL;
1684
1685           /* Not an error, just cut short the traversal.  */
1686           return false;
1687         }
1688     }
1689   return true;
1690 }
1691
1692 /* Set the sizes of the dynamic sections.  */
1693
1694 static boolean
1695 elf_i386_size_dynamic_sections (output_bfd, info)
1696      bfd *output_bfd ATTRIBUTE_UNUSED;
1697      struct bfd_link_info *info;
1698 {
1699   struct elf_i386_link_hash_table *htab;
1700   bfd *dynobj;
1701   asection *s;
1702   boolean relocs;
1703   bfd *ibfd;
1704
1705   htab = elf_i386_hash_table (info);
1706   dynobj = htab->elf.dynobj;
1707   if (dynobj == NULL)
1708     abort ();
1709
1710   if (htab->elf.dynamic_sections_created)
1711     {
1712       /* Set the contents of the .interp section to the interpreter.  */
1713       if (! info->shared)
1714         {
1715           s = bfd_get_section_by_name (dynobj, ".interp");
1716           if (s == NULL)
1717             abort ();
1718           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1719           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1720         }
1721     }
1722
1723   /* Set up .got offsets for local syms, and space for local dynamic
1724      relocs.  */
1725   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1726     {
1727       bfd_signed_vma *local_got;
1728       bfd_signed_vma *end_local_got;
1729       char *local_tls_type;
1730       bfd_size_type locsymcount;
1731       Elf_Internal_Shdr *symtab_hdr;
1732       asection *srel;
1733
1734       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1735         continue;
1736
1737       for (s = ibfd->sections; s != NULL; s = s->next)
1738         {
1739           struct elf_i386_dyn_relocs *p;
1740
1741           for (p = *((struct elf_i386_dyn_relocs **)
1742                      &elf_section_data (s)->local_dynrel);
1743                p != NULL;
1744                p = p->next)
1745             {
1746               if (!bfd_is_abs_section (p->sec)
1747                   && bfd_is_abs_section (p->sec->output_section))
1748                 {
1749                   /* Input section has been discarded, either because
1750                      it is a copy of a linkonce section or due to
1751                      linker script /DISCARD/, so we'll be discarding
1752                      the relocs too.  */
1753                 }
1754               else if (p->count != 0)
1755                 {
1756                   srel = elf_section_data (p->sec)->sreloc;
1757                   srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
1758                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1759                     info->flags |= DF_TEXTREL;
1760                 }
1761             }
1762         }
1763
1764       local_got = elf_local_got_refcounts (ibfd);
1765       if (!local_got)
1766         continue;
1767
1768       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1769       locsymcount = symtab_hdr->sh_info;
1770       end_local_got = local_got + locsymcount;
1771       local_tls_type = elf_i386_local_got_tls_type (ibfd);
1772       s = htab->sgot;
1773       srel = htab->srelgot;
1774       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1775         {
1776           if (*local_got > 0)
1777             {
1778               *local_got = s->_raw_size;
1779               s->_raw_size += 4;
1780               if (*local_tls_type == GOT_TLS_GD)
1781                 s->_raw_size += 4;
1782               if (info->shared
1783                   || *local_tls_type == GOT_TLS_GD
1784                   || *local_tls_type == GOT_TLS_IE)
1785                 srel->_raw_size += sizeof (Elf32_External_Rel);
1786             }
1787           else
1788             *local_got = (bfd_vma) -1;
1789         }
1790     }
1791
1792   if (htab->tls_ldm_got.refcount > 0)
1793     {
1794       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1795          relocs.  */
1796       htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1797       htab->sgot->_raw_size += 8;
1798       htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1799     }
1800   else
1801     htab->tls_ldm_got.offset = -1;
1802
1803   /* Allocate global sym .plt and .got entries, and space for global
1804      sym dynamic relocs.  */
1805   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1806
1807   /* We now have determined the sizes of the various dynamic sections.
1808      Allocate memory for them.  */
1809   relocs = false;
1810   for (s = dynobj->sections; s != NULL; s = s->next)
1811     {
1812       if ((s->flags & SEC_LINKER_CREATED) == 0)
1813         continue;
1814
1815       if (s == htab->splt
1816           || s == htab->sgot
1817           || s == htab->sgotplt)
1818         {
1819           /* Strip this section if we don't need it; see the
1820              comment below.  */
1821         }
1822       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1823         {
1824           if (s->_raw_size != 0 && s != htab->srelplt)
1825             relocs = true;
1826
1827           /* We use the reloc_count field as a counter if we need
1828              to copy relocs into the output file.  */
1829           s->reloc_count = 0;
1830         }
1831       else
1832         {
1833           /* It's not one of our sections, so don't allocate space.  */
1834           continue;
1835         }
1836
1837       if (s->_raw_size == 0)
1838         {
1839           /* If we don't need this section, strip it from the
1840              output file.  This is mostly to handle .rel.bss and
1841              .rel.plt.  We must create both sections in
1842              create_dynamic_sections, because they must be created
1843              before the linker maps input sections to output
1844              sections.  The linker does that before
1845              adjust_dynamic_symbol is called, and it is that
1846              function which decides whether anything needs to go
1847              into these sections.  */
1848
1849           _bfd_strip_section_from_output (info, s);
1850           continue;
1851         }
1852
1853       /* Allocate memory for the section contents.  We use bfd_zalloc
1854          here in case unused entries are not reclaimed before the
1855          section's contents are written out.  This should not happen,
1856          but this way if it does, we get a R_386_NONE reloc instead
1857          of garbage.  */
1858       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1859       if (s->contents == NULL)
1860         return false;
1861     }
1862
1863   if (htab->elf.dynamic_sections_created)
1864     {
1865       /* Add some entries to the .dynamic section.  We fill in the
1866          values later, in elf_i386_finish_dynamic_sections, but we
1867          must add the entries now so that we get the correct size for
1868          the .dynamic section.  The DT_DEBUG entry is filled in by the
1869          dynamic linker and used by the debugger.  */
1870 #define add_dynamic_entry(TAG, VAL) \
1871   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1872
1873       if (! info->shared)
1874         {
1875           if (!add_dynamic_entry (DT_DEBUG, 0))
1876             return false;
1877         }
1878
1879       if (htab->splt->_raw_size != 0)
1880         {
1881           if (!add_dynamic_entry (DT_PLTGOT, 0)
1882               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1883               || !add_dynamic_entry (DT_PLTREL, DT_REL)
1884               || !add_dynamic_entry (DT_JMPREL, 0))
1885             return false;
1886         }
1887
1888       if (relocs)
1889         {
1890           if (!add_dynamic_entry (DT_REL, 0)
1891               || !add_dynamic_entry (DT_RELSZ, 0)
1892               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1893             return false;
1894
1895           /* If any dynamic relocs apply to a read-only section,
1896              then we need a DT_TEXTREL entry.  */
1897           if ((info->flags & DF_TEXTREL) == 0)
1898             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1899                                     (PTR) info);
1900
1901           if ((info->flags & DF_TEXTREL) != 0)
1902             {
1903               if (!add_dynamic_entry (DT_TEXTREL, 0))
1904                 return false;
1905             }
1906         }
1907     }
1908 #undef add_dynamic_entry
1909
1910   return true;
1911 }
1912
1913 /* Set the correct type for an x86 ELF section.  We do this by the
1914    section name, which is a hack, but ought to work.  */
1915
1916 static boolean
1917 elf_i386_fake_sections (abfd, hdr, sec)
1918      bfd *abfd ATTRIBUTE_UNUSED;
1919      Elf32_Internal_Shdr *hdr;
1920      asection *sec;
1921 {
1922   register const char *name;
1923
1924   name = bfd_get_section_name (abfd, sec);
1925
1926   /* This is an ugly, but unfortunately necessary hack that is
1927      needed when producing EFI binaries on x86. It tells
1928      elf.c:elf_fake_sections() not to consider ".reloc" as a section
1929      containing ELF relocation info.  We need this hack in order to
1930      be able to generate ELF binaries that can be translated into
1931      EFI applications (which are essentially COFF objects).  Those
1932      files contain a COFF ".reloc" section inside an ELFNN object,
1933      which would normally cause BFD to segfault because it would
1934      attempt to interpret this section as containing relocation
1935      entries for section "oc".  With this hack enabled, ".reloc"
1936      will be treated as a normal data section, which will avoid the
1937      segfault.  However, you won't be able to create an ELFNN binary
1938      with a section named "oc" that needs relocations, but that's
1939      the kind of ugly side-effects you get when detecting section
1940      types based on their names...  In practice, this limitation is
1941      unlikely to bite.  */
1942   if (strcmp (name, ".reloc") == 0)
1943     hdr->sh_type = SHT_PROGBITS;
1944
1945   return true;
1946 }
1947
1948 /* Return the base VMA address which should be subtracted from real addresses
1949    when resolving @dtpoff relocation.
1950    This is PT_TLS segment p_vaddr.  */
1951
1952 static bfd_vma
1953 dtpoff_base (info)
1954      struct bfd_link_info *info;
1955 {
1956   BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
1957   return elf_hash_table (info)->tls_segment->start;
1958 }
1959
1960 /* Return the relocation value for @tpoff relocation
1961    if STT_TLS virtual address is ADDRESS.  */
1962
1963 static bfd_vma
1964 tpoff (info, address)
1965      struct bfd_link_info *info;
1966      bfd_vma address;
1967 {
1968   struct elf_link_tls_segment *tls_segment
1969     = elf_hash_table (info)->tls_segment;
1970
1971   BFD_ASSERT (tls_segment != NULL);
1972   return (align_power (tls_segment->size, tls_segment->align)
1973           + tls_segment->start - address);
1974 }
1975
1976 /* Relocate an i386 ELF section.  */
1977
1978 static boolean
1979 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1980                            contents, relocs, local_syms, local_sections)
1981      bfd *output_bfd;
1982      struct bfd_link_info *info;
1983      bfd *input_bfd;
1984      asection *input_section;
1985      bfd_byte *contents;
1986      Elf_Internal_Rela *relocs;
1987      Elf_Internal_Sym *local_syms;
1988      asection **local_sections;
1989 {
1990   struct elf_i386_link_hash_table *htab;
1991   Elf_Internal_Shdr *symtab_hdr;
1992   struct elf_link_hash_entry **sym_hashes;
1993   bfd_vma *local_got_offsets;
1994   Elf_Internal_Rela *rel;
1995   Elf_Internal_Rela *relend;
1996
1997   htab = elf_i386_hash_table (info);
1998   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1999   sym_hashes = elf_sym_hashes (input_bfd);
2000   local_got_offsets = elf_local_got_offsets (input_bfd);
2001
2002   rel = relocs;
2003   relend = relocs + input_section->reloc_count;
2004   for (; rel < relend; rel++)
2005     {
2006       unsigned int r_type;
2007       reloc_howto_type *howto;
2008       unsigned long r_symndx;
2009       struct elf_link_hash_entry *h;
2010       Elf_Internal_Sym *sym;
2011       asection *sec;
2012       bfd_vma off;
2013       bfd_vma relocation;
2014       boolean unresolved_reloc;
2015       bfd_reloc_status_type r;
2016       unsigned int indx;
2017       int tls_type;
2018
2019       r_type = ELF32_R_TYPE (rel->r_info);
2020       if (r_type == (int) R_386_GNU_VTINHERIT
2021           || r_type == (int) R_386_GNU_VTENTRY)
2022         continue;
2023
2024       if ((indx = (unsigned) r_type) >= R_386_standard
2025           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2026               >= R_386_ext - R_386_standard)
2027           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2028               >= R_386_tls - R_386_ext))
2029         {
2030           bfd_set_error (bfd_error_bad_value);
2031           return false;
2032         }
2033       howto = elf_howto_table + indx;
2034
2035       r_symndx = ELF32_R_SYM (rel->r_info);
2036
2037       if (info->relocateable)
2038         {
2039           bfd_vma val;
2040           bfd_byte *where;
2041
2042           /* This is a relocatable link.  We don't have to change
2043              anything, unless the reloc is against a section symbol,
2044              in which case we have to adjust according to where the
2045              section symbol winds up in the output section.  */
2046           if (r_symndx >= symtab_hdr->sh_info)
2047             continue;
2048
2049           sym = local_syms + r_symndx;
2050           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2051             continue;
2052
2053           sec = local_sections[r_symndx];
2054           val = sec->output_offset;
2055           if (val == 0)
2056             continue;
2057
2058           where = contents + rel->r_offset;
2059           switch (howto->size)
2060             {
2061               /* FIXME: overflow checks.  */
2062             case 0:
2063               val += bfd_get_8 (input_bfd, where);
2064               bfd_put_8 (input_bfd, val, where);
2065               break;
2066             case 1:
2067               val += bfd_get_16 (input_bfd, where);
2068               bfd_put_16 (input_bfd, val, where);
2069               break;
2070             case 2:
2071               val += bfd_get_32 (input_bfd, where);
2072               bfd_put_32 (input_bfd, val, where);
2073               break;
2074             default:
2075               abort ();
2076             }
2077           continue;
2078         }
2079
2080       /* This is a final link.  */
2081       h = NULL;
2082       sym = NULL;
2083       sec = NULL;
2084       unresolved_reloc = false;
2085       if (r_symndx < symtab_hdr->sh_info)
2086         {
2087           sym = local_syms + r_symndx;
2088           sec = local_sections[r_symndx];
2089           relocation = (sec->output_section->vma
2090                         + sec->output_offset
2091                         + sym->st_value);
2092           if ((sec->flags & SEC_MERGE)
2093               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2094             {
2095               asection *msec;
2096               bfd_vma addend;
2097               bfd_byte *where = contents + rel->r_offset;
2098
2099               switch (howto->size)
2100                 {
2101                 case 0:
2102                   addend = bfd_get_8 (input_bfd, where);
2103                   if (howto->pc_relative)
2104                     {
2105                       addend = (addend ^ 0x80) - 0x80;
2106                       addend += 1;
2107                     }
2108                   break;
2109                 case 1:
2110                   addend = bfd_get_16 (input_bfd, where);
2111                   if (howto->pc_relative)
2112                     {
2113                       addend = (addend ^ 0x8000) - 0x8000;
2114                       addend += 2;
2115                     }
2116                   break;
2117                 case 2:
2118                   addend = bfd_get_32 (input_bfd, where);
2119                   if (howto->pc_relative)
2120                     {
2121                       addend = (addend ^ 0x80000000) - 0x80000000;
2122                       addend += 4;
2123                     }
2124                   break;
2125                 default:
2126                   abort ();
2127                 }
2128
2129               msec = sec;
2130               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2131               addend -= relocation;
2132               addend += msec->output_section->vma + msec->output_offset;
2133
2134               switch (howto->size)
2135                 {
2136                 case 0:
2137                   /* FIXME: overflow checks.  */
2138                   if (howto->pc_relative)
2139                     addend -= 1;
2140                   bfd_put_8 (input_bfd, addend, where);
2141                   break;
2142                 case 1:
2143                   if (howto->pc_relative)
2144                     addend -= 2;
2145                   bfd_put_16 (input_bfd, addend, where);
2146                   break;
2147                 case 2:
2148                   if (howto->pc_relative)
2149                     addend -= 4;
2150                   bfd_put_32 (input_bfd, addend, where);
2151                   break;
2152                 }
2153             }
2154         }
2155       else
2156         {
2157           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2158           while (h->root.type == bfd_link_hash_indirect
2159                  || h->root.type == bfd_link_hash_warning)
2160             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2161
2162           relocation = 0;
2163           if (h->root.type == bfd_link_hash_defined
2164               || h->root.type == bfd_link_hash_defweak)
2165             {
2166               sec = h->root.u.def.section;
2167               if (sec->output_section == NULL)
2168                 /* Set a flag that will be cleared later if we find a
2169                    relocation value for this symbol.  output_section
2170                    is typically NULL for symbols satisfied by a shared
2171                    library.  */
2172                 unresolved_reloc = true;
2173               else
2174                 relocation = (h->root.u.def.value
2175                               + sec->output_section->vma
2176                               + sec->output_offset);
2177             }
2178           else if (h->root.type == bfd_link_hash_undefweak)
2179             ;
2180           else if (info->shared
2181                    && (!info->symbolic || info->allow_shlib_undefined)
2182                    && !info->no_undefined
2183                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2184             ;
2185           else
2186             {
2187               if (! ((*info->callbacks->undefined_symbol)
2188                      (info, h->root.root.string, input_bfd,
2189                       input_section, rel->r_offset,
2190                       (!info->shared || info->no_undefined
2191                        || ELF_ST_VISIBILITY (h->other)))))
2192                 return false;
2193             }
2194         }
2195
2196       switch (r_type)
2197         {
2198         case R_386_GOT32:
2199           /* Relocation is to the entry for this symbol in the global
2200              offset table.  */
2201           if (htab->sgot == NULL)
2202             abort ();
2203
2204           if (h != NULL)
2205             {
2206               boolean dyn;
2207
2208               off = h->got.offset;
2209               dyn = htab->elf.dynamic_sections_created;
2210               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2211                   || (info->shared
2212                       && (info->symbolic
2213                           || h->dynindx == -1
2214                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2215                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2216                 {
2217                   /* This is actually a static link, or it is a
2218                      -Bsymbolic link and the symbol is defined
2219                      locally, or the symbol was forced to be local
2220                      because of a version file.  We must initialize
2221                      this entry in the global offset table.  Since the
2222                      offset must always be a multiple of 4, we use the
2223                      least significant bit to record whether we have
2224                      initialized it already.
2225
2226                      When doing a dynamic link, we create a .rel.got
2227                      relocation entry to initialize the value.  This
2228                      is done in the finish_dynamic_symbol routine.  */
2229                   if ((off & 1) != 0)
2230                     off &= ~1;
2231                   else
2232                     {
2233                       bfd_put_32 (output_bfd, relocation,
2234                                   htab->sgot->contents + off);
2235                       h->got.offset |= 1;
2236                     }
2237                 }
2238               else
2239                 unresolved_reloc = false;
2240             }
2241           else
2242             {
2243               if (local_got_offsets == NULL)
2244                 abort ();
2245
2246               off = local_got_offsets[r_symndx];
2247
2248               /* The offset must always be a multiple of 4.  We use
2249                  the least significant bit to record whether we have
2250                  already generated the necessary reloc.  */
2251               if ((off & 1) != 0)
2252                 off &= ~1;
2253               else
2254                 {
2255                   bfd_put_32 (output_bfd, relocation,
2256                               htab->sgot->contents + off);
2257
2258                   if (info->shared)
2259                     {
2260                       asection *srelgot;
2261                       Elf_Internal_Rel outrel;
2262                       Elf32_External_Rel *loc;
2263
2264                       srelgot = htab->srelgot;
2265                       if (srelgot == NULL)
2266                         abort ();
2267
2268                       outrel.r_offset = (htab->sgot->output_section->vma
2269                                          + htab->sgot->output_offset
2270                                          + off);
2271                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2272                       loc = (Elf32_External_Rel *) srelgot->contents;
2273                       loc += srelgot->reloc_count++;
2274                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2275                     }
2276
2277                   local_got_offsets[r_symndx] |= 1;
2278                 }
2279             }
2280
2281           if (off >= (bfd_vma) -2)
2282             abort ();
2283
2284           relocation = htab->sgot->output_offset + off;
2285           break;
2286
2287         case R_386_GOTOFF:
2288           /* Relocation is relative to the start of the global offset
2289              table.  */
2290
2291           /* Note that sgot->output_offset is not involved in this
2292              calculation.  We always want the start of .got.  If we
2293              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2294              permitted by the ABI, we might have to change this
2295              calculation.  */
2296           relocation -= htab->sgot->output_section->vma;
2297           break;
2298
2299         case R_386_GOTPC:
2300           /* Use global offset table as symbol value.  */
2301           relocation = htab->sgot->output_section->vma;
2302           unresolved_reloc = false;
2303           break;
2304
2305         case R_386_PLT32:
2306           /* Relocation is to the entry for this symbol in the
2307              procedure linkage table.  */
2308
2309           /* Resolve a PLT32 reloc against a local symbol directly,
2310              without using the procedure linkage table.  */
2311           if (h == NULL)
2312             break;
2313
2314           if (h->plt.offset == (bfd_vma) -1
2315               || htab->splt == NULL)
2316             {
2317               /* We didn't make a PLT entry for this symbol.  This
2318                  happens when statically linking PIC code, or when
2319                  using -Bsymbolic.  */
2320               break;
2321             }
2322
2323           relocation = (htab->splt->output_section->vma
2324                         + htab->splt->output_offset
2325                         + h->plt.offset);
2326           unresolved_reloc = false;
2327           break;
2328
2329         case R_386_32:
2330         case R_386_PC32:
2331           /* r_symndx will be zero only for relocs against symbols
2332              from removed linkonce sections, or sections discarded by
2333              a linker script.  */
2334           if (r_symndx == 0
2335               || (input_section->flags & SEC_ALLOC) == 0)
2336             break;
2337
2338           if ((info->shared
2339                && (r_type != R_386_PC32
2340                    || (h != NULL
2341                        && h->dynindx != -1
2342                        && (! info->symbolic
2343                            || (h->elf_link_hash_flags
2344                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2345               || (!info->shared
2346                   && h != NULL
2347                   && h->dynindx != -1
2348                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2349                   && (((h->elf_link_hash_flags
2350                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2351                        && (h->elf_link_hash_flags
2352                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2353                       || h->root.type == bfd_link_hash_undefweak
2354                       || h->root.type == bfd_link_hash_undefined)))
2355             {
2356               Elf_Internal_Rel outrel;
2357               boolean skip, relocate;
2358               asection *sreloc;
2359               Elf32_External_Rel *loc;
2360
2361               /* When generating a shared object, these relocations
2362                  are copied into the output file to be resolved at run
2363                  time.  */
2364
2365               skip = false;
2366               relocate = false;
2367
2368               outrel.r_offset =
2369                 _bfd_elf_section_offset (output_bfd, info, input_section,
2370                                          rel->r_offset);
2371               if (outrel.r_offset == (bfd_vma) -1)
2372                 skip = true;
2373               else if (outrel.r_offset == (bfd_vma) -2)
2374                 skip = true, relocate = true;
2375               outrel.r_offset += (input_section->output_section->vma
2376                                   + input_section->output_offset);
2377
2378               if (skip)
2379                 memset (&outrel, 0, sizeof outrel);
2380               else if (h != NULL
2381                        && h->dynindx != -1
2382                        && (r_type == R_386_PC32
2383                            || !info->shared
2384                            || !info->symbolic
2385                            || (h->elf_link_hash_flags
2386                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2387                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2388               else
2389                 {
2390                   /* This symbol is local, or marked to become local.  */
2391                   relocate = true;
2392                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2393                 }
2394
2395               sreloc = elf_section_data (input_section)->sreloc;
2396               if (sreloc == NULL)
2397                 abort ();
2398
2399               loc = (Elf32_External_Rel *) sreloc->contents;
2400               loc += sreloc->reloc_count++;
2401               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2402
2403               /* If this reloc is against an external symbol, we do
2404                  not want to fiddle with the addend.  Otherwise, we
2405                  need to include the symbol value so that it becomes
2406                  an addend for the dynamic reloc.  */
2407               if (! relocate)
2408                 continue;
2409             }
2410           break;
2411
2412         case R_386_TLS_GD:
2413         case R_386_TLS_IE_32:
2414           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2415           tls_type = GOT_UNKNOWN;
2416           if (h == NULL && local_got_offsets)
2417             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2418           else if (h != NULL)
2419             {
2420               tls_type = elf_i386_hash_entry(h)->tls_type;
2421               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2422                 r_type = R_386_TLS_LE_32;
2423             }
2424           if (r_type == R_386_TLS_GD && tls_type == GOT_TLS_IE)
2425             r_type = R_386_TLS_IE_32;
2426
2427           if (r_type == R_386_TLS_LE_32)
2428             {
2429               BFD_ASSERT (! unresolved_reloc);
2430               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2431                 {
2432                   unsigned int val, type;
2433                   bfd_vma roff;
2434
2435                   /* GD->LE transition.  */
2436                   BFD_ASSERT (rel->r_offset >= 2);
2437                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2438                   BFD_ASSERT (type == 0x8d || type == 0x04);
2439                   BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2440                   BFD_ASSERT (bfd_get_8 (input_bfd,
2441                                          contents + rel->r_offset + 4)
2442                               == 0xe8);
2443                   BFD_ASSERT (rel + 1 < relend);
2444                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2445                   roff = rel->r_offset + 5;
2446                   val = bfd_get_8 (input_bfd,
2447                                    contents + rel->r_offset - 1);
2448                   if (type == 0x04)
2449                     {
2450                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2451                          Change it into:
2452                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2453                          (6 byte form of subl).  */
2454                       BFD_ASSERT (rel->r_offset >= 3);
2455                       BFD_ASSERT (bfd_get_8 (input_bfd,
2456                                              contents + rel->r_offset - 3)
2457                                   == 0x8d);
2458                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2459                       memcpy (contents + rel->r_offset - 3,
2460                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2461                     }
2462                   else
2463                     {
2464                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2465                       if (rel->r_offset + 10 <= input_section->_raw_size
2466                           && bfd_get_8 (input_bfd,
2467                                         contents + rel->r_offset + 9) == 0x90)
2468                         {
2469                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2470                              Change it into:
2471                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2472                              (6 byte form of subl).  */
2473                           memcpy (contents + rel->r_offset - 2,
2474                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2475                           roff = rel->r_offset + 6;
2476                         }
2477                       else
2478                         {
2479                           /* leal foo(%reg), %eax; call ___tls_get_addr
2480                              Change it into:
2481                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2482                              (5 byte form of subl).  */
2483                           memcpy (contents + rel->r_offset - 2,
2484                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2485                         }
2486                     }
2487                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2488                               contents + roff);
2489                   /* Skip R_386_PLT32.  */
2490                   rel++;
2491                   continue;
2492                 }
2493               else
2494                 {
2495                   unsigned int val, type;
2496
2497                   /* IE->LE transition:
2498                      Originally it can be either:
2499                      subl foo(%reg1), %reg2
2500                      or
2501                      movl foo(%reg1), %reg2
2502                      We change it into:
2503                      subl $foo, %reg2
2504                      or
2505                      movl $foo, %reg2 (6 byte form)  */
2506                   BFD_ASSERT (rel->r_offset >= 2);
2507                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2508                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2509                   BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2510                   if (type == 0x8b)
2511                     {
2512                       /* movl */
2513                       BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2514                       bfd_put_8 (output_bfd, 0xc7,
2515                                  contents + rel->r_offset - 2);
2516                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2517                                  contents + rel->r_offset - 1);
2518                     }
2519                   else if (type == 0x2b)
2520                     {
2521                       /* subl */
2522                       BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2523                       bfd_put_8 (output_bfd, 0x81,
2524                                  contents + rel->r_offset - 2);
2525                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2526                                  contents + rel->r_offset - 1);
2527                     }
2528                   else
2529                     BFD_FAIL ();
2530                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2531                               contents + rel->r_offset);
2532                   continue;
2533                 }
2534             }
2535
2536           if (htab->sgot == NULL)
2537             abort ();
2538
2539           if (h != NULL)
2540             off = h->got.offset;
2541           else
2542             {
2543               if (local_got_offsets == NULL)
2544                 abort ();
2545
2546               off = local_got_offsets[r_symndx];
2547             }
2548
2549           if ((off & 1) != 0)
2550             off &= ~1;
2551           else
2552             {
2553               Elf_Internal_Rel outrel;
2554               Elf32_External_Rel *loc;
2555               int dr_type, indx;
2556
2557               if (htab->srelgot == NULL)
2558                 abort ();
2559
2560               outrel.r_offset = (htab->sgot->output_section->vma
2561                                  + htab->sgot->output_offset + off);
2562
2563               bfd_put_32 (output_bfd, 0,
2564                           htab->sgot->contents + off);
2565               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2566               if (r_type == R_386_TLS_GD)
2567                 dr_type = R_386_TLS_DTPMOD32;
2568               else
2569                 dr_type = R_386_TLS_TPOFF32;
2570               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2571               loc = (Elf32_External_Rel *) htab->srelgot->contents;
2572               loc += htab->srelgot->reloc_count++;
2573               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2574
2575               if (r_type == R_386_TLS_GD)
2576                 {
2577                   if (indx == 0)
2578                     {
2579                       BFD_ASSERT (! unresolved_reloc);
2580                       bfd_put_32 (output_bfd,
2581                                   relocation - dtpoff_base (info),
2582                                   htab->sgot->contents + off + 4);
2583                     }
2584                   else
2585                     {
2586                       bfd_put_32 (output_bfd, 0,
2587                                   htab->sgot->contents + off + 4);
2588                       outrel.r_info = ELF32_R_INFO (indx,
2589                                                     R_386_TLS_DTPOFF32);
2590                       outrel.r_offset += 4;
2591                       htab->srelgot->reloc_count++;
2592                       loc++;
2593                       bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2594                                                 loc);
2595                     }
2596                 }
2597
2598               if (h != NULL)
2599                 h->got.offset |= 1;
2600               else
2601                 local_got_offsets[r_symndx] |= 1;
2602             }
2603
2604           if (off >= (bfd_vma) -2)
2605             abort ();
2606           if (r_type == ELF32_R_TYPE (rel->r_info))
2607             {
2608               relocation = htab->sgot->output_offset + off;
2609               unresolved_reloc = false;
2610             }
2611           else
2612             {
2613               unsigned int val, type;
2614               bfd_vma roff;
2615
2616               /* GD->IE transition.  */
2617               BFD_ASSERT (rel->r_offset >= 2);
2618               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2619               BFD_ASSERT (type == 0x8d || type == 0x04);
2620               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2621               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2622                           == 0xe8);
2623               BFD_ASSERT (rel + 1 < relend);
2624               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2625               roff = rel->r_offset - 3;
2626               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2627               if (type == 0x04)
2628                 {
2629                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2630                      Change it into:
2631                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2632                   BFD_ASSERT (rel->r_offset >= 3);
2633                   BFD_ASSERT (bfd_get_8 (input_bfd,
2634                                          contents + rel->r_offset - 3)
2635                               == 0x8d);
2636                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2637                   val >>= 3;
2638                 }
2639               else
2640                 {
2641                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2642                      Change it into:
2643                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2644                   BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2645                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2646                   BFD_ASSERT (bfd_get_8 (input_bfd,
2647                                          contents + rel->r_offset + 9)
2648                               == 0x90);
2649                   roff = rel->r_offset - 2;
2650                 }
2651               memcpy (contents + roff,
2652                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2653               contents[roff + 7] = 0x80 | (val & 7);
2654               bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2655                           contents + roff + 8);
2656               /* Skip R_386_PLT32.  */
2657               rel++;
2658               continue;
2659             }
2660           break;
2661
2662         case R_386_TLS_LDM:
2663           if (! info->shared)
2664             {
2665               unsigned int val;
2666
2667               /* LD->LE transition:
2668                  Ensure it is:
2669                  leal foo(%reg), %eax; call ___tls_get_addr.
2670                  We change it into:
2671                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
2672               BFD_ASSERT (rel->r_offset >= 2);
2673               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2674                           == 0x8d);
2675               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2676               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2677               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2678               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2679                           == 0xe8);
2680               BFD_ASSERT (rel + 1 < relend);
2681               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2682               memcpy (contents + rel->r_offset - 2,
2683                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2684               /* Skip R_386_PLT32.  */
2685               rel++;
2686               continue;
2687             }
2688
2689           if (htab->sgot == NULL)
2690             abort ();
2691
2692           off = htab->tls_ldm_got.offset;
2693           if (off & 1)
2694             off &= ~1;
2695           else
2696             {
2697               Elf_Internal_Rel outrel;
2698               Elf32_External_Rel *loc;
2699
2700               if (htab->srelgot == NULL)
2701                 abort ();
2702
2703               outrel.r_offset = (htab->sgot->output_section->vma
2704                                  + htab->sgot->output_offset + off);
2705
2706               bfd_put_32 (output_bfd, 0,
2707                           htab->sgot->contents + off);
2708               bfd_put_32 (output_bfd, 0,
2709                           htab->sgot->contents + off + 4);
2710               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2711               loc = (Elf32_External_Rel *) htab->srelgot->contents;
2712               loc += htab->srelgot->reloc_count++;
2713               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2714               htab->tls_ldm_got.offset |= 1;
2715             }
2716           relocation = htab->sgot->output_offset + off;
2717           unresolved_reloc = false;
2718           break;
2719
2720         case R_386_TLS_LDO_32:
2721           if (info->shared)
2722             relocation -= dtpoff_base (info);
2723           else
2724             /* When converting LDO to LE, we must negate.  */
2725             relocation = -tpoff (info, relocation);
2726           break;
2727
2728         case R_386_TLS_LE_32:
2729           relocation = tpoff (info, relocation);
2730           break;
2731
2732         case R_386_TLS_LE:
2733           relocation = -tpoff (info, relocation);
2734           break;
2735
2736         default:
2737           break;
2738         }
2739
2740       /* FIXME: Why do we allow debugging sections to escape this error?
2741          More importantly, why do we not emit dynamic relocs for
2742          R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
2743          If we had emitted the dynamic reloc, we could remove the
2744          fudge here.  */
2745       if (unresolved_reloc
2746           && !(info->shared
2747                && (input_section->flags & SEC_DEBUGGING) != 0
2748                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2749         (*_bfd_error_handler)
2750           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2751            bfd_archive_filename (input_bfd),
2752            bfd_get_section_name (input_bfd, input_section),
2753            (long) rel->r_offset,
2754            h->root.root.string);
2755
2756       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2757                                     contents, rel->r_offset,
2758                                     relocation, (bfd_vma) 0);
2759
2760       if (r != bfd_reloc_ok)
2761         {
2762           const char *name;
2763
2764           if (h != NULL)
2765             name = h->root.root.string;
2766           else
2767             {
2768               name = bfd_elf_string_from_elf_section (input_bfd,
2769                                                       symtab_hdr->sh_link,
2770                                                       sym->st_name);
2771               if (name == NULL)
2772                 return false;
2773               if (*name == '\0')
2774                 name = bfd_section_name (input_bfd, sec);
2775             }
2776
2777           if (r == bfd_reloc_overflow)
2778             {
2779               if (! ((*info->callbacks->reloc_overflow)
2780                      (info, name, howto->name, (bfd_vma) 0,
2781                       input_bfd, input_section, rel->r_offset)))
2782                 return false;
2783             }
2784           else
2785             {
2786               (*_bfd_error_handler)
2787                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2788                  bfd_archive_filename (input_bfd),
2789                  bfd_get_section_name (input_bfd, input_section),
2790                  (long) rel->r_offset, name, (int) r);
2791               return false;
2792             }
2793         }
2794     }
2795
2796   return true;
2797 }
2798
2799 /* Finish up dynamic symbol handling.  We set the contents of various
2800    dynamic sections here.  */
2801
2802 static boolean
2803 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2804      bfd *output_bfd;
2805      struct bfd_link_info *info;
2806      struct elf_link_hash_entry *h;
2807      Elf_Internal_Sym *sym;
2808 {
2809   struct elf_i386_link_hash_table *htab;
2810
2811   htab = elf_i386_hash_table (info);
2812
2813   if (h->plt.offset != (bfd_vma) -1)
2814     {
2815       bfd_vma plt_index;
2816       bfd_vma got_offset;
2817       Elf_Internal_Rel rel;
2818       Elf32_External_Rel *loc;
2819
2820       /* This symbol has an entry in the procedure linkage table.  Set
2821          it up.  */
2822
2823       if (h->dynindx == -1
2824           || htab->splt == NULL
2825           || htab->sgotplt == NULL
2826           || htab->srelplt == NULL)
2827         abort ();
2828
2829       /* Get the index in the procedure linkage table which
2830          corresponds to this symbol.  This is the index of this symbol
2831          in all the symbols for which we are making plt entries.  The
2832          first entry in the procedure linkage table is reserved.  */
2833       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2834
2835       /* Get the offset into the .got table of the entry that
2836          corresponds to this function.  Each .got entry is 4 bytes.
2837          The first three are reserved.  */
2838       got_offset = (plt_index + 3) * 4;
2839
2840       /* Fill in the entry in the procedure linkage table.  */
2841       if (! info->shared)
2842         {
2843           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
2844                   PLT_ENTRY_SIZE);
2845           bfd_put_32 (output_bfd,
2846                       (htab->sgotplt->output_section->vma
2847                        + htab->sgotplt->output_offset
2848                        + got_offset),
2849                       htab->splt->contents + h->plt.offset + 2);
2850         }
2851       else
2852         {
2853           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
2854                   PLT_ENTRY_SIZE);
2855           bfd_put_32 (output_bfd, got_offset,
2856                       htab->splt->contents + h->plt.offset + 2);
2857         }
2858
2859       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
2860                   htab->splt->contents + h->plt.offset + 7);
2861       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2862                   htab->splt->contents + h->plt.offset + 12);
2863
2864       /* Fill in the entry in the global offset table.  */
2865       bfd_put_32 (output_bfd,
2866                   (htab->splt->output_section->vma
2867                    + htab->splt->output_offset
2868                    + h->plt.offset
2869                    + 6),
2870                   htab->sgotplt->contents + got_offset);
2871
2872       /* Fill in the entry in the .rel.plt section.  */
2873       rel.r_offset = (htab->sgotplt->output_section->vma
2874                       + htab->sgotplt->output_offset
2875                       + got_offset);
2876       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
2877       loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2878       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2879
2880       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2881         {
2882           /* Mark the symbol as undefined, rather than as defined in
2883              the .plt section.  Leave the value alone.  This is a clue
2884              for the dynamic linker, to make function pointer
2885              comparisons work between an application and shared
2886              library.  */
2887           sym->st_shndx = SHN_UNDEF;
2888         }
2889     }
2890
2891   if (h->got.offset != (bfd_vma) -1
2892       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
2893       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_IE)
2894     {
2895       Elf_Internal_Rel rel;
2896       Elf32_External_Rel *loc;
2897
2898       /* This symbol has an entry in the global offset table.  Set it
2899          up.  */
2900
2901       if (htab->sgot == NULL || htab->srelgot == NULL)
2902         abort ();
2903
2904       rel.r_offset = (htab->sgot->output_section->vma
2905                       + htab->sgot->output_offset
2906                       + (h->got.offset & ~(bfd_vma) 1));
2907
2908       /* If this is a static link, or it is a -Bsymbolic link and the
2909          symbol is defined locally or was forced to be local because
2910          of a version file, we just want to emit a RELATIVE reloc.
2911          The entry in the global offset table will already have been
2912          initialized in the relocate_section function.  */
2913       if (info->shared
2914           && (info->symbolic
2915               || h->dynindx == -1
2916               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2917           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2918         {
2919           BFD_ASSERT((h->got.offset & 1) != 0);
2920           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2921         }
2922       else
2923         {
2924           BFD_ASSERT((h->got.offset & 1) == 0);
2925           bfd_put_32 (output_bfd, (bfd_vma) 0,
2926                       htab->sgot->contents + h->got.offset);
2927           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2928         }
2929
2930       loc = (Elf32_External_Rel *) htab->srelgot->contents;
2931       loc += htab->srelgot->reloc_count++;
2932       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2933     }
2934
2935   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2936     {
2937       Elf_Internal_Rel rel;
2938       Elf32_External_Rel *loc;
2939
2940       /* This symbol needs a copy reloc.  Set it up.  */
2941
2942       if (h->dynindx == -1
2943           || (h->root.type != bfd_link_hash_defined
2944               && h->root.type != bfd_link_hash_defweak)
2945           || htab->srelbss == NULL)
2946         abort ();
2947
2948       rel.r_offset = (h->root.u.def.value
2949                       + h->root.u.def.section->output_section->vma
2950                       + h->root.u.def.section->output_offset);
2951       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2952       loc = (Elf32_External_Rel *) htab->srelbss->contents;
2953       loc += htab->srelbss->reloc_count++;
2954       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2955     }
2956
2957   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2958   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2959       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2960     sym->st_shndx = SHN_ABS;
2961
2962   return true;
2963 }
2964
2965 /* Used to decide how to sort relocs in an optimal manner for the
2966    dynamic linker, before writing them out.  */
2967
2968 static enum elf_reloc_type_class
2969 elf_i386_reloc_type_class (rela)
2970      const Elf_Internal_Rela *rela;
2971 {
2972   switch ((int) ELF32_R_TYPE (rela->r_info))
2973     {
2974     case R_386_RELATIVE:
2975       return reloc_class_relative;
2976     case R_386_JUMP_SLOT:
2977       return reloc_class_plt;
2978     case R_386_COPY:
2979       return reloc_class_copy;
2980     default:
2981       return reloc_class_normal;
2982     }
2983 }
2984
2985 /* Finish up the dynamic sections.  */
2986
2987 static boolean
2988 elf_i386_finish_dynamic_sections (output_bfd, info)
2989      bfd *output_bfd;
2990      struct bfd_link_info *info;
2991 {
2992   struct elf_i386_link_hash_table *htab;
2993   bfd *dynobj;
2994   asection *sdyn;
2995
2996   htab = elf_i386_hash_table (info);
2997   dynobj = htab->elf.dynobj;
2998   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2999
3000   if (htab->elf.dynamic_sections_created)
3001     {
3002       Elf32_External_Dyn *dyncon, *dynconend;
3003
3004       if (sdyn == NULL || htab->sgot == NULL)
3005         abort ();
3006
3007       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3008       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3009       for (; dyncon < dynconend; dyncon++)
3010         {
3011           Elf_Internal_Dyn dyn;
3012           asection *s;
3013
3014           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3015
3016           switch (dyn.d_tag)
3017             {
3018             default:
3019               continue;
3020
3021             case DT_PLTGOT:
3022               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3023               break;
3024
3025             case DT_JMPREL:
3026               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3027               break;
3028
3029             case DT_PLTRELSZ:
3030               s = htab->srelplt->output_section;
3031               if (s->_cooked_size != 0)
3032                 dyn.d_un.d_val = s->_cooked_size;
3033               else
3034                 dyn.d_un.d_val = s->_raw_size;
3035               break;
3036
3037             case DT_RELSZ:
3038               /* My reading of the SVR4 ABI indicates that the
3039                  procedure linkage table relocs (DT_JMPREL) should be
3040                  included in the overall relocs (DT_REL).  This is
3041                  what Solaris does.  However, UnixWare can not handle
3042                  that case.  Therefore, we override the DT_RELSZ entry
3043                  here to make it not include the JMPREL relocs.  Since
3044                  the linker script arranges for .rel.plt to follow all
3045                  other relocation sections, we don't have to worry
3046                  about changing the DT_REL entry.  */
3047               if (htab->srelplt != NULL)
3048                 {
3049                   s = htab->srelplt->output_section;
3050                   if (s->_cooked_size != 0)
3051                     dyn.d_un.d_val -= s->_cooked_size;
3052                   else
3053                     dyn.d_un.d_val -= s->_raw_size;
3054                 }
3055               break;
3056             }
3057
3058           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3059         }
3060
3061       /* Fill in the first entry in the procedure linkage table.  */
3062       if (htab->splt && htab->splt->_raw_size > 0)
3063         {
3064           if (info->shared)
3065             memcpy (htab->splt->contents,
3066                     elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
3067           else
3068             {
3069               memcpy (htab->splt->contents,
3070                       elf_i386_plt0_entry, PLT_ENTRY_SIZE);
3071               bfd_put_32 (output_bfd,
3072                           (htab->sgotplt->output_section->vma
3073                            + htab->sgotplt->output_offset
3074                            + 4),
3075                           htab->splt->contents + 2);
3076               bfd_put_32 (output_bfd,
3077                           (htab->sgotplt->output_section->vma
3078                            + htab->sgotplt->output_offset
3079                            + 8),
3080                           htab->splt->contents + 8);
3081             }
3082
3083           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3084              really seem like the right value.  */
3085           elf_section_data (htab->splt->output_section)
3086             ->this_hdr.sh_entsize = 4;
3087         }
3088     }
3089
3090   if (htab->sgotplt)
3091     {
3092       /* Fill in the first three entries in the global offset table.  */
3093       if (htab->sgotplt->_raw_size > 0)
3094         {
3095           bfd_put_32 (output_bfd,
3096                       (sdyn == NULL ? (bfd_vma) 0
3097                        : sdyn->output_section->vma + sdyn->output_offset),
3098                       htab->sgotplt->contents);
3099           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3100           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3101         }
3102
3103       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3104     }
3105   return true;
3106 }
3107
3108 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3109 #define TARGET_LITTLE_NAME              "elf32-i386"
3110 #define ELF_ARCH                        bfd_arch_i386
3111 #define ELF_MACHINE_CODE                EM_386
3112 #define ELF_MAXPAGESIZE                 0x1000
3113
3114 #define elf_backend_can_gc_sections     1
3115 #define elf_backend_can_refcount        1
3116 #define elf_backend_want_got_plt        1
3117 #define elf_backend_plt_readonly        1
3118 #define elf_backend_want_plt_sym        0
3119 #define elf_backend_got_header_size     12
3120 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3121
3122 #define elf_info_to_howto                     elf_i386_info_to_howto
3123 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3124
3125 #define bfd_elf32_mkobject                    elf_i386_mkobject
3126 #define elf_backend_object_p                  elf_i386_object_p
3127
3128 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3129 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3130 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3131
3132 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3133 #define elf_backend_check_relocs              elf_i386_check_relocs
3134 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3135 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3136 #define elf_backend_fake_sections             elf_i386_fake_sections
3137 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3138 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3139 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3140 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3141 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3142 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3143 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3144 #define elf_backend_relocate_section          elf_i386_relocate_section
3145 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3146
3147 #ifndef ELF32_I386_C_INCLUDED
3148 #include "elf32-target.h"
3149 #endif