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 (! CONST_STRNEQ (name, ".rel")
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,
1283                        Elf_Internal_Rela *rel,
1284                        struct elf_link_hash_entry *h,
1285                        Elf_Internal_Sym *sym)
1286 {
1287   if (h != NULL)
1288     switch (ELF32_R_TYPE (rel->r_info))
1289       {
1290       case R_386_GNU_VTINHERIT:
1291       case R_386_GNU_VTENTRY:
1292         return NULL;
1293       }
1294
1295   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1296 }
1297
1298 /* Update the got entry reference counts for the section being removed.  */
1299
1300 static bfd_boolean
1301 elf_i386_gc_sweep_hook (bfd *abfd,
1302                         struct bfd_link_info *info,
1303                         asection *sec,
1304                         const Elf_Internal_Rela *relocs)
1305 {
1306   Elf_Internal_Shdr *symtab_hdr;
1307   struct elf_link_hash_entry **sym_hashes;
1308   bfd_signed_vma *local_got_refcounts;
1309   const Elf_Internal_Rela *rel, *relend;
1310
1311   elf_section_data (sec)->local_dynrel = NULL;
1312
1313   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1314   sym_hashes = elf_sym_hashes (abfd);
1315   local_got_refcounts = elf_local_got_refcounts (abfd);
1316
1317   relend = relocs + sec->reloc_count;
1318   for (rel = relocs; rel < relend; rel++)
1319     {
1320       unsigned long r_symndx;
1321       unsigned int r_type;
1322       struct elf_link_hash_entry *h = NULL;
1323
1324       r_symndx = ELF32_R_SYM (rel->r_info);
1325       if (r_symndx >= symtab_hdr->sh_info)
1326         {
1327           struct elf_i386_link_hash_entry *eh;
1328           struct elf_i386_dyn_relocs **pp;
1329           struct elf_i386_dyn_relocs *p;
1330
1331           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1332           while (h->root.type == bfd_link_hash_indirect
1333                  || h->root.type == bfd_link_hash_warning)
1334             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1335           eh = (struct elf_i386_link_hash_entry *) h;
1336
1337           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1338             if (p->sec == sec)
1339               {
1340                 /* Everything must go for SEC.  */
1341                 *pp = p->next;
1342                 break;
1343               }
1344         }
1345
1346       r_type = ELF32_R_TYPE (rel->r_info);
1347       r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1348       switch (r_type)
1349         {
1350         case R_386_TLS_LDM:
1351           if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1352             elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1353           break;
1354
1355         case R_386_TLS_GD:
1356         case R_386_TLS_GOTDESC:
1357         case R_386_TLS_DESC_CALL:
1358         case R_386_TLS_IE_32:
1359         case R_386_TLS_IE:
1360         case R_386_TLS_GOTIE:
1361         case R_386_GOT32:
1362           if (h != NULL)
1363             {
1364               if (h->got.refcount > 0)
1365                 h->got.refcount -= 1;
1366             }
1367           else if (local_got_refcounts != NULL)
1368             {
1369               if (local_got_refcounts[r_symndx] > 0)
1370                 local_got_refcounts[r_symndx] -= 1;
1371             }
1372           break;
1373
1374         case R_386_32:
1375         case R_386_PC32:
1376           if (info->shared)
1377             break;
1378           /* Fall through */
1379
1380         case R_386_PLT32:
1381           if (h != NULL)
1382             {
1383               if (h->plt.refcount > 0)
1384                 h->plt.refcount -= 1;
1385             }
1386           break;
1387
1388         default:
1389           break;
1390         }
1391     }
1392
1393   return TRUE;
1394 }
1395
1396 /* Adjust a symbol defined by a dynamic object and referenced by a
1397    regular object.  The current definition is in some section of the
1398    dynamic object, but we're not including those sections.  We have to
1399    change the definition to something the rest of the link can
1400    understand.  */
1401
1402 static bfd_boolean
1403 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1404                                 struct elf_link_hash_entry *h)
1405 {
1406   struct elf_i386_link_hash_table *htab;
1407   asection *s;
1408   unsigned int power_of_two;
1409
1410   /* If this is a function, put it in the procedure linkage table.  We
1411      will fill in the contents of the procedure linkage table later,
1412      when we know the address of the .got section.  */
1413   if (h->type == STT_FUNC
1414       || h->needs_plt)
1415     {
1416       if (h->plt.refcount <= 0
1417           || SYMBOL_CALLS_LOCAL (info, h)
1418           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1419               && h->root.type == bfd_link_hash_undefweak))
1420         {
1421           /* This case can occur if we saw a PLT32 reloc in an input
1422              file, but the symbol was never referred to by a dynamic
1423              object, or if all references were garbage collected.  In
1424              such a case, we don't actually need to build a procedure
1425              linkage table, and we can just do a PC32 reloc instead.  */
1426           h->plt.offset = (bfd_vma) -1;
1427           h->needs_plt = 0;
1428         }
1429
1430       return TRUE;
1431     }
1432   else
1433     /* It's possible that we incorrectly decided a .plt reloc was
1434        needed for an R_386_PC32 reloc to a non-function sym in
1435        check_relocs.  We can't decide accurately between function and
1436        non-function syms in check-relocs;  Objects loaded later in
1437        the link may change h->type.  So fix it now.  */
1438     h->plt.offset = (bfd_vma) -1;
1439
1440   /* If this is a weak symbol, and there is a real definition, the
1441      processor independent code will have arranged for us to see the
1442      real definition first, and we can just use the same value.  */
1443   if (h->u.weakdef != NULL)
1444     {
1445       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1446                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1447       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1448       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1449       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1450         h->non_got_ref = h->u.weakdef->non_got_ref;
1451       return TRUE;
1452     }
1453
1454   /* This is a reference to a symbol defined by a dynamic object which
1455      is not a function.  */
1456
1457   /* If we are creating a shared library, we must presume that the
1458      only references to the symbol are via the global offset table.
1459      For such cases we need not do anything here; the relocations will
1460      be handled correctly by relocate_section.  */
1461   if (info->shared)
1462     return TRUE;
1463
1464   /* If there are no references to this symbol that do not use the
1465      GOT, we don't need to generate a copy reloc.  */
1466   if (!h->non_got_ref)
1467     return TRUE;
1468
1469   /* If -z nocopyreloc was given, we won't generate them either.  */
1470   if (info->nocopyreloc)
1471     {
1472       h->non_got_ref = 0;
1473       return TRUE;
1474     }
1475
1476   htab = elf_i386_hash_table (info);
1477
1478   /* If there aren't any dynamic relocs in read-only sections, then
1479      we can keep the dynamic relocs and avoid the copy reloc.  This
1480      doesn't work on VxWorks, where we can not have dynamic relocations
1481      (other than copy and jump slot relocations) in an executable.  */
1482   if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
1483     {
1484       struct elf_i386_link_hash_entry * eh;
1485       struct elf_i386_dyn_relocs *p;
1486
1487       eh = (struct elf_i386_link_hash_entry *) h;
1488       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1489         {
1490           s = p->sec->output_section;
1491           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1492             break;
1493         }
1494
1495       if (p == NULL)
1496         {
1497           h->non_got_ref = 0;
1498           return TRUE;
1499         }
1500     }
1501
1502   if (h->size == 0)
1503     {
1504       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1505                              h->root.root.string);
1506       return TRUE;
1507     }
1508
1509   /* We must allocate the symbol in our .dynbss section, which will
1510      become part of the .bss section of the executable.  There will be
1511      an entry for this symbol in the .dynsym section.  The dynamic
1512      object will contain position independent code, so all references
1513      from the dynamic object to this symbol will go through the global
1514      offset table.  The dynamic linker will use the .dynsym entry to
1515      determine the address it must put in the global offset table, so
1516      both the dynamic object and the regular object will refer to the
1517      same memory location for the variable.  */
1518
1519   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1520      copy the initial value out of the dynamic object and into the
1521      runtime process image.  */
1522   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1523     {
1524       htab->srelbss->size += sizeof (Elf32_External_Rel);
1525       h->needs_copy = 1;
1526     }
1527
1528   /* We need to figure out the alignment required for this symbol.  I
1529      have no idea how ELF linkers handle this.  */
1530   power_of_two = bfd_log2 (h->size);
1531   if (power_of_two > 3)
1532     power_of_two = 3;
1533
1534   /* Apply the required alignment.  */
1535   s = htab->sdynbss;
1536   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1537   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1538     {
1539       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1540         return FALSE;
1541     }
1542
1543   /* Define the symbol as being at this point in the section.  */
1544   h->root.u.def.section = s;
1545   h->root.u.def.value = s->size;
1546
1547   /* Increment the section size to make room for the symbol.  */
1548   s->size += h->size;
1549
1550   return TRUE;
1551 }
1552
1553 /* Allocate space in .plt, .got and associated reloc sections for
1554    dynamic relocs.  */
1555
1556 static bfd_boolean
1557 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1558 {
1559   struct bfd_link_info *info;
1560   struct elf_i386_link_hash_table *htab;
1561   struct elf_i386_link_hash_entry *eh;
1562   struct elf_i386_dyn_relocs *p;
1563
1564   if (h->root.type == bfd_link_hash_indirect)
1565     return TRUE;
1566
1567   if (h->root.type == bfd_link_hash_warning)
1568     /* When warning symbols are created, they **replace** the "real"
1569        entry in the hash table, thus we never get to see the real
1570        symbol in a hash traversal.  So look at it now.  */
1571     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1572
1573   info = (struct bfd_link_info *) inf;
1574   htab = elf_i386_hash_table (info);
1575
1576   if (htab->elf.dynamic_sections_created
1577       && h->plt.refcount > 0)
1578     {
1579       /* Make sure this symbol is output as a dynamic symbol.
1580          Undefined weak syms won't yet be marked as dynamic.  */
1581       if (h->dynindx == -1
1582           && !h->forced_local)
1583         {
1584           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1585             return FALSE;
1586         }
1587
1588       if (info->shared
1589           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1590         {
1591           asection *s = htab->splt;
1592
1593           /* If this is the first .plt entry, make room for the special
1594              first entry.  */
1595           if (s->size == 0)
1596             s->size += PLT_ENTRY_SIZE;
1597
1598           h->plt.offset = s->size;
1599
1600           /* If this symbol is not defined in a regular file, and we are
1601              not generating a shared library, then set the symbol to this
1602              location in the .plt.  This is required to make function
1603              pointers compare as equal between the normal executable and
1604              the shared library.  */
1605           if (! info->shared
1606               && !h->def_regular)
1607             {
1608               h->root.u.def.section = s;
1609               h->root.u.def.value = h->plt.offset;
1610             }
1611
1612           /* Make room for this entry.  */
1613           s->size += PLT_ENTRY_SIZE;
1614
1615           /* We also need to make an entry in the .got.plt section, which
1616              will be placed in the .got section by the linker script.  */
1617           htab->sgotplt->size += 4;
1618
1619           /* We also need to make an entry in the .rel.plt section.  */
1620           htab->srelplt->size += sizeof (Elf32_External_Rel);
1621           htab->next_tls_desc_index++;
1622
1623           if (htab->is_vxworks && !info->shared)
1624             {
1625               /* VxWorks has a second set of relocations for each PLT entry
1626                  in executables.  They go in a separate relocation section,
1627                  which is processed by the kernel loader.  */
1628
1629               /* There are two relocations for the initial PLT entry: an
1630                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1631                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
1632
1633               if (h->plt.offset == PLT_ENTRY_SIZE)
1634                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1635
1636               /* There are two extra relocations for each subsequent PLT entry:
1637                  an R_386_32 relocation for the GOT entry, and an R_386_32
1638                  relocation for the PLT entry.  */
1639
1640               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1641             }
1642         }
1643       else
1644         {
1645           h->plt.offset = (bfd_vma) -1;
1646           h->needs_plt = 0;
1647         }
1648     }
1649   else
1650     {
1651       h->plt.offset = (bfd_vma) -1;
1652       h->needs_plt = 0;
1653     }
1654
1655   eh = (struct elf_i386_link_hash_entry *) h;
1656   eh->tlsdesc_got = (bfd_vma) -1;
1657
1658   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1659      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
1660   if (h->got.refcount > 0
1661       && !info->shared
1662       && h->dynindx == -1
1663       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1664     h->got.offset = (bfd_vma) -1;
1665   else if (h->got.refcount > 0)
1666     {
1667       asection *s;
1668       bfd_boolean dyn;
1669       int tls_type = elf_i386_hash_entry(h)->tls_type;
1670
1671       /* Make sure this symbol is output as a dynamic symbol.
1672          Undefined weak syms won't yet be marked as dynamic.  */
1673       if (h->dynindx == -1
1674           && !h->forced_local)
1675         {
1676           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1677             return FALSE;
1678         }
1679
1680       s = htab->sgot;
1681       if (GOT_TLS_GDESC_P (tls_type))
1682         {
1683           eh->tlsdesc_got = htab->sgotplt->size
1684             - elf_i386_compute_jump_table_size (htab);
1685           htab->sgotplt->size += 8;
1686           h->got.offset = (bfd_vma) -2;
1687         }
1688       if (! GOT_TLS_GDESC_P (tls_type)
1689           || GOT_TLS_GD_P (tls_type))
1690         {
1691           h->got.offset = s->size;
1692           s->size += 4;
1693           /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
1694           if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
1695             s->size += 4;
1696         }
1697       dyn = htab->elf.dynamic_sections_created;
1698       /* R_386_TLS_IE_32 needs one dynamic relocation,
1699          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1700          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1701          need two), R_386_TLS_GD needs one if local symbol and two if
1702          global.  */
1703       if (tls_type == GOT_TLS_IE_BOTH)
1704         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1705       else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1706                || (tls_type & GOT_TLS_IE))
1707         htab->srelgot->size += sizeof (Elf32_External_Rel);
1708       else if (GOT_TLS_GD_P (tls_type))
1709         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1710       else if (! GOT_TLS_GDESC_P (tls_type)
1711                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1712                    || h->root.type != bfd_link_hash_undefweak)
1713                && (info->shared
1714                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1715         htab->srelgot->size += sizeof (Elf32_External_Rel);
1716       if (GOT_TLS_GDESC_P (tls_type))
1717         htab->srelplt->size += sizeof (Elf32_External_Rel);
1718     }
1719   else
1720     h->got.offset = (bfd_vma) -1;
1721
1722   if (eh->dyn_relocs == NULL)
1723     return TRUE;
1724
1725   /* In the shared -Bsymbolic case, discard space allocated for
1726      dynamic pc-relative relocs against symbols which turn out to be
1727      defined in regular objects.  For the normal shared case, discard
1728      space for pc-relative relocs that have become local due to symbol
1729      visibility changes.  */
1730
1731   if (info->shared)
1732     {
1733       /* The only reloc that uses pc_count is R_386_PC32, which will
1734          appear on a call or on something like ".long foo - .".  We
1735          want calls to protected symbols to resolve directly to the
1736          function rather than going via the plt.  If people want
1737          function pointer comparisons to work as expected then they
1738          should avoid writing assembly like ".long foo - .".  */
1739       if (SYMBOL_CALLS_LOCAL (info, h))
1740         {
1741           struct elf_i386_dyn_relocs **pp;
1742
1743           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1744             {
1745               p->count -= p->pc_count;
1746               p->pc_count = 0;
1747               if (p->count == 0)
1748                 *pp = p->next;
1749               else
1750                 pp = &p->next;
1751             }
1752         }
1753
1754       /* Also discard relocs on undefined weak syms with non-default
1755          visibility.  */
1756       if (eh->dyn_relocs != NULL
1757           && h->root.type == bfd_link_hash_undefweak)
1758         {
1759           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1760             eh->dyn_relocs = NULL;
1761
1762           /* Make sure undefined weak symbols are output as a dynamic
1763              symbol in PIEs.  */
1764           else if (h->dynindx == -1
1765                    && !h->forced_local)
1766             {
1767               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1768                 return FALSE;
1769             }
1770         }
1771     }
1772   else if (ELIMINATE_COPY_RELOCS)
1773     {
1774       /* For the non-shared case, discard space for relocs against
1775          symbols which turn out to need copy relocs or are not
1776          dynamic.  */
1777
1778       if (!h->non_got_ref
1779           && ((h->def_dynamic
1780                && !h->def_regular)
1781               || (htab->elf.dynamic_sections_created
1782                   && (h->root.type == bfd_link_hash_undefweak
1783                       || h->root.type == bfd_link_hash_undefined))))
1784         {
1785           /* Make sure this symbol is output as a dynamic symbol.
1786              Undefined weak syms won't yet be marked as dynamic.  */
1787           if (h->dynindx == -1
1788               && !h->forced_local)
1789             {
1790               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1791                 return FALSE;
1792             }
1793
1794           /* If that succeeded, we know we'll be keeping all the
1795              relocs.  */
1796           if (h->dynindx != -1)
1797             goto keep;
1798         }
1799
1800       eh->dyn_relocs = NULL;
1801
1802     keep: ;
1803     }
1804
1805   /* Finally, allocate space.  */
1806   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1807     {
1808       asection *sreloc = elf_section_data (p->sec)->sreloc;
1809       sreloc->size += p->count * sizeof (Elf32_External_Rel);
1810     }
1811
1812   return TRUE;
1813 }
1814
1815 /* Find any dynamic relocs that apply to read-only sections.  */
1816
1817 static bfd_boolean
1818 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1819 {
1820   struct elf_i386_link_hash_entry *eh;
1821   struct elf_i386_dyn_relocs *p;
1822
1823   if (h->root.type == bfd_link_hash_warning)
1824     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1825
1826   eh = (struct elf_i386_link_hash_entry *) h;
1827   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1828     {
1829       asection *s = p->sec->output_section;
1830
1831       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1832         {
1833           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1834
1835           info->flags |= DF_TEXTREL;
1836
1837           /* Not an error, just cut short the traversal.  */
1838           return FALSE;
1839         }
1840     }
1841   return TRUE;
1842 }
1843
1844 /* Set the sizes of the dynamic sections.  */
1845
1846 static bfd_boolean
1847 elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1848                                 struct bfd_link_info *info)
1849 {
1850   struct elf_i386_link_hash_table *htab;
1851   bfd *dynobj;
1852   asection *s;
1853   bfd_boolean relocs;
1854   bfd *ibfd;
1855
1856   htab = elf_i386_hash_table (info);
1857   dynobj = htab->elf.dynobj;
1858   if (dynobj == NULL)
1859     abort ();
1860
1861   if (htab->elf.dynamic_sections_created)
1862     {
1863       /* Set the contents of the .interp section to the interpreter.  */
1864       if (info->executable)
1865         {
1866           s = bfd_get_section_by_name (dynobj, ".interp");
1867           if (s == NULL)
1868             abort ();
1869           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1870           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1871         }
1872     }
1873
1874   /* Set up .got offsets for local syms, and space for local dynamic
1875      relocs.  */
1876   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1877     {
1878       bfd_signed_vma *local_got;
1879       bfd_signed_vma *end_local_got;
1880       char *local_tls_type;
1881       bfd_vma *local_tlsdesc_gotent;
1882       bfd_size_type locsymcount;
1883       Elf_Internal_Shdr *symtab_hdr;
1884       asection *srel;
1885
1886       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1887         continue;
1888
1889       for (s = ibfd->sections; s != NULL; s = s->next)
1890         {
1891           struct elf_i386_dyn_relocs *p;
1892
1893           for (p = ((struct elf_i386_dyn_relocs *)
1894                      elf_section_data (s)->local_dynrel);
1895                p != NULL;
1896                p = p->next)
1897             {
1898               if (!bfd_is_abs_section (p->sec)
1899                   && bfd_is_abs_section (p->sec->output_section))
1900                 {
1901                   /* Input section has been discarded, either because
1902                      it is a copy of a linkonce section or due to
1903                      linker script /DISCARD/, so we'll be discarding
1904                      the relocs too.  */
1905                 }
1906               else if (p->count != 0)
1907                 {
1908                   srel = elf_section_data (p->sec)->sreloc;
1909                   srel->size += p->count * sizeof (Elf32_External_Rel);
1910                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1911                     info->flags |= DF_TEXTREL;
1912                 }
1913             }
1914         }
1915
1916       local_got = elf_local_got_refcounts (ibfd);
1917       if (!local_got)
1918         continue;
1919
1920       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1921       locsymcount = symtab_hdr->sh_info;
1922       end_local_got = local_got + locsymcount;
1923       local_tls_type = elf_i386_local_got_tls_type (ibfd);
1924       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
1925       s = htab->sgot;
1926       srel = htab->srelgot;
1927       for (; local_got < end_local_got;
1928            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1929         {
1930           *local_tlsdesc_gotent = (bfd_vma) -1;
1931           if (*local_got > 0)
1932             {
1933               if (GOT_TLS_GDESC_P (*local_tls_type))
1934                 {
1935                   *local_tlsdesc_gotent = htab->sgotplt->size
1936                     - elf_i386_compute_jump_table_size (htab);
1937                   htab->sgotplt->size += 8;
1938                   *local_got = (bfd_vma) -2;
1939                 }
1940               if (! GOT_TLS_GDESC_P (*local_tls_type)
1941                   || GOT_TLS_GD_P (*local_tls_type))
1942                 {
1943                   *local_got = s->size;
1944                   s->size += 4;
1945                   if (GOT_TLS_GD_P (*local_tls_type)
1946                       || *local_tls_type == GOT_TLS_IE_BOTH)
1947                     s->size += 4;
1948                 }
1949               if (info->shared
1950                   || GOT_TLS_GD_ANY_P (*local_tls_type)
1951                   || (*local_tls_type & GOT_TLS_IE))
1952                 {
1953                   if (*local_tls_type == GOT_TLS_IE_BOTH)
1954                     srel->size += 2 * sizeof (Elf32_External_Rel);
1955                   else if (GOT_TLS_GD_P (*local_tls_type)
1956                            || ! GOT_TLS_GDESC_P (*local_tls_type))
1957                     srel->size += sizeof (Elf32_External_Rel);
1958                   if (GOT_TLS_GDESC_P (*local_tls_type))
1959                     htab->srelplt->size += sizeof (Elf32_External_Rel);
1960                 }
1961             }
1962           else
1963             *local_got = (bfd_vma) -1;
1964         }
1965     }
1966
1967   if (htab->tls_ldm_got.refcount > 0)
1968     {
1969       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1970          relocs.  */
1971       htab->tls_ldm_got.offset = htab->sgot->size;
1972       htab->sgot->size += 8;
1973       htab->srelgot->size += sizeof (Elf32_External_Rel);
1974     }
1975   else
1976     htab->tls_ldm_got.offset = -1;
1977
1978   /* Allocate global sym .plt and .got entries, and space for global
1979      sym dynamic relocs.  */
1980   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1981
1982   /* For every jump slot reserved in the sgotplt, reloc_count is
1983      incremented.  However, when we reserve space for TLS descriptors,
1984      it's not incremented, so in order to compute the space reserved
1985      for them, it suffices to multiply the reloc count by the jump
1986      slot size.  */
1987   if (htab->srelplt)
1988     htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
1989
1990   /* We now have determined the sizes of the various dynamic sections.
1991      Allocate memory for them.  */
1992   relocs = FALSE;
1993   for (s = dynobj->sections; s != NULL; s = s->next)
1994     {
1995       bfd_boolean strip_section = TRUE;
1996
1997       if ((s->flags & SEC_LINKER_CREATED) == 0)
1998         continue;
1999
2000       if (s == htab->splt
2001           || s == htab->sgot
2002           || s == htab->sgotplt
2003           || s == htab->sdynbss)
2004         {
2005           /* Strip this section if we don't need it; see the
2006              comment below.  */
2007           /* We'd like to strip these sections if they aren't needed, but if
2008              we've exported dynamic symbols from them we must leave them.
2009              It's too late to tell BFD to get rid of the symbols.  */
2010
2011           if (htab->elf.hplt != NULL)
2012             strip_section = FALSE;
2013         }
2014       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2015         {
2016           if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
2017             relocs = TRUE;
2018
2019           /* We use the reloc_count field as a counter if we need
2020              to copy relocs into the output file.  */
2021           s->reloc_count = 0;
2022         }
2023       else
2024         {
2025           /* It's not one of our sections, so don't allocate space.  */
2026           continue;
2027         }
2028
2029       if (s->size == 0)
2030         {
2031           /* If we don't need this section, strip it from the
2032              output file.  This is mostly to handle .rel.bss and
2033              .rel.plt.  We must create both sections in
2034              create_dynamic_sections, because they must be created
2035              before the linker maps input sections to output
2036              sections.  The linker does that before
2037              adjust_dynamic_symbol is called, and it is that
2038              function which decides whether anything needs to go
2039              into these sections.  */
2040           if (strip_section)
2041             s->flags |= SEC_EXCLUDE;
2042           continue;
2043         }
2044
2045       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2046         continue;
2047
2048       /* Allocate memory for the section contents.  We use bfd_zalloc
2049          here in case unused entries are not reclaimed before the
2050          section's contents are written out.  This should not happen,
2051          but this way if it does, we get a R_386_NONE reloc instead
2052          of garbage.  */
2053       s->contents = bfd_zalloc (dynobj, s->size);
2054       if (s->contents == NULL)
2055         return FALSE;
2056     }
2057
2058   if (htab->elf.dynamic_sections_created)
2059     {
2060       /* Add some entries to the .dynamic section.  We fill in the
2061          values later, in elf_i386_finish_dynamic_sections, but we
2062          must add the entries now so that we get the correct size for
2063          the .dynamic section.  The DT_DEBUG entry is filled in by the
2064          dynamic linker and used by the debugger.  */
2065 #define add_dynamic_entry(TAG, VAL) \
2066   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2067
2068       if (info->executable)
2069         {
2070           if (!add_dynamic_entry (DT_DEBUG, 0))
2071             return FALSE;
2072         }
2073
2074       if (htab->splt->size != 0)
2075         {
2076           if (!add_dynamic_entry (DT_PLTGOT, 0)
2077               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2078               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2079               || !add_dynamic_entry (DT_JMPREL, 0))
2080             return FALSE;
2081         }
2082
2083       if (relocs)
2084         {
2085           if (!add_dynamic_entry (DT_REL, 0)
2086               || !add_dynamic_entry (DT_RELSZ, 0)
2087               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2088             return FALSE;
2089
2090           /* If any dynamic relocs apply to a read-only section,
2091              then we need a DT_TEXTREL entry.  */
2092           if ((info->flags & DF_TEXTREL) == 0)
2093             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2094                                     (PTR) info);
2095
2096           if ((info->flags & DF_TEXTREL) != 0)
2097             {
2098               if (!add_dynamic_entry (DT_TEXTREL, 0))
2099                 return FALSE;
2100             }
2101         }
2102     }
2103 #undef add_dynamic_entry
2104
2105   return TRUE;
2106 }
2107
2108 static bfd_boolean
2109 elf_i386_always_size_sections (bfd *output_bfd,
2110                                struct bfd_link_info *info)
2111 {
2112   asection *tls_sec = elf_hash_table (info)->tls_sec;
2113
2114   if (tls_sec)
2115     {
2116       struct elf_link_hash_entry *tlsbase;
2117
2118       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2119                                       "_TLS_MODULE_BASE_",
2120                                       FALSE, FALSE, FALSE);
2121
2122       if (tlsbase && tlsbase->type == STT_TLS)
2123         {
2124           struct bfd_link_hash_entry *bh = NULL;
2125           const struct elf_backend_data *bed
2126             = get_elf_backend_data (output_bfd);
2127
2128           if (!(_bfd_generic_link_add_one_symbol
2129                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2130                  tls_sec, 0, NULL, FALSE,
2131                  bed->collect, &bh)))
2132             return FALSE;
2133           tlsbase = (struct elf_link_hash_entry *)bh;
2134           tlsbase->def_regular = 1;
2135           tlsbase->other = STV_HIDDEN;
2136           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2137         }
2138     }
2139
2140   return TRUE;
2141 }
2142
2143 /* Set the correct type for an x86 ELF section.  We do this by the
2144    section name, which is a hack, but ought to work.  */
2145
2146 static bfd_boolean
2147 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2148                         Elf_Internal_Shdr *hdr,
2149                         asection *sec)
2150 {
2151   register const char *name;
2152
2153   name = bfd_get_section_name (abfd, sec);
2154
2155   /* This is an ugly, but unfortunately necessary hack that is
2156      needed when producing EFI binaries on x86. It tells
2157      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2158      containing ELF relocation info.  We need this hack in order to
2159      be able to generate ELF binaries that can be translated into
2160      EFI applications (which are essentially COFF objects).  Those
2161      files contain a COFF ".reloc" section inside an ELFNN object,
2162      which would normally cause BFD to segfault because it would
2163      attempt to interpret this section as containing relocation
2164      entries for section "oc".  With this hack enabled, ".reloc"
2165      will be treated as a normal data section, which will avoid the
2166      segfault.  However, you won't be able to create an ELFNN binary
2167      with a section named "oc" that needs relocations, but that's
2168      the kind of ugly side-effects you get when detecting section
2169      types based on their names...  In practice, this limitation is
2170      unlikely to bite.  */
2171   if (strcmp (name, ".reloc") == 0)
2172     hdr->sh_type = SHT_PROGBITS;
2173
2174   return TRUE;
2175 }
2176
2177 /* Return the base VMA address which should be subtracted from real addresses
2178    when resolving @dtpoff relocation.
2179    This is PT_TLS segment p_vaddr.  */
2180
2181 static bfd_vma
2182 dtpoff_base (struct bfd_link_info *info)
2183 {
2184   /* If tls_sec is NULL, we should have signalled an error already.  */
2185   if (elf_hash_table (info)->tls_sec == NULL)
2186     return 0;
2187   return elf_hash_table (info)->tls_sec->vma;
2188 }
2189
2190 /* Return the relocation value for @tpoff relocation
2191    if STT_TLS virtual address is ADDRESS.  */
2192
2193 static bfd_vma
2194 tpoff (struct bfd_link_info *info, bfd_vma address)
2195 {
2196   struct elf_link_hash_table *htab = elf_hash_table (info);
2197
2198   /* If tls_sec is NULL, we should have signalled an error already.  */
2199   if (htab->tls_sec == NULL)
2200     return 0;
2201   return htab->tls_size + htab->tls_sec->vma - address;
2202 }
2203
2204 /* Relocate an i386 ELF section.  */
2205
2206 static bfd_boolean
2207 elf_i386_relocate_section (bfd *output_bfd,
2208                            struct bfd_link_info *info,
2209                            bfd *input_bfd,
2210                            asection *input_section,
2211                            bfd_byte *contents,
2212                            Elf_Internal_Rela *relocs,
2213                            Elf_Internal_Sym *local_syms,
2214                            asection **local_sections)
2215 {
2216   struct elf_i386_link_hash_table *htab;
2217   Elf_Internal_Shdr *symtab_hdr;
2218   struct elf_link_hash_entry **sym_hashes;
2219   bfd_vma *local_got_offsets;
2220   bfd_vma *local_tlsdesc_gotents;
2221   Elf_Internal_Rela *rel;
2222   Elf_Internal_Rela *relend;
2223
2224   htab = elf_i386_hash_table (info);
2225   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2226   sym_hashes = elf_sym_hashes (input_bfd);
2227   local_got_offsets = elf_local_got_offsets (input_bfd);
2228   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
2229
2230   rel = relocs;
2231   relend = relocs + input_section->reloc_count;
2232   for (; rel < relend; rel++)
2233     {
2234       unsigned int r_type;
2235       reloc_howto_type *howto;
2236       unsigned long r_symndx;
2237       struct elf_link_hash_entry *h;
2238       Elf_Internal_Sym *sym;
2239       asection *sec;
2240       bfd_vma off, offplt;
2241       bfd_vma relocation;
2242       bfd_boolean unresolved_reloc;
2243       bfd_reloc_status_type r;
2244       unsigned int indx;
2245       int tls_type;
2246
2247       r_type = ELF32_R_TYPE (rel->r_info);
2248       if (r_type == R_386_GNU_VTINHERIT
2249           || r_type == R_386_GNU_VTENTRY)
2250         continue;
2251
2252       if ((indx = r_type) >= R_386_standard
2253           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2254               >= R_386_ext - R_386_standard)
2255           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2256               >= R_386_tls - R_386_ext))
2257         {
2258           (*_bfd_error_handler)
2259             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2260              input_bfd, input_section, r_type);
2261           bfd_set_error (bfd_error_bad_value);
2262           return FALSE;
2263         }
2264       howto = elf_howto_table + indx;
2265
2266       r_symndx = ELF32_R_SYM (rel->r_info);
2267
2268       if (info->relocatable)
2269         {
2270           bfd_vma val;
2271           bfd_byte *where;
2272
2273           /* This is a relocatable link.  We don't have to change
2274              anything, unless the reloc is against a section symbol,
2275              in which case we have to adjust according to where the
2276              section symbol winds up in the output section.  */
2277           if (r_symndx >= symtab_hdr->sh_info)
2278             continue;
2279
2280           sym = local_syms + r_symndx;
2281           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2282             continue;
2283
2284           sec = local_sections[r_symndx];
2285           val = sec->output_offset;
2286           if (val == 0)
2287             continue;
2288
2289           where = contents + rel->r_offset;
2290           switch (howto->size)
2291             {
2292               /* FIXME: overflow checks.  */
2293             case 0:
2294               val += bfd_get_8 (input_bfd, where);
2295               bfd_put_8 (input_bfd, val, where);
2296               break;
2297             case 1:
2298               val += bfd_get_16 (input_bfd, where);
2299               bfd_put_16 (input_bfd, val, where);
2300               break;
2301             case 2:
2302               val += bfd_get_32 (input_bfd, where);
2303               bfd_put_32 (input_bfd, val, where);
2304               break;
2305             default:
2306               abort ();
2307             }
2308           continue;
2309         }
2310
2311       /* This is a final link.  */
2312       h = NULL;
2313       sym = NULL;
2314       sec = NULL;
2315       unresolved_reloc = FALSE;
2316       if (r_symndx < symtab_hdr->sh_info)
2317         {
2318           sym = local_syms + r_symndx;
2319           sec = local_sections[r_symndx];
2320           relocation = (sec->output_section->vma
2321                         + sec->output_offset
2322                         + sym->st_value);
2323           if ((sec->flags & SEC_MERGE)
2324               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2325             {
2326               asection *msec;
2327               bfd_vma addend;
2328               bfd_byte *where = contents + rel->r_offset;
2329
2330               switch (howto->size)
2331                 {
2332                 case 0:
2333                   addend = bfd_get_8 (input_bfd, where);
2334                   if (howto->pc_relative)
2335                     {
2336                       addend = (addend ^ 0x80) - 0x80;
2337                       addend += 1;
2338                     }
2339                   break;
2340                 case 1:
2341                   addend = bfd_get_16 (input_bfd, where);
2342                   if (howto->pc_relative)
2343                     {
2344                       addend = (addend ^ 0x8000) - 0x8000;
2345                       addend += 2;
2346                     }
2347                   break;
2348                 case 2:
2349                   addend = bfd_get_32 (input_bfd, where);
2350                   if (howto->pc_relative)
2351                     {
2352                       addend = (addend ^ 0x80000000) - 0x80000000;
2353                       addend += 4;
2354                     }
2355                   break;
2356                 default:
2357                   abort ();
2358                 }
2359
2360               msec = sec;
2361               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2362               addend -= relocation;
2363               addend += msec->output_section->vma + msec->output_offset;
2364
2365               switch (howto->size)
2366                 {
2367                 case 0:
2368                   /* FIXME: overflow checks.  */
2369                   if (howto->pc_relative)
2370                     addend -= 1;
2371                   bfd_put_8 (input_bfd, addend, where);
2372                   break;
2373                 case 1:
2374                   if (howto->pc_relative)
2375                     addend -= 2;
2376                   bfd_put_16 (input_bfd, addend, where);
2377                   break;
2378                 case 2:
2379                   if (howto->pc_relative)
2380                     addend -= 4;
2381                   bfd_put_32 (input_bfd, addend, where);
2382                   break;
2383                 }
2384             }
2385         }
2386       else
2387         {
2388           bfd_boolean warned;
2389
2390           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2391                                    r_symndx, symtab_hdr, sym_hashes,
2392                                    h, sec, relocation,
2393                                    unresolved_reloc, warned);
2394         }
2395
2396       if (r_symndx == 0)
2397         {
2398         /* r_symndx will be zero only for relocs against symbols from
2399            removed linkonce sections, or sections discarded by a linker
2400            script.  For these relocs, we just want the section contents
2401            zeroed.  Avoid any special processing in the switch below.  */
2402           r_type = R_386_NONE;
2403
2404           relocation = 0;
2405           if (howto->pc_relative)
2406             relocation = (input_section->output_section->vma
2407                           + input_section->output_offset
2408                           + rel->r_offset);
2409         }
2410
2411       switch (r_type)
2412         {
2413         case R_386_GOT32:
2414           /* Relocation is to the entry for this symbol in the global
2415              offset table.  */
2416           if (htab->sgot == NULL)
2417             abort ();
2418
2419           if (h != NULL)
2420             {
2421               bfd_boolean dyn;
2422
2423               off = h->got.offset;
2424               dyn = htab->elf.dynamic_sections_created;
2425               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2426                   || (info->shared
2427                       && SYMBOL_REFERENCES_LOCAL (info, h))
2428                   || (ELF_ST_VISIBILITY (h->other)
2429                       && h->root.type == bfd_link_hash_undefweak))
2430                 {
2431                   /* This is actually a static link, or it is a
2432                      -Bsymbolic link and the symbol is defined
2433                      locally, or the symbol was forced to be local
2434                      because of a version file.  We must initialize
2435                      this entry in the global offset table.  Since the
2436                      offset must always be a multiple of 4, we use the
2437                      least significant bit to record whether we have
2438                      initialized it already.
2439
2440                      When doing a dynamic link, we create a .rel.got
2441                      relocation entry to initialize the value.  This
2442                      is done in the finish_dynamic_symbol routine.  */
2443                   if ((off & 1) != 0)
2444                     off &= ~1;
2445                   else
2446                     {
2447                       bfd_put_32 (output_bfd, relocation,
2448                                   htab->sgot->contents + off);
2449                       h->got.offset |= 1;
2450                     }
2451                 }
2452               else
2453                 unresolved_reloc = FALSE;
2454             }
2455           else
2456             {
2457               if (local_got_offsets == NULL)
2458                 abort ();
2459
2460               off = local_got_offsets[r_symndx];
2461
2462               /* The offset must always be a multiple of 4.  We use
2463                  the least significant bit to record whether we have
2464                  already generated the necessary reloc.  */
2465               if ((off & 1) != 0)
2466                 off &= ~1;
2467               else
2468                 {
2469                   bfd_put_32 (output_bfd, relocation,
2470                               htab->sgot->contents + off);
2471
2472                   if (info->shared)
2473                     {
2474                       asection *s;
2475                       Elf_Internal_Rela outrel;
2476                       bfd_byte *loc;
2477
2478                       s = htab->srelgot;
2479                       if (s == NULL)
2480                         abort ();
2481
2482                       outrel.r_offset = (htab->sgot->output_section->vma
2483                                          + htab->sgot->output_offset
2484                                          + off);
2485                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2486                       loc = s->contents;
2487                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2488                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2489                     }
2490
2491                   local_got_offsets[r_symndx] |= 1;
2492                 }
2493             }
2494
2495           if (off >= (bfd_vma) -2)
2496             abort ();
2497
2498           relocation = htab->sgot->output_section->vma
2499                        + htab->sgot->output_offset + off
2500                        - htab->sgotplt->output_section->vma
2501                        - htab->sgotplt->output_offset;
2502           break;
2503
2504         case R_386_GOTOFF:
2505           /* Relocation is relative to the start of the global offset
2506              table.  */
2507
2508           /* Check to make sure it isn't a protected function symbol
2509              for shared library since it may not be local when used
2510              as function address.  */
2511           if (info->shared
2512               && !info->executable
2513               && h
2514               && h->def_regular
2515               && h->type == STT_FUNC
2516               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2517             {
2518               (*_bfd_error_handler)
2519                 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2520                  input_bfd, h->root.root.string);
2521               bfd_set_error (bfd_error_bad_value);
2522               return FALSE;
2523             }
2524
2525           /* Note that sgot is not involved in this
2526              calculation.  We always want the start of .got.plt.  If we
2527              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2528              permitted by the ABI, we might have to change this
2529              calculation.  */
2530           relocation -= htab->sgotplt->output_section->vma
2531                         + htab->sgotplt->output_offset;
2532           break;
2533
2534         case R_386_GOTPC:
2535           /* Use global offset table as symbol value.  */
2536           relocation = htab->sgotplt->output_section->vma
2537                        + htab->sgotplt->output_offset;
2538           unresolved_reloc = FALSE;
2539           break;
2540
2541         case R_386_PLT32:
2542           /* Relocation is to the entry for this symbol in the
2543              procedure linkage table.  */
2544
2545           /* Resolve a PLT32 reloc against a local symbol directly,
2546              without using the procedure linkage table.  */
2547           if (h == NULL)
2548             break;
2549
2550           if (h->plt.offset == (bfd_vma) -1
2551               || htab->splt == NULL)
2552             {
2553               /* We didn't make a PLT entry for this symbol.  This
2554                  happens when statically linking PIC code, or when
2555                  using -Bsymbolic.  */
2556               break;
2557             }
2558
2559           relocation = (htab->splt->output_section->vma
2560                         + htab->splt->output_offset
2561                         + h->plt.offset);
2562           unresolved_reloc = FALSE;
2563           break;
2564
2565         case R_386_32:
2566         case R_386_PC32:
2567           if ((input_section->flags & SEC_ALLOC) == 0)
2568             break;
2569
2570           if ((info->shared
2571                && (h == NULL
2572                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2573                    || h->root.type != bfd_link_hash_undefweak)
2574                && (r_type != R_386_PC32
2575                    || !SYMBOL_CALLS_LOCAL (info, h)))
2576               || (ELIMINATE_COPY_RELOCS
2577                   && !info->shared
2578                   && h != NULL
2579                   && h->dynindx != -1
2580                   && !h->non_got_ref
2581                   && ((h->def_dynamic
2582                        && !h->def_regular)
2583                       || h->root.type == bfd_link_hash_undefweak
2584                       || h->root.type == bfd_link_hash_undefined)))
2585             {
2586               Elf_Internal_Rela outrel;
2587               bfd_byte *loc;
2588               bfd_boolean skip, relocate;
2589               asection *sreloc;
2590
2591               /* When generating a shared object, these relocations
2592                  are copied into the output file to be resolved at run
2593                  time.  */
2594
2595               skip = FALSE;
2596               relocate = FALSE;
2597
2598               outrel.r_offset =
2599                 _bfd_elf_section_offset (output_bfd, info, input_section,
2600                                          rel->r_offset);
2601               if (outrel.r_offset == (bfd_vma) -1)
2602                 skip = TRUE;
2603               else if (outrel.r_offset == (bfd_vma) -2)
2604                 skip = TRUE, relocate = TRUE;
2605               outrel.r_offset += (input_section->output_section->vma
2606                                   + input_section->output_offset);
2607
2608               if (skip)
2609                 memset (&outrel, 0, sizeof outrel);
2610               else if (h != NULL
2611                        && h->dynindx != -1
2612                        && (r_type == R_386_PC32
2613                            || !info->shared
2614                            || !SYMBOLIC_BIND (info, h)
2615                            || !h->def_regular))
2616                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2617               else
2618                 {
2619                   /* This symbol is local, or marked to become local.  */
2620                   relocate = TRUE;
2621                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2622                 }
2623
2624               sreloc = elf_section_data (input_section)->sreloc;
2625               if (sreloc == NULL)
2626                 abort ();
2627
2628               loc = sreloc->contents;
2629               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2630               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2631
2632               /* If this reloc is against an external symbol, we do
2633                  not want to fiddle with the addend.  Otherwise, we
2634                  need to include the symbol value so that it becomes
2635                  an addend for the dynamic reloc.  */
2636               if (! relocate)
2637                 continue;
2638             }
2639           break;
2640
2641         case R_386_TLS_IE:
2642           if (info->shared)
2643             {
2644               Elf_Internal_Rela outrel;
2645               bfd_byte *loc;
2646               asection *sreloc;
2647
2648               outrel.r_offset = rel->r_offset
2649                                 + input_section->output_section->vma
2650                                 + input_section->output_offset;
2651               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2652               sreloc = elf_section_data (input_section)->sreloc;
2653               if (sreloc == NULL)
2654                 abort ();
2655               loc = sreloc->contents;
2656               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2657               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2658             }
2659           /* Fall through */
2660
2661         case R_386_TLS_GD:
2662         case R_386_TLS_GOTDESC:
2663         case R_386_TLS_DESC_CALL:
2664         case R_386_TLS_IE_32:
2665         case R_386_TLS_GOTIE:
2666           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2667           tls_type = GOT_UNKNOWN;
2668           if (h == NULL && local_got_offsets)
2669             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2670           else if (h != NULL)
2671             {
2672               tls_type = elf_i386_hash_entry(h)->tls_type;
2673               if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2674                 r_type = R_386_TLS_LE_32;
2675             }
2676           if (tls_type == GOT_TLS_IE)
2677             tls_type = GOT_TLS_IE_NEG;
2678           if (r_type == R_386_TLS_GD
2679               || r_type == R_386_TLS_GOTDESC
2680               || r_type == R_386_TLS_DESC_CALL)
2681             {
2682               if (tls_type == GOT_TLS_IE_POS)
2683                 r_type = R_386_TLS_GOTIE;
2684               else if (tls_type & GOT_TLS_IE)
2685                 r_type = R_386_TLS_IE_32;
2686             }
2687
2688           if (r_type == R_386_TLS_LE_32)
2689             {
2690               BFD_ASSERT (! unresolved_reloc);
2691               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2692                 {
2693                   unsigned int val, type;
2694                   bfd_vma roff;
2695
2696                   /* GD->LE transition.  */
2697                   BFD_ASSERT (rel->r_offset >= 2);
2698                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2699                   BFD_ASSERT (type == 0x8d || type == 0x04);
2700                   BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2701                   BFD_ASSERT (bfd_get_8 (input_bfd,
2702                                          contents + rel->r_offset + 4)
2703                               == 0xe8);
2704                   BFD_ASSERT (rel + 1 < relend);
2705                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2706                   roff = rel->r_offset + 5;
2707                   val = bfd_get_8 (input_bfd,
2708                                    contents + rel->r_offset - 1);
2709                   if (type == 0x04)
2710                     {
2711                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2712                          Change it into:
2713                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2714                          (6 byte form of subl).  */
2715                       BFD_ASSERT (rel->r_offset >= 3);
2716                       BFD_ASSERT (bfd_get_8 (input_bfd,
2717                                              contents + rel->r_offset - 3)
2718                                   == 0x8d);
2719                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2720                       memcpy (contents + rel->r_offset - 3,
2721                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2722                     }
2723                   else
2724                     {
2725                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2726                       if (rel->r_offset + 10 <= input_section->size
2727                           && bfd_get_8 (input_bfd,
2728                                         contents + rel->r_offset + 9) == 0x90)
2729                         {
2730                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2731                              Change it into:
2732                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2733                              (6 byte form of subl).  */
2734                           memcpy (contents + rel->r_offset - 2,
2735                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2736                           roff = rel->r_offset + 6;
2737                         }
2738                       else
2739                         {
2740                           /* leal foo(%reg), %eax; call ___tls_get_addr
2741                              Change it into:
2742                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2743                              (5 byte form of subl).  */
2744                           memcpy (contents + rel->r_offset - 2,
2745                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2746                         }
2747                     }
2748                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2749                               contents + roff);
2750                   /* Skip R_386_PLT32.  */
2751                   rel++;
2752                   continue;
2753                 }
2754               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
2755                 {
2756                   /* GDesc -> LE transition.
2757                      It's originally something like:
2758                      leal x@tlsdesc(%ebx), %eax
2759
2760                      leal x@ntpoff, %eax
2761
2762                      Registers other than %eax may be set up here.  */
2763
2764                   unsigned int val, type;
2765                   bfd_vma roff;
2766
2767                   /* First, make sure it's a leal adding ebx to a
2768                      32-bit offset into any register, although it's
2769                      probably almost always going to be eax.  */
2770                   roff = rel->r_offset;
2771                   BFD_ASSERT (roff >= 2);
2772                   type = bfd_get_8 (input_bfd, contents + roff - 2);
2773                   BFD_ASSERT (type == 0x8d);
2774                   val = bfd_get_8 (input_bfd, contents + roff - 1);
2775                   BFD_ASSERT ((val & 0xc7) == 0x83);
2776                   BFD_ASSERT (roff + 4 <= input_section->size);
2777
2778                   /* Now modify the instruction as appropriate.  */
2779                   /* aoliva FIXME: remove the above and xor the byte
2780                      below with 0x86.  */
2781                   bfd_put_8 (output_bfd, val ^ 0x86,
2782                              contents + roff - 1);
2783                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2784                               contents + roff);
2785                   continue;
2786                 }
2787               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
2788                 {
2789                   /* GDesc -> LE transition.
2790                      It's originally:
2791                      call *(%eax)
2792                      Turn it into:
2793                      nop; nop  */
2794
2795                   unsigned int val, type;
2796                   bfd_vma roff;
2797
2798                   /* First, make sure it's a call *(%eax).  */
2799                   roff = rel->r_offset;
2800                   BFD_ASSERT (roff + 2 <= input_section->size);
2801                   type = bfd_get_8 (input_bfd, contents + roff);
2802                   BFD_ASSERT (type == 0xff);
2803                   val = bfd_get_8 (input_bfd, contents + roff + 1);
2804                   BFD_ASSERT (val == 0x10);
2805
2806                   /* Now modify the instruction as appropriate.  Use
2807                      xchg %ax,%ax instead of 2 nops.  */
2808                   bfd_put_8 (output_bfd, 0x66, contents + roff);
2809                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2810                   continue;
2811                 }
2812               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2813                 {
2814                   unsigned int val, type;
2815
2816                   /* IE->LE transition:
2817                      Originally it can be one of:
2818                      movl foo, %eax
2819                      movl foo, %reg
2820                      addl foo, %reg
2821                      We change it into:
2822                      movl $foo, %eax
2823                      movl $foo, %reg
2824                      addl $foo, %reg.  */
2825                   BFD_ASSERT (rel->r_offset >= 1);
2826                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2827                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2828                   if (val == 0xa1)
2829                     {
2830                       /* movl foo, %eax.  */
2831                       bfd_put_8 (output_bfd, 0xb8,
2832                                  contents + rel->r_offset - 1);
2833                     }
2834                   else
2835                     {
2836                       BFD_ASSERT (rel->r_offset >= 2);
2837                       type = bfd_get_8 (input_bfd,
2838                                         contents + rel->r_offset - 2);
2839                       switch (type)
2840                         {
2841                         case 0x8b:
2842                           /* movl */
2843                           BFD_ASSERT ((val & 0xc7) == 0x05);
2844                           bfd_put_8 (output_bfd, 0xc7,
2845                                      contents + rel->r_offset - 2);
2846                           bfd_put_8 (output_bfd,
2847                                      0xc0 | ((val >> 3) & 7),
2848                                      contents + rel->r_offset - 1);
2849                           break;
2850                         case 0x03:
2851                           /* addl */
2852                           BFD_ASSERT ((val & 0xc7) == 0x05);
2853                           bfd_put_8 (output_bfd, 0x81,
2854                                      contents + rel->r_offset - 2);
2855                           bfd_put_8 (output_bfd,
2856                                      0xc0 | ((val >> 3) & 7),
2857                                      contents + rel->r_offset - 1);
2858                           break;
2859                         default:
2860                           BFD_FAIL ();
2861                           break;
2862                         }
2863                     }
2864                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2865                               contents + rel->r_offset);
2866                   continue;
2867                 }
2868               else
2869                 {
2870                   unsigned int val, type;
2871
2872                   /* {IE_32,GOTIE}->LE transition:
2873                      Originally it can be one of:
2874                      subl foo(%reg1), %reg2
2875                      movl foo(%reg1), %reg2
2876                      addl foo(%reg1), %reg2
2877                      We change it into:
2878                      subl $foo, %reg2
2879                      movl $foo, %reg2 (6 byte form)
2880                      addl $foo, %reg2.  */
2881                   BFD_ASSERT (rel->r_offset >= 2);
2882                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2883                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2884                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2885                   BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2886                   if (type == 0x8b)
2887                     {
2888                       /* movl */
2889                       bfd_put_8 (output_bfd, 0xc7,
2890                                  contents + rel->r_offset - 2);
2891                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2892                                  contents + rel->r_offset - 1);
2893                     }
2894                   else if (type == 0x2b)
2895                     {
2896                       /* subl */
2897                       bfd_put_8 (output_bfd, 0x81,
2898                                  contents + rel->r_offset - 2);
2899                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2900                                  contents + rel->r_offset - 1);
2901                     }
2902                   else if (type == 0x03)
2903                     {
2904                       /* addl */
2905                       bfd_put_8 (output_bfd, 0x81,
2906                                  contents + rel->r_offset - 2);
2907                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2908                                  contents + rel->r_offset - 1);
2909                     }
2910                   else
2911                     BFD_FAIL ();
2912                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2913                     bfd_put_32 (output_bfd, -tpoff (info, relocation),
2914                                 contents + rel->r_offset);
2915                   else
2916                     bfd_put_32 (output_bfd, tpoff (info, relocation),
2917                                 contents + rel->r_offset);
2918                   continue;
2919                 }
2920             }
2921
2922           if (htab->sgot == NULL)
2923             abort ();
2924
2925           if (h != NULL)
2926             {
2927               off = h->got.offset;
2928               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
2929             }
2930           else
2931             {
2932               if (local_got_offsets == NULL)
2933                 abort ();
2934
2935               off = local_got_offsets[r_symndx];
2936               offplt = local_tlsdesc_gotents[r_symndx];
2937             }
2938
2939           if ((off & 1) != 0)
2940             off &= ~1;
2941           else
2942             {
2943               Elf_Internal_Rela outrel;
2944               bfd_byte *loc;
2945               int dr_type, indx;
2946               asection *sreloc;
2947
2948               if (htab->srelgot == NULL)
2949                 abort ();
2950
2951               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2952
2953               if (GOT_TLS_GDESC_P (tls_type))
2954                 {
2955                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
2956                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
2957                               <= htab->sgotplt->size);
2958                   outrel.r_offset = (htab->sgotplt->output_section->vma
2959                                      + htab->sgotplt->output_offset
2960                                      + offplt
2961                                      + htab->sgotplt_jump_table_size);
2962                   sreloc = htab->srelplt;
2963                   loc = sreloc->contents;
2964                   loc += (htab->next_tls_desc_index++
2965                           * sizeof (Elf32_External_Rel));
2966                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
2967                               <= sreloc->contents + sreloc->size);
2968                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2969                   if (indx == 0)
2970                     {
2971                       BFD_ASSERT (! unresolved_reloc);
2972                       bfd_put_32 (output_bfd,
2973                                   relocation - dtpoff_base (info),
2974                                   htab->sgotplt->contents + offplt
2975                                   + htab->sgotplt_jump_table_size + 4);
2976                     }
2977                   else
2978                     {
2979                       bfd_put_32 (output_bfd, 0,
2980                                   htab->sgotplt->contents + offplt
2981                                   + htab->sgotplt_jump_table_size + 4);
2982                     }
2983                 }
2984
2985               sreloc = htab->srelgot;
2986
2987               outrel.r_offset = (htab->sgot->output_section->vma
2988                                  + htab->sgot->output_offset + off);
2989
2990               if (GOT_TLS_GD_P (tls_type))
2991                 dr_type = R_386_TLS_DTPMOD32;
2992               else if (GOT_TLS_GDESC_P (tls_type))
2993                 goto dr_done;
2994               else if (tls_type == GOT_TLS_IE_POS)
2995                 dr_type = R_386_TLS_TPOFF;
2996               else
2997                 dr_type = R_386_TLS_TPOFF32;
2998
2999               if (dr_type == R_386_TLS_TPOFF && indx == 0)
3000                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3001                             htab->sgot->contents + off);
3002               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
3003                 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
3004                             htab->sgot->contents + off);
3005               else if (dr_type != R_386_TLS_DESC)
3006                 bfd_put_32 (output_bfd, 0,
3007                             htab->sgot->contents + off);
3008               outrel.r_info = ELF32_R_INFO (indx, dr_type);
3009
3010               loc = sreloc->contents;
3011               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3012               BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3013                           <= sreloc->contents + sreloc->size);
3014               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3015
3016               if (GOT_TLS_GD_P (tls_type))
3017                 {
3018                   if (indx == 0)
3019                     {
3020                       BFD_ASSERT (! unresolved_reloc);
3021                       bfd_put_32 (output_bfd,
3022                                   relocation - dtpoff_base (info),
3023                                   htab->sgot->contents + off + 4);
3024                     }
3025                   else
3026                     {
3027                       bfd_put_32 (output_bfd, 0,
3028                                   htab->sgot->contents + off + 4);
3029                       outrel.r_info = ELF32_R_INFO (indx,
3030                                                     R_386_TLS_DTPOFF32);
3031                       outrel.r_offset += 4;
3032                       sreloc->reloc_count++;
3033                       loc += sizeof (Elf32_External_Rel);
3034                       BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3035                                   <= sreloc->contents + sreloc->size);
3036                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3037                     }
3038                 }
3039               else if (tls_type == GOT_TLS_IE_BOTH)
3040                 {
3041                   bfd_put_32 (output_bfd,
3042                               indx == 0 ? relocation - dtpoff_base (info) : 0,
3043                               htab->sgot->contents + off + 4);
3044                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3045                   outrel.r_offset += 4;
3046                   sreloc->reloc_count++;
3047                   loc += sizeof (Elf32_External_Rel);
3048                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3049                 }
3050
3051             dr_done:
3052               if (h != NULL)
3053                 h->got.offset |= 1;
3054               else
3055                 local_got_offsets[r_symndx] |= 1;
3056             }
3057
3058           if (off >= (bfd_vma) -2
3059               && ! GOT_TLS_GDESC_P (tls_type))
3060             abort ();
3061           if (r_type == R_386_TLS_GOTDESC
3062               || r_type == R_386_TLS_DESC_CALL)
3063             {
3064               relocation = htab->sgotplt_jump_table_size + offplt;
3065               unresolved_reloc = FALSE;
3066             }
3067           else if (r_type == ELF32_R_TYPE (rel->r_info))
3068             {
3069               bfd_vma g_o_t = htab->sgotplt->output_section->vma
3070                               + htab->sgotplt->output_offset;
3071               relocation = htab->sgot->output_section->vma
3072                 + htab->sgot->output_offset + off - g_o_t;
3073               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3074                   && tls_type == GOT_TLS_IE_BOTH)
3075                 relocation += 4;
3076               if (r_type == R_386_TLS_IE)
3077                 relocation += g_o_t;
3078               unresolved_reloc = FALSE;
3079             }
3080           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3081             {
3082               unsigned int val, type;
3083               bfd_vma roff;
3084
3085               /* GD->IE transition.  */
3086               BFD_ASSERT (rel->r_offset >= 2);
3087               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3088               BFD_ASSERT (type == 0x8d || type == 0x04);
3089               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
3090               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3091                           == 0xe8);
3092               BFD_ASSERT (rel + 1 < relend);
3093               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
3094               roff = rel->r_offset - 3;
3095               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3096               if (type == 0x04)
3097                 {
3098                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3099                      Change it into:
3100                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
3101                   BFD_ASSERT (rel->r_offset >= 3);
3102                   BFD_ASSERT (bfd_get_8 (input_bfd,
3103                                          contents + rel->r_offset - 3)
3104                               == 0x8d);
3105                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
3106                   val >>= 3;
3107                 }
3108               else
3109                 {
3110                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3111                      Change it into:
3112                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
3113                   BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
3114                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3115                   BFD_ASSERT (bfd_get_8 (input_bfd,
3116                                          contents + rel->r_offset + 9)
3117                               == 0x90);
3118                   roff = rel->r_offset - 2;
3119                 }
3120               memcpy (contents + roff,
3121                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3122               contents[roff + 7] = 0x80 | (val & 7);
3123               /* If foo is used only with foo@gotntpoff(%reg) and
3124                  foo@indntpoff, but not with foo@gottpoff(%reg), change
3125                  subl $foo@gottpoff(%reg), %eax
3126                  into:
3127                  addl $foo@gotntpoff(%reg), %eax.  */
3128               if (tls_type == GOT_TLS_IE_POS)
3129                 contents[roff + 6] = 0x03;
3130               bfd_put_32 (output_bfd,
3131                           htab->sgot->output_section->vma
3132                           + htab->sgot->output_offset + off
3133                           - htab->sgotplt->output_section->vma
3134                           - htab->sgotplt->output_offset,
3135                           contents + roff + 8);
3136               /* Skip R_386_PLT32.  */
3137               rel++;
3138               continue;
3139             }
3140           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3141             {
3142               /* GDesc -> IE transition.
3143                  It's originally something like:
3144                  leal x@tlsdesc(%ebx), %eax
3145
3146                  Change it to:
3147                  movl x@gotntpoff(%ebx), %eax # before nop; nop
3148                  or:
3149                  movl x@gottpoff(%ebx), %eax # before negl %eax
3150
3151                  Registers other than %eax may be set up here.  */
3152
3153               unsigned int val, type;
3154               bfd_vma roff;
3155
3156               /* First, make sure it's a leal adding ebx to a 32-bit
3157                  offset into any register, although it's probably
3158                  almost always going to be eax.  */
3159               roff = rel->r_offset;
3160               BFD_ASSERT (roff >= 2);
3161               type = bfd_get_8 (input_bfd, contents + roff - 2);
3162               BFD_ASSERT (type == 0x8d);
3163               val = bfd_get_8 (input_bfd, contents + roff - 1);
3164               BFD_ASSERT ((val & 0xc7) == 0x83);
3165               BFD_ASSERT (roff + 4 <= input_section->size);
3166
3167               /* Now modify the instruction as appropriate.  */
3168               /* To turn a leal into a movl in the form we use it, it
3169                  suffices to change the first byte from 0x8d to 0x8b.
3170                  aoliva FIXME: should we decide to keep the leal, all
3171                  we have to do is remove the statement below, and
3172                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
3173               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3174
3175               if (tls_type == GOT_TLS_IE_BOTH)
3176                 off += 4;
3177
3178               bfd_put_32 (output_bfd,
3179                           htab->sgot->output_section->vma
3180                           + htab->sgot->output_offset + off
3181                           - htab->sgotplt->output_section->vma
3182                           - htab->sgotplt->output_offset,
3183                           contents + roff);
3184               continue;
3185             }
3186           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3187             {
3188               /* GDesc -> IE transition.
3189                  It's originally:
3190                  call *(%eax)
3191
3192                  Change it to:
3193                  nop; nop
3194                  or
3195                  negl %eax
3196                  depending on how we transformed the TLS_GOTDESC above.
3197               */
3198
3199               unsigned int val, type;
3200               bfd_vma roff;
3201
3202               /* First, make sure it's a call *(%eax).  */
3203               roff = rel->r_offset;
3204               BFD_ASSERT (roff + 2 <= input_section->size);
3205               type = bfd_get_8 (input_bfd, contents + roff);
3206               BFD_ASSERT (type == 0xff);
3207               val = bfd_get_8 (input_bfd, contents + roff + 1);
3208               BFD_ASSERT (val == 0x10);
3209
3210               /* Now modify the instruction as appropriate.  */
3211               if (tls_type != GOT_TLS_IE_NEG)
3212                 {
3213                   /* xchg %ax,%ax */
3214                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3215                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3216                 }
3217               else
3218                 {
3219                   /* negl %eax */
3220                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
3221                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
3222                 }
3223
3224               continue;
3225             }
3226           else
3227             BFD_ASSERT (FALSE);
3228           break;
3229
3230         case R_386_TLS_LDM:
3231           if (! info->shared)
3232             {
3233               unsigned int val;
3234
3235               /* LD->LE transition:
3236                  Ensure it is:
3237                  leal foo(%reg), %eax; call ___tls_get_addr.
3238                  We change it into:
3239                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
3240               BFD_ASSERT (rel->r_offset >= 2);
3241               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
3242                           == 0x8d);
3243               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3244               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3245               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
3246               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3247                           == 0xe8);
3248               BFD_ASSERT (rel + 1 < relend);
3249               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
3250               memcpy (contents + rel->r_offset - 2,
3251                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3252               /* Skip R_386_PLT32.  */
3253               rel++;
3254               continue;
3255             }
3256
3257           if (htab->sgot == NULL)
3258             abort ();
3259
3260           off = htab->tls_ldm_got.offset;
3261           if (off & 1)
3262             off &= ~1;
3263           else
3264             {
3265               Elf_Internal_Rela outrel;
3266               bfd_byte *loc;
3267
3268               if (htab->srelgot == NULL)
3269                 abort ();
3270
3271               outrel.r_offset = (htab->sgot->output_section->vma
3272                                  + htab->sgot->output_offset + off);
3273
3274               bfd_put_32 (output_bfd, 0,
3275                           htab->sgot->contents + off);
3276               bfd_put_32 (output_bfd, 0,
3277                           htab->sgot->contents + off + 4);
3278               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
3279               loc = htab->srelgot->contents;
3280               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3281               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3282               htab->tls_ldm_got.offset |= 1;
3283             }
3284           relocation = htab->sgot->output_section->vma
3285                        + htab->sgot->output_offset + off
3286                        - htab->sgotplt->output_section->vma
3287                        - htab->sgotplt->output_offset;
3288           unresolved_reloc = FALSE;
3289           break;
3290
3291         case R_386_TLS_LDO_32:
3292           if (info->shared || (input_section->flags & SEC_CODE) == 0)
3293             relocation -= dtpoff_base (info);
3294           else
3295             /* When converting LDO to LE, we must negate.  */
3296             relocation = -tpoff (info, relocation);
3297           break;
3298
3299         case R_386_TLS_LE_32:
3300         case R_386_TLS_LE:
3301           if (info->shared)
3302             {
3303               Elf_Internal_Rela outrel;
3304               asection *sreloc;
3305               bfd_byte *loc;
3306               int indx;
3307
3308               outrel.r_offset = rel->r_offset
3309                                 + input_section->output_section->vma
3310                                 + input_section->output_offset;
3311               if (h != NULL && h->dynindx != -1)
3312                 indx = h->dynindx;
3313               else
3314                 indx = 0;
3315               if (r_type == R_386_TLS_LE_32)
3316                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3317               else
3318                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3319               sreloc = elf_section_data (input_section)->sreloc;
3320               if (sreloc == NULL)
3321                 abort ();
3322               loc = sreloc->contents;
3323               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3324               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3325               if (indx)
3326                 continue;
3327               else if (r_type == R_386_TLS_LE_32)
3328                 relocation = dtpoff_base (info) - relocation;
3329               else
3330                 relocation -= dtpoff_base (info);
3331             }
3332           else if (r_type == R_386_TLS_LE_32)
3333             relocation = tpoff (info, relocation);
3334           else
3335             relocation = -tpoff (info, relocation);
3336           break;
3337
3338         default:
3339           break;
3340         }
3341
3342       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3343          because such sections are not SEC_ALLOC and thus ld.so will
3344          not process them.  */
3345       if (unresolved_reloc
3346           && !((input_section->flags & SEC_DEBUGGING) != 0
3347                && h->def_dynamic))
3348         {
3349           (*_bfd_error_handler)
3350             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3351              input_bfd,
3352              input_section,
3353              (long) rel->r_offset,
3354              howto->name,
3355              h->root.root.string);
3356           return FALSE;
3357         }
3358
3359       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3360                                     contents, rel->r_offset,
3361                                     relocation, 0);
3362
3363       if (r != bfd_reloc_ok)
3364         {
3365           const char *name;
3366
3367           if (h != NULL)
3368             name = h->root.root.string;
3369           else
3370             {
3371               name = bfd_elf_string_from_elf_section (input_bfd,
3372                                                       symtab_hdr->sh_link,
3373                                                       sym->st_name);
3374               if (name == NULL)
3375                 return FALSE;
3376               if (*name == '\0')
3377                 name = bfd_section_name (input_bfd, sec);
3378             }
3379
3380           if (r == bfd_reloc_overflow)
3381             {
3382               if (! ((*info->callbacks->reloc_overflow)
3383                      (info, (h ? &h->root : NULL), name, howto->name,
3384                       (bfd_vma) 0, input_bfd, input_section,
3385                       rel->r_offset)))
3386                 return FALSE;
3387             }
3388           else
3389             {
3390               (*_bfd_error_handler)
3391                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3392                  input_bfd, input_section,
3393                  (long) rel->r_offset, name, (int) r);
3394               return FALSE;
3395             }
3396         }
3397     }
3398
3399   return TRUE;
3400 }
3401
3402 /* Finish up dynamic symbol handling.  We set the contents of various
3403    dynamic sections here.  */
3404
3405 static bfd_boolean
3406 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3407                                 struct bfd_link_info *info,
3408                                 struct elf_link_hash_entry *h,
3409                                 Elf_Internal_Sym *sym)
3410 {
3411   struct elf_i386_link_hash_table *htab;
3412
3413   htab = elf_i386_hash_table (info);
3414
3415   if (h->plt.offset != (bfd_vma) -1)
3416     {
3417       bfd_vma plt_index;
3418       bfd_vma got_offset;
3419       Elf_Internal_Rela rel;
3420       bfd_byte *loc;
3421
3422       /* This symbol has an entry in the procedure linkage table.  Set
3423          it up.  */
3424
3425       if (h->dynindx == -1
3426           || htab->splt == NULL
3427           || htab->sgotplt == NULL
3428           || htab->srelplt == NULL)
3429         abort ();
3430
3431       /* Get the index in the procedure linkage table which
3432          corresponds to this symbol.  This is the index of this symbol
3433          in all the symbols for which we are making plt entries.  The
3434          first entry in the procedure linkage table is reserved.  */
3435       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3436
3437       /* Get the offset into the .got table of the entry that
3438          corresponds to this function.  Each .got entry is 4 bytes.
3439          The first three are reserved.  */
3440       got_offset = (plt_index + 3) * 4;
3441
3442       /* Fill in the entry in the procedure linkage table.  */
3443       if (! info->shared)
3444         {
3445           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3446                   PLT_ENTRY_SIZE);
3447           bfd_put_32 (output_bfd,
3448                       (htab->sgotplt->output_section->vma
3449                        + htab->sgotplt->output_offset
3450                        + got_offset),
3451                       htab->splt->contents + h->plt.offset + 2);
3452
3453           if (htab->is_vxworks)
3454             {
3455               int s, k, reloc_index;
3456
3457               /* Create the R_386_32 relocation referencing the GOT
3458                  for this PLT entry.  */
3459
3460               /* S: Current slot number (zero-based).  */
3461               s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3462               /* K: Number of relocations for PLTResolve. */
3463               if (info->shared)
3464                 k = PLTRESOLVE_RELOCS_SHLIB;
3465               else
3466                 k = PLTRESOLVE_RELOCS;
3467               /* Skip the PLTresolve relocations, and the relocations for
3468                  the other PLT slots. */
3469               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3470               loc = (htab->srelplt2->contents + reloc_index
3471                      * sizeof (Elf32_External_Rel));
3472
3473               rel.r_offset = (htab->splt->output_section->vma
3474                               + htab->splt->output_offset
3475                               + h->plt.offset + 2),
3476               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3477               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3478
3479               /* Create the R_386_32 relocation referencing the beginning of
3480                  the PLT for this GOT entry.  */
3481               rel.r_offset = (htab->sgotplt->output_section->vma
3482                               + htab->sgotplt->output_offset
3483                               + got_offset);
3484               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3485               bfd_elf32_swap_reloc_out (output_bfd, &rel,
3486               loc + sizeof (Elf32_External_Rel));
3487             }
3488         }
3489       else
3490         {
3491           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3492                   PLT_ENTRY_SIZE);
3493           bfd_put_32 (output_bfd, got_offset,
3494                       htab->splt->contents + h->plt.offset + 2);
3495         }
3496
3497       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3498                   htab->splt->contents + h->plt.offset + 7);
3499       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3500                   htab->splt->contents + h->plt.offset + 12);
3501
3502       /* Fill in the entry in the global offset table.  */
3503       bfd_put_32 (output_bfd,
3504                   (htab->splt->output_section->vma
3505                    + htab->splt->output_offset
3506                    + h->plt.offset
3507                    + 6),
3508                   htab->sgotplt->contents + got_offset);
3509
3510       /* Fill in the entry in the .rel.plt section.  */
3511       rel.r_offset = (htab->sgotplt->output_section->vma
3512                       + htab->sgotplt->output_offset
3513                       + got_offset);
3514       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3515       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3516       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3517
3518       if (!h->def_regular)
3519         {
3520           /* Mark the symbol as undefined, rather than as defined in
3521              the .plt section.  Leave the value if there were any
3522              relocations where pointer equality matters (this is a clue
3523              for the dynamic linker, to make function pointer
3524              comparisons work between an application and shared
3525              library), otherwise set it to zero.  If a function is only
3526              called from a binary, there is no need to slow down
3527              shared libraries because of that.  */
3528           sym->st_shndx = SHN_UNDEF;
3529           if (!h->pointer_equality_needed)
3530             sym->st_value = 0;
3531         }
3532     }
3533
3534   if (h->got.offset != (bfd_vma) -1
3535       && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
3536       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3537     {
3538       Elf_Internal_Rela rel;
3539       bfd_byte *loc;
3540
3541       /* This symbol has an entry in the global offset table.  Set it
3542          up.  */
3543
3544       if (htab->sgot == NULL || htab->srelgot == NULL)
3545         abort ();
3546
3547       rel.r_offset = (htab->sgot->output_section->vma
3548                       + htab->sgot->output_offset
3549                       + (h->got.offset & ~(bfd_vma) 1));
3550
3551       /* If this is a static link, or it is a -Bsymbolic link and the
3552          symbol is defined locally or was forced to be local because
3553          of a version file, we just want to emit a RELATIVE reloc.
3554          The entry in the global offset table will already have been
3555          initialized in the relocate_section function.  */
3556       if (info->shared
3557           && SYMBOL_REFERENCES_LOCAL (info, h))
3558         {
3559           BFD_ASSERT((h->got.offset & 1) != 0);
3560           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3561         }
3562       else
3563         {
3564           BFD_ASSERT((h->got.offset & 1) == 0);
3565           bfd_put_32 (output_bfd, (bfd_vma) 0,
3566                       htab->sgot->contents + h->got.offset);
3567           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3568         }
3569
3570       loc = htab->srelgot->contents;
3571       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3572       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3573     }
3574
3575   if (h->needs_copy)
3576     {
3577       Elf_Internal_Rela rel;
3578       bfd_byte *loc;
3579
3580       /* This symbol needs a copy reloc.  Set it up.  */
3581
3582       if (h->dynindx == -1
3583           || (h->root.type != bfd_link_hash_defined
3584               && h->root.type != bfd_link_hash_defweak)
3585           || htab->srelbss == NULL)
3586         abort ();
3587
3588       rel.r_offset = (h->root.u.def.value
3589                       + h->root.u.def.section->output_section->vma
3590                       + h->root.u.def.section->output_offset);
3591       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3592       loc = htab->srelbss->contents;
3593       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3594       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3595     }
3596
3597   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3598      On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3599      is relative to the ".got" section.  */
3600   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3601       || (!htab->is_vxworks && h == htab->elf.hgot))
3602     sym->st_shndx = SHN_ABS;
3603
3604   return TRUE;
3605 }
3606
3607 /* Used to decide how to sort relocs in an optimal manner for the
3608    dynamic linker, before writing them out.  */
3609
3610 static enum elf_reloc_type_class
3611 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3612 {
3613   switch (ELF32_R_TYPE (rela->r_info))
3614     {
3615     case R_386_RELATIVE:
3616       return reloc_class_relative;
3617     case R_386_JUMP_SLOT:
3618       return reloc_class_plt;
3619     case R_386_COPY:
3620       return reloc_class_copy;
3621     default:
3622       return reloc_class_normal;
3623     }
3624 }
3625
3626 /* Finish up the dynamic sections.  */
3627
3628 static bfd_boolean
3629 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3630                                   struct bfd_link_info *info)
3631 {
3632   struct elf_i386_link_hash_table *htab;
3633   bfd *dynobj;
3634   asection *sdyn;
3635
3636   htab = elf_i386_hash_table (info);
3637   dynobj = htab->elf.dynobj;
3638   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3639
3640   if (htab->elf.dynamic_sections_created)
3641     {
3642       Elf32_External_Dyn *dyncon, *dynconend;
3643
3644       if (sdyn == NULL || htab->sgot == NULL)
3645         abort ();
3646
3647       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3648       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3649       for (; dyncon < dynconend; dyncon++)
3650         {
3651           Elf_Internal_Dyn dyn;
3652           asection *s;
3653
3654           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3655
3656           switch (dyn.d_tag)
3657             {
3658             default:
3659               continue;
3660
3661             case DT_PLTGOT:
3662               s = htab->sgotplt;
3663               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3664               break;
3665
3666             case DT_JMPREL:
3667               s = htab->srelplt;
3668               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3669               break;
3670
3671             case DT_PLTRELSZ:
3672               s = htab->srelplt;
3673               dyn.d_un.d_val = s->size;
3674               break;
3675
3676             case DT_RELSZ:
3677               /* My reading of the SVR4 ABI indicates that the
3678                  procedure linkage table relocs (DT_JMPREL) should be
3679                  included in the overall relocs (DT_REL).  This is
3680                  what Solaris does.  However, UnixWare can not handle
3681                  that case.  Therefore, we override the DT_RELSZ entry
3682                  here to make it not include the JMPREL relocs.  */
3683               s = htab->srelplt;
3684               if (s == NULL)
3685                 continue;
3686               dyn.d_un.d_val -= s->size;
3687               break;
3688
3689             case DT_REL:
3690               /* We may not be using the standard ELF linker script.
3691                  If .rel.plt is the first .rel section, we adjust
3692                  DT_REL to not include it.  */
3693               s = htab->srelplt;
3694               if (s == NULL)
3695                 continue;
3696               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3697                 continue;
3698               dyn.d_un.d_ptr += s->size;
3699               break;
3700             }
3701
3702           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3703         }
3704
3705       /* Fill in the first entry in the procedure linkage table.  */
3706       if (htab->splt && htab->splt->size > 0)
3707         {
3708           if (info->shared)
3709             {
3710               memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3711                       sizeof (elf_i386_pic_plt0_entry));
3712               memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3713                       htab->plt0_pad_byte,
3714                       PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3715             }
3716           else
3717             {
3718               memcpy (htab->splt->contents, elf_i386_plt0_entry,
3719                       sizeof(elf_i386_plt0_entry));
3720               memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3721                       htab->plt0_pad_byte,
3722                       PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
3723               bfd_put_32 (output_bfd,
3724                           (htab->sgotplt->output_section->vma
3725                            + htab->sgotplt->output_offset
3726                            + 4),
3727                           htab->splt->contents + 2);
3728               bfd_put_32 (output_bfd,
3729                           (htab->sgotplt->output_section->vma
3730                            + htab->sgotplt->output_offset
3731                            + 8),
3732                           htab->splt->contents + 8);
3733
3734               if (htab->is_vxworks)
3735                 {
3736                   Elf_Internal_Rela rel;
3737
3738                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3739                      On IA32 we use REL relocations so the addend goes in
3740                      the PLT directly.  */
3741                   rel.r_offset = (htab->splt->output_section->vma
3742                                   + htab->splt->output_offset
3743                                   + 2);
3744                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3745                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3746                                             htab->srelplt2->contents);
3747                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
3748                   rel.r_offset = (htab->splt->output_section->vma
3749                                   + htab->splt->output_offset
3750                                   + 8);
3751                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3752                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3753                                             htab->srelplt2->contents +
3754                                             sizeof (Elf32_External_Rel));
3755                 }
3756             }
3757
3758           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3759              really seem like the right value.  */
3760           elf_section_data (htab->splt->output_section)
3761             ->this_hdr.sh_entsize = 4;
3762
3763           /* Correct the .rel.plt.unloaded relocations.  */
3764           if (htab->is_vxworks && !info->shared)
3765             {
3766               int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
3767               unsigned char *p;
3768
3769               p = htab->srelplt2->contents;
3770               if (info->shared)
3771                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
3772               else
3773                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
3774
3775               for (; num_plts; num_plts--)
3776                 {
3777                   Elf_Internal_Rela rel;
3778                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3779                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3780                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3781                   p += sizeof (Elf32_External_Rel);
3782
3783                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3784                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3785                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3786                   p += sizeof (Elf32_External_Rel);
3787                 }
3788             }
3789         }
3790     }
3791
3792   if (htab->sgotplt)
3793     {
3794       /* Fill in the first three entries in the global offset table.  */
3795       if (htab->sgotplt->size > 0)
3796         {
3797           bfd_put_32 (output_bfd,
3798                       (sdyn == NULL ? 0
3799                        : sdyn->output_section->vma + sdyn->output_offset),
3800                       htab->sgotplt->contents);
3801           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3802           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3803         }
3804
3805       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3806     }
3807
3808   if (htab->sgot && htab->sgot->size > 0)
3809     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3810
3811   return TRUE;
3812 }
3813
3814 /* Return address for Ith PLT stub in section PLT, for relocation REL
3815    or (bfd_vma) -1 if it should not be included.  */
3816
3817 static bfd_vma
3818 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
3819                       const arelent *rel ATTRIBUTE_UNUSED)
3820 {
3821   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3822 }
3823
3824 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
3825
3826 static bfd_boolean
3827 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
3828 {
3829   if (h->plt.offset != (bfd_vma) -1
3830       && !h->def_regular
3831       && !h->pointer_equality_needed)
3832     return FALSE;
3833
3834   return _bfd_elf_hash_symbol (h);
3835 }
3836
3837 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3838 #define TARGET_LITTLE_NAME              "elf32-i386"
3839 #define ELF_ARCH                        bfd_arch_i386
3840 #define ELF_MACHINE_CODE                EM_386
3841 #define ELF_MAXPAGESIZE                 0x1000
3842
3843 #define elf_backend_can_gc_sections     1
3844 #define elf_backend_can_refcount        1
3845 #define elf_backend_want_got_plt        1
3846 #define elf_backend_plt_readonly        1
3847 #define elf_backend_want_plt_sym        0
3848 #define elf_backend_got_header_size     12
3849
3850 /* Support RELA for objdump of prelink objects.  */
3851 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3852 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3853
3854 #define bfd_elf32_mkobject                    elf_i386_mkobject
3855
3856 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3857 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3858 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3859
3860 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3861 #define elf_backend_check_relocs              elf_i386_check_relocs
3862 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3863 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3864 #define elf_backend_fake_sections             elf_i386_fake_sections
3865 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3866 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3867 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3868 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3869 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3870 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3871 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3872 #define elf_backend_relocate_section          elf_i386_relocate_section
3873 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3874 #define elf_backend_always_size_sections      elf_i386_always_size_sections
3875 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
3876 #define elf_backend_hash_symbol               elf_i386_hash_symbol
3877
3878 #include "elf32-target.h"
3879
3880 /* FreeBSD support.  */
3881
3882 #undef  TARGET_LITTLE_SYM
3883 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3884 #undef  TARGET_LITTLE_NAME
3885 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3886
3887 /* The kernel recognizes executables as valid only if they carry a
3888    "FreeBSD" label in the ELF header.  So we put this label on all
3889    executables and (for simplicity) also all other object files.  */
3890
3891 static void
3892 elf_i386_post_process_headers (bfd *abfd,
3893                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3894 {
3895   Elf_Internal_Ehdr *i_ehdrp;
3896
3897   i_ehdrp = elf_elfheader (abfd);
3898
3899   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3900   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3901 #ifdef OLD_FREEBSD_ABI_LABEL
3902   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3903   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3904 #endif
3905 }
3906
3907 #undef  elf_backend_post_process_headers
3908 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3909 #undef  elf32_bed
3910 #define elf32_bed                               elf32_i386_fbsd_bed
3911
3912 #include "elf32-target.h"
3913
3914 /* VxWorks support.  */
3915
3916 #undef  TARGET_LITTLE_SYM
3917 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
3918 #undef  TARGET_LITTLE_NAME
3919 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
3920
3921
3922 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks.  */
3923
3924 static struct bfd_link_hash_table *
3925 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3926 {
3927   struct bfd_link_hash_table *ret;
3928   struct elf_i386_link_hash_table *htab;
3929
3930   ret = elf_i386_link_hash_table_create (abfd);
3931   if (ret)
3932     {
3933       htab = (struct elf_i386_link_hash_table *) ret;
3934       htab->is_vxworks = 1;
3935       htab->plt0_pad_byte = 0x90;
3936     }
3937
3938   return ret;
3939 }
3940
3941
3942 #undef  elf_backend_post_process_headers
3943 #undef bfd_elf32_bfd_link_hash_table_create
3944 #define bfd_elf32_bfd_link_hash_table_create \
3945   elf_i386_vxworks_link_hash_table_create
3946 #undef elf_backend_add_symbol_hook
3947 #define elf_backend_add_symbol_hook \
3948   elf_vxworks_add_symbol_hook
3949 #undef elf_backend_link_output_symbol_hook
3950 #define elf_backend_link_output_symbol_hook \
3951   elf_vxworks_link_output_symbol_hook
3952 #undef elf_backend_emit_relocs
3953 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
3954 #undef elf_backend_final_write_processing
3955 #define elf_backend_final_write_processing \
3956   elf_vxworks_final_write_processing
3957
3958 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3959    define it.  */
3960 #undef elf_backend_want_plt_sym
3961 #define elf_backend_want_plt_sym        1
3962
3963 #undef  elf32_bed
3964 #define elf32_bed                               elf32_i386_vxworks_bed
3965
3966 #include "elf32-target.h"