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