bfd/elf32-i386.c

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