bfd/elf32-i386.c

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