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   BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
1966   return elf_hash_table (info)->tls_segment->start;
1967 }
1968
1969 /* Return the relocation value for @tpoff relocation
1970    if STT_TLS virtual address is ADDRESS.  */
1971
1972 static bfd_vma
1973 tpoff (info, address)
1974      struct bfd_link_info *info;
1975      bfd_vma address;
1976 {
1977   struct elf_link_tls_segment *tls_segment
1978     = elf_hash_table (info)->tls_segment;
1979
1980   BFD_ASSERT (tls_segment != NULL);
1981   return (align_power (tls_segment->size, tls_segment->align)
1982           + tls_segment->start - address);
1983 }
1984
1985 /* Relocate an i386 ELF section.  */
1986
1987 static boolean
1988 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1989                            contents, relocs, local_syms, local_sections)
1990      bfd *output_bfd;
1991      struct bfd_link_info *info;
1992      bfd *input_bfd;
1993      asection *input_section;
1994      bfd_byte *contents;
1995      Elf_Internal_Rela *relocs;
1996      Elf_Internal_Sym *local_syms;
1997      asection **local_sections;
1998 {
1999   struct elf_i386_link_hash_table *htab;
2000   Elf_Internal_Shdr *symtab_hdr;
2001   struct elf_link_hash_entry **sym_hashes;
2002   bfd_vma *local_got_offsets;
2003   Elf_Internal_Rela *rel;
2004   Elf_Internal_Rela *relend;
2005
2006   htab = elf_i386_hash_table (info);
2007   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2008   sym_hashes = elf_sym_hashes (input_bfd);
2009   local_got_offsets = elf_local_got_offsets (input_bfd);
2010
2011   rel = relocs;
2012   relend = relocs + input_section->reloc_count;
2013   for (; rel < relend; rel++)
2014     {
2015       unsigned int r_type;
2016       reloc_howto_type *howto;
2017       unsigned long r_symndx;
2018       struct elf_link_hash_entry *h;
2019       Elf_Internal_Sym *sym;
2020       asection *sec;
2021       bfd_vma off;
2022       bfd_vma relocation;
2023       boolean unresolved_reloc;
2024       bfd_reloc_status_type r;
2025       unsigned int indx;
2026       int tls_type;
2027
2028       r_type = ELF32_R_TYPE (rel->r_info);
2029       if (r_type == (int) R_386_GNU_VTINHERIT
2030           || r_type == (int) R_386_GNU_VTENTRY)
2031         continue;
2032
2033       if ((indx = (unsigned) r_type) >= R_386_standard
2034           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2035               >= R_386_ext - R_386_standard)
2036           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2037               >= R_386_tls - R_386_ext))
2038         {
2039           bfd_set_error (bfd_error_bad_value);
2040           return false;
2041         }
2042       howto = elf_howto_table + indx;
2043
2044       r_symndx = ELF32_R_SYM (rel->r_info);
2045
2046       if (info->relocateable)
2047         {
2048           bfd_vma val;
2049           bfd_byte *where;
2050
2051           /* This is a relocatable link.  We don't have to change
2052              anything, unless the reloc is against a section symbol,
2053              in which case we have to adjust according to where the
2054              section symbol winds up in the output section.  */
2055           if (r_symndx >= symtab_hdr->sh_info)
2056             continue;
2057
2058           sym = local_syms + r_symndx;
2059           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2060             continue;
2061
2062           sec = local_sections[r_symndx];
2063           val = sec->output_offset;
2064           if (val == 0)
2065             continue;
2066
2067           where = contents + rel->r_offset;
2068           switch (howto->size)
2069             {
2070               /* FIXME: overflow checks.  */
2071             case 0:
2072               val += bfd_get_8 (input_bfd, where);
2073               bfd_put_8 (input_bfd, val, where);
2074               break;
2075             case 1:
2076               val += bfd_get_16 (input_bfd, where);
2077               bfd_put_16 (input_bfd, val, where);
2078               break;
2079             case 2:
2080               val += bfd_get_32 (input_bfd, where);
2081               bfd_put_32 (input_bfd, val, where);
2082               break;
2083             default:
2084               abort ();
2085             }
2086           continue;
2087         }
2088
2089       /* This is a final link.  */
2090       h = NULL;
2091       sym = NULL;
2092       sec = NULL;
2093       unresolved_reloc = false;
2094       if (r_symndx < symtab_hdr->sh_info)
2095         {
2096           sym = local_syms + r_symndx;
2097           sec = local_sections[r_symndx];
2098           relocation = (sec->output_section->vma
2099                         + sec->output_offset
2100                         + sym->st_value);
2101           if ((sec->flags & SEC_MERGE)
2102               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2103             {
2104               asection *msec;
2105               bfd_vma addend;
2106               bfd_byte *where = contents + rel->r_offset;
2107
2108               switch (howto->size)
2109                 {
2110                 case 0:
2111                   addend = bfd_get_8 (input_bfd, where);
2112                   if (howto->pc_relative)
2113                     {
2114                       addend = (addend ^ 0x80) - 0x80;
2115                       addend += 1;
2116                     }
2117                   break;
2118                 case 1:
2119                   addend = bfd_get_16 (input_bfd, where);
2120                   if (howto->pc_relative)
2121                     {
2122                       addend = (addend ^ 0x8000) - 0x8000;
2123                       addend += 2;
2124                     }
2125                   break;
2126                 case 2:
2127                   addend = bfd_get_32 (input_bfd, where);
2128                   if (howto->pc_relative)
2129                     {
2130                       addend = (addend ^ 0x80000000) - 0x80000000;
2131                       addend += 4;
2132                     }
2133                   break;
2134                 default:
2135                   abort ();
2136                 }
2137
2138               msec = sec;
2139               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2140               addend -= relocation;
2141               addend += msec->output_section->vma + msec->output_offset;
2142
2143               switch (howto->size)
2144                 {
2145                 case 0:
2146                   /* FIXME: overflow checks.  */
2147                   if (howto->pc_relative)
2148                     addend -= 1;
2149                   bfd_put_8 (input_bfd, addend, where);
2150                   break;
2151                 case 1:
2152                   if (howto->pc_relative)
2153                     addend -= 2;
2154                   bfd_put_16 (input_bfd, addend, where);
2155                   break;
2156                 case 2:
2157                   if (howto->pc_relative)
2158                     addend -= 4;
2159                   bfd_put_32 (input_bfd, addend, where);
2160                   break;
2161                 }
2162             }
2163         }
2164       else
2165         {
2166           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2167           while (h->root.type == bfd_link_hash_indirect
2168                  || h->root.type == bfd_link_hash_warning)
2169             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2170
2171           relocation = 0;
2172           if (h->root.type == bfd_link_hash_defined
2173               || h->root.type == bfd_link_hash_defweak)
2174             {
2175               sec = h->root.u.def.section;
2176               if (sec->output_section == NULL)
2177                 /* Set a flag that will be cleared later if we find a
2178                    relocation value for this symbol.  output_section
2179                    is typically NULL for symbols satisfied by a shared
2180                    library.  */
2181                 unresolved_reloc = true;
2182               else
2183                 relocation = (h->root.u.def.value
2184                               + sec->output_section->vma
2185                               + sec->output_offset);
2186             }
2187           else if (h->root.type == bfd_link_hash_undefweak)
2188             ;
2189           else if (info->shared
2190                    && (!info->symbolic || info->allow_shlib_undefined)
2191                    && !info->no_undefined
2192                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2193             ;
2194           else
2195             {
2196               if (! ((*info->callbacks->undefined_symbol)
2197                      (info, h->root.root.string, input_bfd,
2198                       input_section, rel->r_offset,
2199                       (!info->shared || info->no_undefined
2200                        || ELF_ST_VISIBILITY (h->other)))))
2201                 return false;
2202             }
2203         }
2204
2205       switch (r_type)
2206         {
2207         case R_386_GOT32:
2208           /* Relocation is to the entry for this symbol in the global
2209              offset table.  */
2210           if (htab->sgot == NULL)
2211             abort ();
2212
2213           if (h != NULL)
2214             {
2215               boolean dyn;
2216
2217               off = h->got.offset;
2218               dyn = htab->elf.dynamic_sections_created;
2219               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2220                   || (info->shared
2221                       && (info->symbolic
2222                           || h->dynindx == -1
2223                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2224                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2225                 {
2226                   /* This is actually a static link, or it is a
2227                      -Bsymbolic link and the symbol is defined
2228                      locally, or the symbol was forced to be local
2229                      because of a version file.  We must initialize
2230                      this entry in the global offset table.  Since the
2231                      offset must always be a multiple of 4, we use the
2232                      least significant bit to record whether we have
2233                      initialized it already.
2234
2235                      When doing a dynamic link, we create a .rel.got
2236                      relocation entry to initialize the value.  This
2237                      is done in the finish_dynamic_symbol routine.  */
2238                   if ((off & 1) != 0)
2239                     off &= ~1;
2240                   else
2241                     {
2242                       bfd_put_32 (output_bfd, relocation,
2243                                   htab->sgot->contents + off);
2244                       h->got.offset |= 1;
2245                     }
2246                 }
2247               else
2248                 unresolved_reloc = false;
2249             }
2250           else
2251             {
2252               if (local_got_offsets == NULL)
2253                 abort ();
2254
2255               off = local_got_offsets[r_symndx];
2256
2257               /* The offset must always be a multiple of 4.  We use
2258                  the least significant bit to record whether we have
2259                  already generated the necessary reloc.  */
2260               if ((off & 1) != 0)
2261                 off &= ~1;
2262               else
2263                 {
2264                   bfd_put_32 (output_bfd, relocation,
2265                               htab->sgot->contents + off);
2266
2267                   if (info->shared)
2268                     {
2269                       asection *srelgot;
2270                       Elf_Internal_Rel outrel;
2271                       Elf32_External_Rel *loc;
2272
2273                       srelgot = htab->srelgot;
2274                       if (srelgot == NULL)
2275                         abort ();
2276
2277                       outrel.r_offset = (htab->sgot->output_section->vma
2278                                          + htab->sgot->output_offset
2279                                          + off);
2280                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2281                       loc = (Elf32_External_Rel *) srelgot->contents;
2282                       loc += srelgot->reloc_count++;
2283                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2284                     }
2285
2286                   local_got_offsets[r_symndx] |= 1;
2287                 }
2288             }
2289
2290           if (off >= (bfd_vma) -2)
2291             abort ();
2292
2293           relocation = htab->sgot->output_offset + off;
2294           break;
2295
2296         case R_386_GOTOFF:
2297           /* Relocation is relative to the start of the global offset
2298              table.  */
2299
2300           /* Note that sgot->output_offset is not involved in this
2301              calculation.  We always want the start of .got.  If we
2302              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2303              permitted by the ABI, we might have to change this
2304              calculation.  */
2305           relocation -= htab->sgot->output_section->vma;
2306           break;
2307
2308         case R_386_GOTPC:
2309           /* Use global offset table as symbol value.  */
2310           relocation = htab->sgot->output_section->vma;
2311           unresolved_reloc = false;
2312           break;
2313
2314         case R_386_PLT32:
2315           /* Relocation is to the entry for this symbol in the
2316              procedure linkage table.  */
2317
2318           /* Resolve a PLT32 reloc against a local symbol directly,
2319              without using the procedure linkage table.  */
2320           if (h == NULL)
2321             break;
2322
2323           if (h->plt.offset == (bfd_vma) -1
2324               || htab->splt == NULL)
2325             {
2326               /* We didn't make a PLT entry for this symbol.  This
2327                  happens when statically linking PIC code, or when
2328                  using -Bsymbolic.  */
2329               break;
2330             }
2331
2332           relocation = (htab->splt->output_section->vma
2333                         + htab->splt->output_offset
2334                         + h->plt.offset);
2335           unresolved_reloc = false;
2336           break;
2337
2338         case R_386_32:
2339         case R_386_PC32:
2340           /* r_symndx will be zero only for relocs against symbols
2341              from removed linkonce sections, or sections discarded by
2342              a linker script.  */
2343           if (r_symndx == 0
2344               || (input_section->flags & SEC_ALLOC) == 0)
2345             break;
2346
2347           if ((info->shared
2348                && (r_type != R_386_PC32
2349                    || (h != NULL
2350                        && h->dynindx != -1
2351                        && (! info->symbolic
2352                            || (h->elf_link_hash_flags
2353                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2354               || (!info->shared
2355                   && h != NULL
2356                   && h->dynindx != -1
2357                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2358                   && (((h->elf_link_hash_flags
2359                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2360                        && (h->elf_link_hash_flags
2361                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2362                       || h->root.type == bfd_link_hash_undefweak
2363                       || h->root.type == bfd_link_hash_undefined)))
2364             {
2365               Elf_Internal_Rel outrel;
2366               boolean skip, relocate;
2367               asection *sreloc;
2368               Elf32_External_Rel *loc;
2369
2370               /* When generating a shared object, these relocations
2371                  are copied into the output file to be resolved at run
2372                  time.  */
2373
2374               skip = false;
2375               relocate = false;
2376
2377               outrel.r_offset =
2378                 _bfd_elf_section_offset (output_bfd, info, input_section,
2379                                          rel->r_offset);
2380               if (outrel.r_offset == (bfd_vma) -1)
2381                 skip = true;
2382               else if (outrel.r_offset == (bfd_vma) -2)
2383                 skip = true, relocate = true;
2384               outrel.r_offset += (input_section->output_section->vma
2385                                   + input_section->output_offset);
2386
2387               if (skip)
2388                 memset (&outrel, 0, sizeof outrel);
2389               else if (h != NULL
2390                        && h->dynindx != -1
2391                        && (r_type == R_386_PC32
2392                            || !info->shared
2393                            || !info->symbolic
2394                            || (h->elf_link_hash_flags
2395                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2396                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2397               else
2398                 {
2399                   /* This symbol is local, or marked to become local.  */
2400                   relocate = true;
2401                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2402                 }
2403
2404               sreloc = elf_section_data (input_section)->sreloc;
2405               if (sreloc == NULL)
2406                 abort ();
2407
2408               loc = (Elf32_External_Rel *) sreloc->contents;
2409               loc += sreloc->reloc_count++;
2410               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2411
2412               /* If this reloc is against an external symbol, we do
2413                  not want to fiddle with the addend.  Otherwise, we
2414                  need to include the symbol value so that it becomes
2415                  an addend for the dynamic reloc.  */
2416               if (! relocate)
2417                 continue;
2418             }
2419           break;
2420
2421         case R_386_TLS_GD:
2422         case R_386_TLS_IE_32:
2423           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2424           tls_type = GOT_UNKNOWN;
2425           if (h == NULL && local_got_offsets)
2426             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2427           else if (h != NULL)
2428             {
2429               tls_type = elf_i386_hash_entry(h)->tls_type;
2430               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2431                 r_type = R_386_TLS_LE_32;
2432             }
2433           if (r_type == R_386_TLS_GD && tls_type == GOT_TLS_IE)
2434             r_type = R_386_TLS_IE_32;
2435
2436           if (r_type == R_386_TLS_LE_32)
2437             {
2438               BFD_ASSERT (! unresolved_reloc);
2439               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2440                 {
2441                   unsigned int val, type;
2442                   bfd_vma roff;
2443
2444                   /* GD->LE transition.  */
2445                   BFD_ASSERT (rel->r_offset >= 2);
2446                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2447                   BFD_ASSERT (type == 0x8d || type == 0x04);
2448                   BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2449                   BFD_ASSERT (bfd_get_8 (input_bfd,
2450                                          contents + rel->r_offset + 4)
2451                               == 0xe8);
2452                   BFD_ASSERT (rel + 1 < relend);
2453                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2454                   roff = rel->r_offset + 5;
2455                   val = bfd_get_8 (input_bfd,
2456                                    contents + rel->r_offset - 1);
2457                   if (type == 0x04)
2458                     {
2459                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2460                          Change it into:
2461                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2462                          (6 byte form of subl).  */
2463                       BFD_ASSERT (rel->r_offset >= 3);
2464                       BFD_ASSERT (bfd_get_8 (input_bfd,
2465                                              contents + rel->r_offset - 3)
2466                                   == 0x8d);
2467                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2468                       memcpy (contents + rel->r_offset - 3,
2469                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2470                     }
2471                   else
2472                     {
2473                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2474                       if (rel->r_offset + 10 <= input_section->_raw_size
2475                           && bfd_get_8 (input_bfd,
2476                                         contents + rel->r_offset + 9) == 0x90)
2477                         {
2478                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2479                              Change it into:
2480                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2481                              (6 byte form of subl).  */
2482                           memcpy (contents + rel->r_offset - 2,
2483                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2484                           roff = rel->r_offset + 6;
2485                         }
2486                       else
2487                         {
2488                           /* leal foo(%reg), %eax; call ___tls_get_addr
2489                              Change it into:
2490                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2491                              (5 byte form of subl).  */
2492                           memcpy (contents + rel->r_offset - 2,
2493                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2494                         }
2495                     }
2496                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2497                               contents + roff);
2498                   /* Skip R_386_PLT32.  */
2499                   rel++;
2500                   continue;
2501                 }
2502               else
2503                 {
2504                   unsigned int val, type;
2505
2506                   /* IE->LE transition:
2507                      Originally it can be either:
2508                      subl foo(%reg1), %reg2
2509                      or
2510                      movl foo(%reg1), %reg2
2511                      We change it into:
2512                      subl $foo, %reg2
2513                      or
2514                      movl $foo, %reg2 (6 byte form)  */
2515                   BFD_ASSERT (rel->r_offset >= 2);
2516                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2517                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2518                   BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2519                   if (type == 0x8b)
2520                     {
2521                       /* movl */
2522                       BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2523                       bfd_put_8 (output_bfd, 0xc7,
2524                                  contents + rel->r_offset - 2);
2525                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2526                                  contents + rel->r_offset - 1);
2527                     }
2528                   else if (type == 0x2b)
2529                     {
2530                       /* subl */
2531                       BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2532                       bfd_put_8 (output_bfd, 0x81,
2533                                  contents + rel->r_offset - 2);
2534                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2535                                  contents + rel->r_offset - 1);
2536                     }
2537                   else
2538                     BFD_FAIL ();
2539                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2540                               contents + rel->r_offset);
2541                   continue;
2542                 }
2543             }
2544
2545           if (htab->sgot == NULL)
2546             abort ();
2547
2548           if (h != NULL)
2549             off = h->got.offset;
2550           else
2551             {
2552               if (local_got_offsets == NULL)
2553                 abort ();
2554
2555               off = local_got_offsets[r_symndx];
2556             }
2557
2558           if ((off & 1) != 0)
2559             off &= ~1;
2560           else
2561             {
2562               Elf_Internal_Rel outrel;
2563               Elf32_External_Rel *loc;
2564               int dr_type, indx;
2565
2566               if (htab->srelgot == NULL)
2567                 abort ();
2568
2569               outrel.r_offset = (htab->sgot->output_section->vma
2570                                  + htab->sgot->output_offset + off);
2571
2572               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2573               if (r_type == R_386_TLS_GD)
2574                 dr_type = R_386_TLS_DTPMOD32;
2575               else
2576                 dr_type = R_386_TLS_TPOFF32;
2577               if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2578                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2579                             htab->sgot->contents + off);
2580               else
2581                 bfd_put_32 (output_bfd, 0,
2582                             htab->sgot->contents + off);
2583               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2584               loc = (Elf32_External_Rel *) htab->srelgot->contents;
2585               loc += htab->srelgot->reloc_count++;
2586               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2587
2588               if (r_type == R_386_TLS_GD)
2589                 {
2590                   if (indx == 0)
2591                     {
2592                       BFD_ASSERT (! unresolved_reloc);
2593                       bfd_put_32 (output_bfd,
2594                                   relocation - dtpoff_base (info),
2595                                   htab->sgot->contents + off + 4);
2596                     }
2597                   else
2598                     {
2599                       bfd_put_32 (output_bfd, 0,
2600                                   htab->sgot->contents + off + 4);
2601                       outrel.r_info = ELF32_R_INFO (indx,
2602                                                     R_386_TLS_DTPOFF32);
2603                       outrel.r_offset += 4;
2604                       htab->srelgot->reloc_count++;
2605                       loc++;
2606                       bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2607                                                 loc);
2608                     }
2609                 }
2610
2611               if (h != NULL)
2612                 h->got.offset |= 1;
2613               else
2614                 local_got_offsets[r_symndx] |= 1;
2615             }
2616
2617           if (off >= (bfd_vma) -2)
2618             abort ();
2619           if (r_type == ELF32_R_TYPE (rel->r_info))
2620             {
2621               relocation = htab->sgot->output_offset + off;
2622               unresolved_reloc = false;
2623             }
2624           else
2625             {
2626               unsigned int val, type;
2627               bfd_vma roff;
2628
2629               /* GD->IE transition.  */
2630               BFD_ASSERT (rel->r_offset >= 2);
2631               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2632               BFD_ASSERT (type == 0x8d || type == 0x04);
2633               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2634               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2635                           == 0xe8);
2636               BFD_ASSERT (rel + 1 < relend);
2637               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2638               roff = rel->r_offset - 3;
2639               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2640               if (type == 0x04)
2641                 {
2642                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2643                      Change it into:
2644                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2645                   BFD_ASSERT (rel->r_offset >= 3);
2646                   BFD_ASSERT (bfd_get_8 (input_bfd,
2647                                          contents + rel->r_offset - 3)
2648                               == 0x8d);
2649                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2650                   val >>= 3;
2651                 }
2652               else
2653                 {
2654                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2655                      Change it into:
2656                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2657                   BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2658                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2659                   BFD_ASSERT (bfd_get_8 (input_bfd,
2660                                          contents + rel->r_offset + 9)
2661                               == 0x90);
2662                   roff = rel->r_offset - 2;
2663                 }
2664               memcpy (contents + roff,
2665                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2666               contents[roff + 7] = 0x80 | (val & 7);
2667               bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2668                           contents + roff + 8);
2669               /* Skip R_386_PLT32.  */
2670               rel++;
2671               continue;
2672             }
2673           break;
2674
2675         case R_386_TLS_LDM:
2676           if (! info->shared)
2677             {
2678               unsigned int val;
2679
2680               /* LD->LE transition:
2681                  Ensure it is:
2682                  leal foo(%reg), %eax; call ___tls_get_addr.
2683                  We change it into:
2684                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
2685               BFD_ASSERT (rel->r_offset >= 2);
2686               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2687                           == 0x8d);
2688               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2689               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2690               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2691               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2692                           == 0xe8);
2693               BFD_ASSERT (rel + 1 < relend);
2694               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2695               memcpy (contents + rel->r_offset - 2,
2696                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2697               /* Skip R_386_PLT32.  */
2698               rel++;
2699               continue;
2700             }
2701
2702           if (htab->sgot == NULL)
2703             abort ();
2704
2705           off = htab->tls_ldm_got.offset;
2706           if (off & 1)
2707             off &= ~1;
2708           else
2709             {
2710               Elf_Internal_Rel outrel;
2711               Elf32_External_Rel *loc;
2712
2713               if (htab->srelgot == NULL)
2714                 abort ();
2715
2716               outrel.r_offset = (htab->sgot->output_section->vma
2717                                  + htab->sgot->output_offset + off);
2718
2719               bfd_put_32 (output_bfd, 0,
2720                           htab->sgot->contents + off);
2721               bfd_put_32 (output_bfd, 0,
2722                           htab->sgot->contents + off + 4);
2723               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2724               loc = (Elf32_External_Rel *) htab->srelgot->contents;
2725               loc += htab->srelgot->reloc_count++;
2726               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2727               htab->tls_ldm_got.offset |= 1;
2728             }
2729           relocation = htab->sgot->output_offset + off;
2730           unresolved_reloc = false;
2731           break;
2732
2733         case R_386_TLS_LDO_32:
2734           if (info->shared)
2735             relocation -= dtpoff_base (info);
2736           else
2737             /* When converting LDO to LE, we must negate.  */
2738             relocation = -tpoff (info, relocation);
2739           break;
2740
2741         case R_386_TLS_LE_32:
2742           relocation = tpoff (info, relocation);
2743           break;
2744
2745         case R_386_TLS_LE:
2746           relocation = -tpoff (info, relocation);
2747           break;
2748
2749         default:
2750           break;
2751         }
2752
2753       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2754          because such sections are not SEC_ALLOC and thus ld.so will
2755          not process them.  */
2756       if (unresolved_reloc
2757           && !((input_section->flags & SEC_DEBUGGING) != 0
2758                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2759         (*_bfd_error_handler)
2760           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2761            bfd_archive_filename (input_bfd),
2762            bfd_get_section_name (input_bfd, input_section),
2763            (long) rel->r_offset,
2764            h->root.root.string);
2765
2766       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2767                                     contents, rel->r_offset,
2768                                     relocation, (bfd_vma) 0);
2769
2770       if (r != bfd_reloc_ok)
2771         {
2772           const char *name;
2773
2774           if (h != NULL)
2775             name = h->root.root.string;
2776           else
2777             {
2778               name = bfd_elf_string_from_elf_section (input_bfd,
2779                                                       symtab_hdr->sh_link,
2780                                                       sym->st_name);
2781               if (name == NULL)
2782                 return false;
2783               if (*name == '\0')
2784                 name = bfd_section_name (input_bfd, sec);
2785             }
2786
2787           if (r == bfd_reloc_overflow)
2788             {
2789               if (! ((*info->callbacks->reloc_overflow)
2790                      (info, name, howto->name, (bfd_vma) 0,
2791                       input_bfd, input_section, rel->r_offset)))
2792                 return false;
2793             }
2794           else
2795             {
2796               (*_bfd_error_handler)
2797                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2798                  bfd_archive_filename (input_bfd),
2799                  bfd_get_section_name (input_bfd, input_section),
2800                  (long) rel->r_offset, name, (int) r);
2801               return false;
2802             }
2803         }
2804     }
2805
2806   return true;
2807 }
2808
2809 /* Finish up dynamic symbol handling.  We set the contents of various
2810    dynamic sections here.  */
2811
2812 static boolean
2813 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2814      bfd *output_bfd;
2815      struct bfd_link_info *info;
2816      struct elf_link_hash_entry *h;
2817      Elf_Internal_Sym *sym;
2818 {
2819   struct elf_i386_link_hash_table *htab;
2820
2821   htab = elf_i386_hash_table (info);
2822
2823   if (h->plt.offset != (bfd_vma) -1)
2824     {
2825       bfd_vma plt_index;
2826       bfd_vma got_offset;
2827       Elf_Internal_Rel rel;
2828       Elf32_External_Rel *loc;
2829
2830       /* This symbol has an entry in the procedure linkage table.  Set
2831          it up.  */
2832
2833       if (h->dynindx == -1
2834           || htab->splt == NULL
2835           || htab->sgotplt == NULL
2836           || htab->srelplt == NULL)
2837         abort ();
2838
2839       /* Get the index in the procedure linkage table which
2840          corresponds to this symbol.  This is the index of this symbol
2841          in all the symbols for which we are making plt entries.  The
2842          first entry in the procedure linkage table is reserved.  */
2843       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2844
2845       /* Get the offset into the .got table of the entry that
2846          corresponds to this function.  Each .got entry is 4 bytes.
2847          The first three are reserved.  */
2848       got_offset = (plt_index + 3) * 4;
2849
2850       /* Fill in the entry in the procedure linkage table.  */
2851       if (! info->shared)
2852         {
2853           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
2854                   PLT_ENTRY_SIZE);
2855           bfd_put_32 (output_bfd,
2856                       (htab->sgotplt->output_section->vma
2857                        + htab->sgotplt->output_offset
2858                        + got_offset),
2859                       htab->splt->contents + h->plt.offset + 2);
2860         }
2861       else
2862         {
2863           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
2864                   PLT_ENTRY_SIZE);
2865           bfd_put_32 (output_bfd, got_offset,
2866                       htab->splt->contents + h->plt.offset + 2);
2867         }
2868
2869       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
2870                   htab->splt->contents + h->plt.offset + 7);
2871       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2872                   htab->splt->contents + h->plt.offset + 12);
2873
2874       /* Fill in the entry in the global offset table.  */
2875       bfd_put_32 (output_bfd,
2876                   (htab->splt->output_section->vma
2877                    + htab->splt->output_offset
2878                    + h->plt.offset
2879                    + 6),
2880                   htab->sgotplt->contents + got_offset);
2881
2882       /* Fill in the entry in the .rel.plt section.  */
2883       rel.r_offset = (htab->sgotplt->output_section->vma
2884                       + htab->sgotplt->output_offset
2885                       + got_offset);
2886       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
2887       loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2888       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2889
2890       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2891         {
2892           /* Mark the symbol as undefined, rather than as defined in
2893              the .plt section.  Leave the value alone.  This is a clue
2894              for the dynamic linker, to make function pointer
2895              comparisons work between an application and shared
2896              library.  */
2897           sym->st_shndx = SHN_UNDEF;
2898         }
2899     }
2900
2901   if (h->got.offset != (bfd_vma) -1
2902       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
2903       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_IE)
2904     {
2905       Elf_Internal_Rel rel;
2906       Elf32_External_Rel *loc;
2907
2908       /* This symbol has an entry in the global offset table.  Set it
2909          up.  */
2910
2911       if (htab->sgot == NULL || htab->srelgot == NULL)
2912         abort ();
2913
2914       rel.r_offset = (htab->sgot->output_section->vma
2915                       + htab->sgot->output_offset
2916                       + (h->got.offset & ~(bfd_vma) 1));
2917
2918       /* If this is a static link, or it is a -Bsymbolic link and the
2919          symbol is defined locally or was forced to be local because
2920          of a version file, we just want to emit a RELATIVE reloc.
2921          The entry in the global offset table will already have been
2922          initialized in the relocate_section function.  */
2923       if (info->shared
2924           && (info->symbolic
2925               || h->dynindx == -1
2926               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2927           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2928         {
2929           BFD_ASSERT((h->got.offset & 1) != 0);
2930           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2931         }
2932       else
2933         {
2934           BFD_ASSERT((h->got.offset & 1) == 0);
2935           bfd_put_32 (output_bfd, (bfd_vma) 0,
2936                       htab->sgot->contents + h->got.offset);
2937           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2938         }
2939
2940       loc = (Elf32_External_Rel *) htab->srelgot->contents;
2941       loc += htab->srelgot->reloc_count++;
2942       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2943     }
2944
2945   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2946     {
2947       Elf_Internal_Rel rel;
2948       Elf32_External_Rel *loc;
2949
2950       /* This symbol needs a copy reloc.  Set it up.  */
2951
2952       if (h->dynindx == -1
2953           || (h->root.type != bfd_link_hash_defined
2954               && h->root.type != bfd_link_hash_defweak)
2955           || htab->srelbss == NULL)
2956         abort ();
2957
2958       rel.r_offset = (h->root.u.def.value
2959                       + h->root.u.def.section->output_section->vma
2960                       + h->root.u.def.section->output_offset);
2961       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2962       loc = (Elf32_External_Rel *) htab->srelbss->contents;
2963       loc += htab->srelbss->reloc_count++;
2964       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2965     }
2966
2967   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2968   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2969       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2970     sym->st_shndx = SHN_ABS;
2971
2972   return true;
2973 }
2974
2975 /* Used to decide how to sort relocs in an optimal manner for the
2976    dynamic linker, before writing them out.  */
2977
2978 static enum elf_reloc_type_class
2979 elf_i386_reloc_type_class (rela)
2980      const Elf_Internal_Rela *rela;
2981 {
2982   switch ((int) ELF32_R_TYPE (rela->r_info))
2983     {
2984     case R_386_RELATIVE:
2985       return reloc_class_relative;
2986     case R_386_JUMP_SLOT:
2987       return reloc_class_plt;
2988     case R_386_COPY:
2989       return reloc_class_copy;
2990     default:
2991       return reloc_class_normal;
2992     }
2993 }
2994
2995 /* Finish up the dynamic sections.  */
2996
2997 static boolean
2998 elf_i386_finish_dynamic_sections (output_bfd, info)
2999      bfd *output_bfd;
3000      struct bfd_link_info *info;
3001 {
3002   struct elf_i386_link_hash_table *htab;
3003   bfd *dynobj;
3004   asection *sdyn;
3005
3006   htab = elf_i386_hash_table (info);
3007   dynobj = htab->elf.dynobj;
3008   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3009
3010   if (htab->elf.dynamic_sections_created)
3011     {
3012       Elf32_External_Dyn *dyncon, *dynconend;
3013
3014       if (sdyn == NULL || htab->sgot == NULL)
3015         abort ();
3016
3017       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3018       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3019       for (; dyncon < dynconend; dyncon++)
3020         {
3021           Elf_Internal_Dyn dyn;
3022           asection *s;
3023
3024           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3025
3026           switch (dyn.d_tag)
3027             {
3028             default:
3029               continue;
3030
3031             case DT_PLTGOT:
3032               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3033               break;
3034
3035             case DT_JMPREL:
3036               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3037               break;
3038
3039             case DT_PLTRELSZ:
3040               s = htab->srelplt->output_section;
3041               if (s->_cooked_size != 0)
3042                 dyn.d_un.d_val = s->_cooked_size;
3043               else
3044                 dyn.d_un.d_val = s->_raw_size;
3045               break;
3046
3047             case DT_RELSZ:
3048               /* My reading of the SVR4 ABI indicates that the
3049                  procedure linkage table relocs (DT_JMPREL) should be
3050                  included in the overall relocs (DT_REL).  This is
3051                  what Solaris does.  However, UnixWare can not handle
3052                  that case.  Therefore, we override the DT_RELSZ entry
3053                  here to make it not include the JMPREL relocs.  Since
3054                  the linker script arranges for .rel.plt to follow all
3055                  other relocation sections, we don't have to worry
3056                  about changing the DT_REL entry.  */
3057               if (htab->srelplt != NULL)
3058                 {
3059                   s = htab->srelplt->output_section;
3060                   if (s->_cooked_size != 0)
3061                     dyn.d_un.d_val -= s->_cooked_size;
3062                   else
3063                     dyn.d_un.d_val -= s->_raw_size;
3064                 }
3065               break;
3066             }
3067
3068           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3069         }
3070
3071       /* Fill in the first entry in the procedure linkage table.  */
3072       if (htab->splt && htab->splt->_raw_size > 0)
3073         {
3074           if (info->shared)
3075             memcpy (htab->splt->contents,
3076                     elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
3077           else
3078             {
3079               memcpy (htab->splt->contents,
3080                       elf_i386_plt0_entry, PLT_ENTRY_SIZE);
3081               bfd_put_32 (output_bfd,
3082                           (htab->sgotplt->output_section->vma
3083                            + htab->sgotplt->output_offset
3084                            + 4),
3085                           htab->splt->contents + 2);
3086               bfd_put_32 (output_bfd,
3087                           (htab->sgotplt->output_section->vma
3088                            + htab->sgotplt->output_offset
3089                            + 8),
3090                           htab->splt->contents + 8);
3091             }
3092
3093           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3094              really seem like the right value.  */
3095           elf_section_data (htab->splt->output_section)
3096             ->this_hdr.sh_entsize = 4;
3097         }
3098     }
3099
3100   if (htab->sgotplt)
3101     {
3102       /* Fill in the first three entries in the global offset table.  */
3103       if (htab->sgotplt->_raw_size > 0)
3104         {
3105           bfd_put_32 (output_bfd,
3106                       (sdyn == NULL ? (bfd_vma) 0
3107                        : sdyn->output_section->vma + sdyn->output_offset),
3108                       htab->sgotplt->contents);
3109           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3110           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3111         }
3112
3113       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3114     }
3115   return true;
3116 }
3117
3118 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3119 #define TARGET_LITTLE_NAME              "elf32-i386"
3120 #define ELF_ARCH                        bfd_arch_i386
3121 #define ELF_MACHINE_CODE                EM_386
3122 #define ELF_MAXPAGESIZE                 0x1000
3123
3124 #define elf_backend_can_gc_sections     1
3125 #define elf_backend_can_refcount        1
3126 #define elf_backend_want_got_plt        1
3127 #define elf_backend_plt_readonly        1
3128 #define elf_backend_want_plt_sym        0
3129 #define elf_backend_got_header_size     12
3130 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3131
3132 #define elf_info_to_howto                     elf_i386_info_to_howto
3133 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3134
3135 #define bfd_elf32_mkobject                    elf_i386_mkobject
3136 #define elf_backend_object_p                  elf_i386_object_p
3137
3138 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3139 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3140 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3141
3142 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3143 #define elf_backend_check_relocs              elf_i386_check_relocs
3144 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3145 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3146 #define elf_backend_fake_sections             elf_i386_fake_sections
3147 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3148 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3149 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3150 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3151 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3152 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3153 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3154 #define elf_backend_relocate_section          elf_i386_relocate_section
3155 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3156
3157 #ifndef ELF32_I386_C_INCLUDED
3158 #include "elf32-target.h"
3159 #endif