bfd/elf32-i386.c

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