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