bfd/elf32-i386.c

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