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