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