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