bfd/elf32-i386.c

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