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