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