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