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