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 "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf-vxworks.h"
  27
  28 /* 386 uses REL relocations instead of RELA.  */
  29 #define USE_REL 1
  30
  31 #include "elf/i386.h"
  32
  33 static reloc_howto_type elf_howto_table[]=
  34 {
  35   HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
  36         bfd_elf_generic_reloc, "R_386_NONE",
  37         TRUE, 0x00000000, 0x00000000, FALSE),
  38   HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  39         bfd_elf_generic_reloc, "R_386_32",
  40         TRUE, 0xffffffff, 0xffffffff, FALSE),
  41   HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  42         bfd_elf_generic_reloc, "R_386_PC32",
  43         TRUE, 0xffffffff, 0xffffffff, TRUE),
  44   HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  45         bfd_elf_generic_reloc, "R_386_GOT32",
  46         TRUE, 0xffffffff, 0xffffffff, FALSE),
  47   HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  48         bfd_elf_generic_reloc, "R_386_PLT32",
  49         TRUE, 0xffffffff, 0xffffffff, TRUE),
  50   HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  51         bfd_elf_generic_reloc, "R_386_COPY",
  52         TRUE, 0xffffffff, 0xffffffff, FALSE),
  53   HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  54         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
  55         TRUE, 0xffffffff, 0xffffffff, FALSE),
  56   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  57         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
  58         TRUE, 0xffffffff, 0xffffffff, FALSE),
  59   HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  60         bfd_elf_generic_reloc, "R_386_RELATIVE",
  61         TRUE, 0xffffffff, 0xffffffff, FALSE),
  62   HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  63         bfd_elf_generic_reloc, "R_386_GOTOFF",
  64         TRUE, 0xffffffff, 0xffffffff, FALSE),
  65   HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  66         bfd_elf_generic_reloc, "R_386_GOTPC",
  67         TRUE, 0xffffffff, 0xffffffff, TRUE),
  68
  69   /* We have a gap in the reloc numbers here.
  70      R_386_standard counts the number up to this point, and
  71      R_386_ext_offset is the value to subtract from a reloc type of
  72      R_386_16 thru R_386_PC8 to form an index into this table.  */
  73 #define R_386_standard (R_386_GOTPC + 1)
  74 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
  75
  76   /* These relocs are a GNU extension.  */
  77   HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  78         bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
  79         TRUE, 0xffffffff, 0xffffffff, FALSE),
  80   HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  81         bfd_elf_generic_reloc, "R_386_TLS_IE",
  82         TRUE, 0xffffffff, 0xffffffff, FALSE),
  83   HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  84         bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
  85         TRUE, 0xffffffff, 0xffffffff, FALSE),
  86   HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  87         bfd_elf_generic_reloc, "R_386_TLS_LE",
  88         TRUE, 0xffffffff, 0xffffffff, FALSE),
  89   HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  90         bfd_elf_generic_reloc, "R_386_TLS_GD",
  91         TRUE, 0xffffffff, 0xffffffff, FALSE),
  92   HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  93         bfd_elf_generic_reloc, "R_386_TLS_LDM",
  94         TRUE, 0xffffffff, 0xffffffff, FALSE),
  95   HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  96         bfd_elf_generic_reloc, "R_386_16",
  97         TRUE, 0xffff, 0xffff, FALSE),
  98   HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  99         bfd_elf_generic_reloc, "R_386_PC16",
 100         TRUE, 0xffff, 0xffff, TRUE),
 101   HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
 102         bfd_elf_generic_reloc, "R_386_8",
 103         TRUE, 0xff, 0xff, FALSE),
 104   HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
 105         bfd_elf_generic_reloc, "R_386_PC8",
 106         TRUE, 0xff, 0xff, TRUE),
 107
 108 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
 109 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
 110   /* These are common with Solaris TLS implementation.  */
 111   HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 112         bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
 113         TRUE, 0xffffffff, 0xffffffff, FALSE),
 114   HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 115         bfd_elf_generic_reloc, "R_386_TLS_IE_32",
 116         TRUE, 0xffffffff, 0xffffffff, FALSE),
 117   HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 118         bfd_elf_generic_reloc, "R_386_TLS_LE_32",
 119         TRUE, 0xffffffff, 0xffffffff, FALSE),
 120   HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 121         bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
 122         TRUE, 0xffffffff, 0xffffffff, FALSE),
 123   HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 124         bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
 125         TRUE, 0xffffffff, 0xffffffff, FALSE),
 126   HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 127         bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
 128         TRUE, 0xffffffff, 0xffffffff, FALSE),
 129   EMPTY_HOWTO (38),
 130   HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 131         bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
 132         TRUE, 0xffffffff, 0xffffffff, FALSE),
 133   HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 134         bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
 135         FALSE, 0, 0, FALSE),
 136   HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 137         bfd_elf_generic_reloc, "R_386_TLS_DESC",
 138         TRUE, 0xffffffff, 0xffffffff, FALSE),
 139
 140   /* Another gap.  */
 141 #define R_386_tls (R_386_TLS_DESC + 1 - R_386_tls_offset)
 142 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_tls)
 143
 144 /* GNU extension to record C++ vtable hierarchy.  */
 145   HOWTO (R_386_GNU_VTINHERIT,   /* type */
 146          0,                     /* rightshift */
 147          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 148          0,                     /* bitsize */
 149          FALSE,                 /* pc_relative */
 150          0,                     /* bitpos */
 151          complain_overflow_dont, /* complain_on_overflow */
 152          NULL,                  /* special_function */
 153          "R_386_GNU_VTINHERIT", /* name */
 154          FALSE,                 /* partial_inplace */
 155          0,                     /* src_mask */
 156          0,                     /* dst_mask */
 157          FALSE),                /* pcrel_offset */
 158
 159 /* GNU extension to record C++ vtable member usage.  */
 160   HOWTO (R_386_GNU_VTENTRY,     /* type */
 161          0,                     /* rightshift */
 162          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 163          0,                     /* bitsize */
 164          FALSE,                 /* pc_relative */
 165          0,                     /* bitpos */
 166          complain_overflow_dont, /* complain_on_overflow */
 167          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 168          "R_386_GNU_VTENTRY",   /* name */
 169          FALSE,                 /* partial_inplace */
 170          0,                     /* src_mask */
 171          0,                     /* dst_mask */
 172          FALSE)                 /* pcrel_offset */
 173
 174 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
 175
 176 };
 177
 178 #ifdef DEBUG_GEN_RELOC
 179 #define TRACE(str) \
 180   fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 181 #else
 182 #define TRACE(str)
 183 #endif
 184
 185 static reloc_howto_type *
 186 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 187                             bfd_reloc_code_real_type code)
 188 {
 189   switch (code)
 190     {
 191     case BFD_RELOC_NONE:
 192       TRACE ("BFD_RELOC_NONE");
 193       return &elf_howto_table[R_386_NONE];
 194
 195     case BFD_RELOC_32:
 196       TRACE ("BFD_RELOC_32");
 197       return &elf_howto_table[R_386_32];
 198
 199     case BFD_RELOC_CTOR:
 200       TRACE ("BFD_RELOC_CTOR");
 201       return &elf_howto_table[R_386_32];
 202
 203     case BFD_RELOC_32_PCREL:
 204       TRACE ("BFD_RELOC_PC32");
 205       return &elf_howto_table[R_386_PC32];
 206
 207     case BFD_RELOC_386_GOT32:
 208       TRACE ("BFD_RELOC_386_GOT32");
 209       return &elf_howto_table[R_386_GOT32];
 210
 211     case BFD_RELOC_386_PLT32:
 212       TRACE ("BFD_RELOC_386_PLT32");
 213       return &elf_howto_table[R_386_PLT32];
 214
 215     case BFD_RELOC_386_COPY:
 216       TRACE ("BFD_RELOC_386_COPY");
 217       return &elf_howto_table[R_386_COPY];
 218
 219     case BFD_RELOC_386_GLOB_DAT:
 220       TRACE ("BFD_RELOC_386_GLOB_DAT");
 221       return &elf_howto_table[R_386_GLOB_DAT];
 222
 223     case BFD_RELOC_386_JUMP_SLOT:
 224       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 225       return &elf_howto_table[R_386_JUMP_SLOT];
 226
 227     case BFD_RELOC_386_RELATIVE:
 228       TRACE ("BFD_RELOC_386_RELATIVE");
 229       return &elf_howto_table[R_386_RELATIVE];
 230
 231     case BFD_RELOC_386_GOTOFF:
 232       TRACE ("BFD_RELOC_386_GOTOFF");
 233       return &elf_howto_table[R_386_GOTOFF];
 234
 235     case BFD_RELOC_386_GOTPC:
 236       TRACE ("BFD_RELOC_386_GOTPC");
 237       return &elf_howto_table[R_386_GOTPC];
 238
 239       /* These relocs are a GNU extension.  */
 240     case BFD_RELOC_386_TLS_TPOFF:
 241       TRACE ("BFD_RELOC_386_TLS_TPOFF");
 242       return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
 243
 244     case BFD_RELOC_386_TLS_IE:
 245       TRACE ("BFD_RELOC_386_TLS_IE");
 246       return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
 247
 248     case BFD_RELOC_386_TLS_GOTIE:
 249       TRACE ("BFD_RELOC_386_TLS_GOTIE");
 250       return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
 251
 252     case BFD_RELOC_386_TLS_LE:
 253       TRACE ("BFD_RELOC_386_TLS_LE");
 254       return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
 255
 256     case BFD_RELOC_386_TLS_GD:
 257       TRACE ("BFD_RELOC_386_TLS_GD");
 258       return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
 259
 260     case BFD_RELOC_386_TLS_LDM:
 261       TRACE ("BFD_RELOC_386_TLS_LDM");
 262       return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
 263
 264     case BFD_RELOC_16:
 265       TRACE ("BFD_RELOC_16");
 266       return &elf_howto_table[R_386_16 - R_386_ext_offset];
 267
 268     case BFD_RELOC_16_PCREL:
 269       TRACE ("BFD_RELOC_16_PCREL");
 270       return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
 271
 272     case BFD_RELOC_8:
 273       TRACE ("BFD_RELOC_8");
 274       return &elf_howto_table[R_386_8 - R_386_ext_offset];
 275
 276     case BFD_RELOC_8_PCREL:
 277       TRACE ("BFD_RELOC_8_PCREL");
 278       return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
 279
 280     /* Common with Sun TLS implementation.  */
 281     case BFD_RELOC_386_TLS_LDO_32:
 282       TRACE ("BFD_RELOC_386_TLS_LDO_32");
 283       return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
 284
 285     case BFD_RELOC_386_TLS_IE_32:
 286       TRACE ("BFD_RELOC_386_TLS_IE_32");
 287       return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
 288
 289     case BFD_RELOC_386_TLS_LE_32:
 290       TRACE ("BFD_RELOC_386_TLS_LE_32");
 291       return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
 292
 293     case BFD_RELOC_386_TLS_DTPMOD32:
 294       TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
 295       return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
 296
 297     case BFD_RELOC_386_TLS_DTPOFF32:
 298       TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
 299       return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
 300
 301     case BFD_RELOC_386_TLS_TPOFF32:
 302       TRACE ("BFD_RELOC_386_TLS_TPOFF32");
 303       return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
 304
 305     case BFD_RELOC_386_TLS_GOTDESC:
 306       TRACE ("BFD_RELOC_386_TLS_GOTDESC");
 307       return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
 308
 309     case BFD_RELOC_386_TLS_DESC_CALL:
 310       TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
 311       return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
 312
 313     case BFD_RELOC_386_TLS_DESC:
 314       TRACE ("BFD_RELOC_386_TLS_DESC");
 315       return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
 316
 317     case BFD_RELOC_VTABLE_INHERIT:
 318       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 319       return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
 320
 321     case BFD_RELOC_VTABLE_ENTRY:
 322       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 323       return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
 324
 325     default:
 326       break;
 327     }
 328
 329   TRACE ("Unknown");
 330   return 0;
 331 }
 332
 333 static 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   unsigned int power_of_two;
1423
1424   /* If this is a function, put it in the procedure linkage table.  We
1425      will fill in the contents of the procedure linkage table later,
1426      when we know the address of the .got section.  */
1427   if (h->type == STT_FUNC
1428       || h->needs_plt)
1429     {
1430       if (h->plt.refcount <= 0
1431           || SYMBOL_CALLS_LOCAL (info, h)
1432           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1433               && h->root.type == bfd_link_hash_undefweak))
1434         {
1435           /* This case can occur if we saw a PLT32 reloc in an input
1436              file, but the symbol was never referred to by a dynamic
1437              object, or if all references were garbage collected.  In
1438              such a case, we don't actually need to build a procedure
1439              linkage table, and we can just do a PC32 reloc instead.  */
1440           h->plt.offset = (bfd_vma) -1;
1441           h->needs_plt = 0;
1442         }
1443
1444       return TRUE;
1445     }
1446   else
1447     /* It's possible that we incorrectly decided a .plt reloc was
1448        needed for an R_386_PC32 reloc to a non-function sym in
1449        check_relocs.  We can't decide accurately between function and
1450        non-function syms in check-relocs;  Objects loaded later in
1451        the link may change h->type.  So fix it now.  */
1452     h->plt.offset = (bfd_vma) -1;
1453
1454   /* If this is a weak symbol, and there is a real definition, the
1455      processor independent code will have arranged for us to see the
1456      real definition first, and we can just use the same value.  */
1457   if (h->u.weakdef != NULL)
1458     {
1459       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1460                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1461       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1462       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1463       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1464         h->non_got_ref = h->u.weakdef->non_got_ref;
1465       return TRUE;
1466     }
1467
1468   /* This is a reference to a symbol defined by a dynamic object which
1469      is not a function.  */
1470
1471   /* If we are creating a shared library, we must presume that the
1472      only references to the symbol are via the global offset table.
1473      For such cases we need not do anything here; the relocations will
1474      be handled correctly by relocate_section.  */
1475   if (info->shared)
1476     return TRUE;
1477
1478   /* If there are no references to this symbol that do not use the
1479      GOT, we don't need to generate a copy reloc.  */
1480   if (!h->non_got_ref)
1481     return TRUE;
1482
1483   /* If -z nocopyreloc was given, we won't generate them either.  */
1484   if (info->nocopyreloc)
1485     {
1486       h->non_got_ref = 0;
1487       return TRUE;
1488     }
1489
1490   htab = elf_i386_hash_table (info);
1491
1492   /* If there aren't any dynamic relocs in read-only sections, then
1493      we can keep the dynamic relocs and avoid the copy reloc.  This
1494      doesn't work on VxWorks, where we can not have dynamic relocations
1495      (other than copy and jump slot relocations) in an executable.  */
1496   if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
1497     {
1498       struct elf_i386_link_hash_entry * eh;
1499       struct elf_i386_dyn_relocs *p;
1500
1501       eh = (struct elf_i386_link_hash_entry *) h;
1502       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1503         {
1504           s = p->sec->output_section;
1505           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1506             break;
1507         }
1508
1509       if (p == NULL)
1510         {
1511           h->non_got_ref = 0;
1512           return TRUE;
1513         }
1514     }
1515
1516   if (h->size == 0)
1517     {
1518       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1519                              h->root.root.string);
1520       return TRUE;
1521     }
1522
1523   /* We must allocate the symbol in our .dynbss section, which will
1524      become part of the .bss section of the executable.  There will be
1525      an entry for this symbol in the .dynsym section.  The dynamic
1526      object will contain position independent code, so all references
1527      from the dynamic object to this symbol will go through the global
1528      offset table.  The dynamic linker will use the .dynsym entry to
1529      determine the address it must put in the global offset table, so
1530      both the dynamic object and the regular object will refer to the
1531      same memory location for the variable.  */
1532
1533   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1534      copy the initial value out of the dynamic object and into the
1535      runtime process image.  */
1536   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1537     {
1538       htab->srelbss->size += sizeof (Elf32_External_Rel);
1539       h->needs_copy = 1;
1540     }
1541
1542   /* We need to figure out the alignment required for this symbol.  I
1543      have no idea how ELF linkers handle this.  */
1544   power_of_two = bfd_log2 (h->size);
1545   if (power_of_two > 3)
1546     power_of_two = 3;
1547
1548   /* Apply the required alignment.  */
1549   s = htab->sdynbss;
1550   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1551   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1552     {
1553       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1554         return FALSE;
1555     }
1556
1557   /* Define the symbol as being at this point in the section.  */
1558   h->root.u.def.section = s;
1559   h->root.u.def.value = s->size;
1560
1561   /* Increment the section size to make room for the symbol.  */
1562   s->size += h->size;
1563
1564   return TRUE;
1565 }
1566
1567 /* Allocate space in .plt, .got and associated reloc sections for
1568    dynamic relocs.  */
1569
1570 static bfd_boolean
1571 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1572 {
1573   struct bfd_link_info *info;
1574   struct elf_i386_link_hash_table *htab;
1575   struct elf_i386_link_hash_entry *eh;
1576   struct elf_i386_dyn_relocs *p;
1577
1578   if (h->root.type == bfd_link_hash_indirect)
1579     return TRUE;
1580
1581   if (h->root.type == bfd_link_hash_warning)
1582     /* When warning symbols are created, they **replace** the "real"
1583        entry in the hash table, thus we never get to see the real
1584        symbol in a hash traversal.  So look at it now.  */
1585     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1586
1587   info = (struct bfd_link_info *) inf;
1588   htab = elf_i386_hash_table (info);
1589
1590   if (htab->elf.dynamic_sections_created
1591       && h->plt.refcount > 0)
1592     {
1593       /* Make sure this symbol is output as a dynamic symbol.
1594          Undefined weak syms won't yet be marked as dynamic.  */
1595       if (h->dynindx == -1
1596           && !h->forced_local)
1597         {
1598           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1599             return FALSE;
1600         }
1601
1602       if (info->shared
1603           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1604         {
1605           asection *s = htab->splt;
1606
1607           /* If this is the first .plt entry, make room for the special
1608              first entry.  */
1609           if (s->size == 0)
1610             s->size += PLT_ENTRY_SIZE;
1611
1612           h->plt.offset = s->size;
1613
1614           /* If this symbol is not defined in a regular file, and we are
1615              not generating a shared library, then set the symbol to this
1616              location in the .plt.  This is required to make function
1617              pointers compare as equal between the normal executable and
1618              the shared library.  */
1619           if (! info->shared
1620               && !h->def_regular)
1621             {
1622               h->root.u.def.section = s;
1623               h->root.u.def.value = h->plt.offset;
1624             }
1625
1626           /* Make room for this entry.  */
1627           s->size += PLT_ENTRY_SIZE;
1628
1629           /* We also need to make an entry in the .got.plt section, which
1630              will be placed in the .got section by the linker script.  */
1631           htab->sgotplt->size += 4;
1632
1633           /* We also need to make an entry in the .rel.plt section.  */
1634           htab->srelplt->size += sizeof (Elf32_External_Rel);
1635           htab->next_tls_desc_index++;
1636
1637           if (htab->is_vxworks && !info->shared)
1638             {
1639               /* VxWorks has a second set of relocations for each PLT entry
1640                  in executables.  They go in a separate relocation section,
1641                  which is processed by the kernel loader.  */
1642
1643               /* There are two relocations for the initial PLT entry: an
1644                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1645                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
1646
1647               if (h->plt.offset == PLT_ENTRY_SIZE)
1648                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1649
1650               /* There are two extra relocations for each subsequent PLT entry:
1651                  an R_386_32 relocation for the GOT entry, and an R_386_32
1652                  relocation for the PLT entry.  */
1653
1654               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1655             }
1656         }
1657       else
1658         {
1659           h->plt.offset = (bfd_vma) -1;
1660           h->needs_plt = 0;
1661         }
1662     }
1663   else
1664     {
1665       h->plt.offset = (bfd_vma) -1;
1666       h->needs_plt = 0;
1667     }
1668
1669   eh = (struct elf_i386_link_hash_entry *) h;
1670   eh->tlsdesc_got = (bfd_vma) -1;
1671
1672   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1673      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
1674   if (h->got.refcount > 0
1675       && !info->shared
1676       && h->dynindx == -1
1677       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1678     h->got.offset = (bfd_vma) -1;
1679   else if (h->got.refcount > 0)
1680     {
1681       asection *s;
1682       bfd_boolean dyn;
1683       int tls_type = elf_i386_hash_entry(h)->tls_type;
1684
1685       /* Make sure this symbol is output as a dynamic symbol.
1686          Undefined weak syms won't yet be marked as dynamic.  */
1687       if (h->dynindx == -1
1688           && !h->forced_local)
1689         {
1690           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1691             return FALSE;
1692         }
1693
1694       s = htab->sgot;
1695       if (GOT_TLS_GDESC_P (tls_type))
1696         {
1697           eh->tlsdesc_got = htab->sgotplt->size
1698             - elf_i386_compute_jump_table_size (htab);
1699           htab->sgotplt->size += 8;
1700           h->got.offset = (bfd_vma) -2;
1701         }
1702       if (! GOT_TLS_GDESC_P (tls_type)
1703           || GOT_TLS_GD_P (tls_type))
1704         {
1705           h->got.offset = s->size;
1706           s->size += 4;
1707           /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
1708           if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
1709             s->size += 4;
1710         }
1711       dyn = htab->elf.dynamic_sections_created;
1712       /* R_386_TLS_IE_32 needs one dynamic relocation,
1713          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1714          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1715          need two), R_386_TLS_GD needs one if local symbol and two if
1716          global.  */
1717       if (tls_type == GOT_TLS_IE_BOTH)
1718         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1719       else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1720                || (tls_type & GOT_TLS_IE))
1721         htab->srelgot->size += sizeof (Elf32_External_Rel);
1722       else if (GOT_TLS_GD_P (tls_type))
1723         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1724       else if (! GOT_TLS_GDESC_P (tls_type)
1725                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1726                    || h->root.type != bfd_link_hash_undefweak)
1727                && (info->shared
1728                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1729         htab->srelgot->size += sizeof (Elf32_External_Rel);
1730       if (GOT_TLS_GDESC_P (tls_type))
1731         htab->srelplt->size += sizeof (Elf32_External_Rel);
1732     }
1733   else
1734     h->got.offset = (bfd_vma) -1;
1735
1736   if (eh->dyn_relocs == NULL)
1737     return TRUE;
1738
1739   /* In the shared -Bsymbolic case, discard space allocated for
1740      dynamic pc-relative relocs against symbols which turn out to be
1741      defined in regular objects.  For the normal shared case, discard
1742      space for pc-relative relocs that have become local due to symbol
1743      visibility changes.  */
1744
1745   if (info->shared)
1746     {
1747       /* The only reloc that uses pc_count is R_386_PC32, which will
1748          appear on a call or on something like ".long foo - .".  We
1749          want calls to protected symbols to resolve directly to the
1750          function rather than going via the plt.  If people want
1751          function pointer comparisons to work as expected then they
1752          should avoid writing assembly like ".long foo - .".  */
1753       if (SYMBOL_CALLS_LOCAL (info, h))
1754         {
1755           struct elf_i386_dyn_relocs **pp;
1756
1757           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1758             {
1759               p->count -= p->pc_count;
1760               p->pc_count = 0;
1761               if (p->count == 0)
1762                 *pp = p->next;
1763               else
1764                 pp = &p->next;
1765             }
1766         }
1767
1768       /* Also discard relocs on undefined weak syms with non-default
1769          visibility.  */
1770       if (eh->dyn_relocs != NULL
1771           && h->root.type == bfd_link_hash_undefweak)
1772         {
1773           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1774             eh->dyn_relocs = NULL;
1775
1776           /* Make sure undefined weak symbols are output as a dynamic
1777              symbol in PIEs.  */
1778           else if (h->dynindx == -1
1779                    && !h->forced_local)
1780             {
1781               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1782                 return FALSE;
1783             }
1784         }
1785     }
1786   else if (ELIMINATE_COPY_RELOCS)
1787     {
1788       /* For the non-shared case, discard space for relocs against
1789          symbols which turn out to need copy relocs or are not
1790          dynamic.  */
1791
1792       if (!h->non_got_ref
1793           && ((h->def_dynamic
1794                && !h->def_regular)
1795               || (htab->elf.dynamic_sections_created
1796                   && (h->root.type == bfd_link_hash_undefweak
1797                       || h->root.type == bfd_link_hash_undefined))))
1798         {
1799           /* Make sure this symbol is output as a dynamic symbol.
1800              Undefined weak syms won't yet be marked as dynamic.  */
1801           if (h->dynindx == -1
1802               && !h->forced_local)
1803             {
1804               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1805                 return FALSE;
1806             }
1807
1808           /* If that succeeded, we know we'll be keeping all the
1809              relocs.  */
1810           if (h->dynindx != -1)
1811             goto keep;
1812         }
1813
1814       eh->dyn_relocs = NULL;
1815
1816     keep: ;
1817     }
1818
1819   /* Finally, allocate space.  */
1820   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1821     {
1822       asection *sreloc = elf_section_data (p->sec)->sreloc;
1823       sreloc->size += p->count * sizeof (Elf32_External_Rel);
1824     }
1825
1826   return TRUE;
1827 }
1828
1829 /* Find any dynamic relocs that apply to read-only sections.  */
1830
1831 static bfd_boolean
1832 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1833 {
1834   struct elf_i386_link_hash_entry *eh;
1835   struct elf_i386_dyn_relocs *p;
1836
1837   if (h->root.type == bfd_link_hash_warning)
1838     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1839
1840   eh = (struct elf_i386_link_hash_entry *) h;
1841   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1842     {
1843       asection *s = p->sec->output_section;
1844
1845       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1846         {
1847           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1848
1849           info->flags |= DF_TEXTREL;
1850
1851           /* Not an error, just cut short the traversal.  */
1852           return FALSE;
1853         }
1854     }
1855   return TRUE;
1856 }
1857
1858 /* Set the sizes of the dynamic sections.  */
1859
1860 static bfd_boolean
1861 elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1862                                 struct bfd_link_info *info)
1863 {
1864   struct elf_i386_link_hash_table *htab;
1865   bfd *dynobj;
1866   asection *s;
1867   bfd_boolean relocs;
1868   bfd *ibfd;
1869
1870   htab = elf_i386_hash_table (info);
1871   dynobj = htab->elf.dynobj;
1872   if (dynobj == NULL)
1873     abort ();
1874
1875   if (htab->elf.dynamic_sections_created)
1876     {
1877       /* Set the contents of the .interp section to the interpreter.  */
1878       if (info->executable)
1879         {
1880           s = bfd_get_section_by_name (dynobj, ".interp");
1881           if (s == NULL)
1882             abort ();
1883           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1884           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1885         }
1886     }
1887
1888   /* Set up .got offsets for local syms, and space for local dynamic
1889      relocs.  */
1890   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1891     {
1892       bfd_signed_vma *local_got;
1893       bfd_signed_vma *end_local_got;
1894       char *local_tls_type;
1895       bfd_vma *local_tlsdesc_gotent;
1896       bfd_size_type locsymcount;
1897       Elf_Internal_Shdr *symtab_hdr;
1898       asection *srel;
1899
1900       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1901         continue;
1902
1903       for (s = ibfd->sections; s != NULL; s = s->next)
1904         {
1905           struct elf_i386_dyn_relocs *p;
1906
1907           for (p = ((struct elf_i386_dyn_relocs *)
1908                      elf_section_data (s)->local_dynrel);
1909                p != NULL;
1910                p = p->next)
1911             {
1912               if (!bfd_is_abs_section (p->sec)
1913                   && bfd_is_abs_section (p->sec->output_section))
1914                 {
1915                   /* Input section has been discarded, either because
1916                      it is a copy of a linkonce section or due to
1917                      linker script /DISCARD/, so we'll be discarding
1918                      the relocs too.  */
1919                 }
1920               else if (p->count != 0)
1921                 {
1922                   srel = elf_section_data (p->sec)->sreloc;
1923                   srel->size += p->count * sizeof (Elf32_External_Rel);
1924                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1925                     info->flags |= DF_TEXTREL;
1926                 }
1927             }
1928         }
1929
1930       local_got = elf_local_got_refcounts (ibfd);
1931       if (!local_got)
1932         continue;
1933
1934       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1935       locsymcount = symtab_hdr->sh_info;
1936       end_local_got = local_got + locsymcount;
1937       local_tls_type = elf_i386_local_got_tls_type (ibfd);
1938       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
1939       s = htab->sgot;
1940       srel = htab->srelgot;
1941       for (; local_got < end_local_got;
1942            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1943         {
1944           *local_tlsdesc_gotent = (bfd_vma) -1;
1945           if (*local_got > 0)
1946             {
1947               if (GOT_TLS_GDESC_P (*local_tls_type))
1948                 {
1949                   *local_tlsdesc_gotent = htab->sgotplt->size
1950                     - elf_i386_compute_jump_table_size (htab);
1951                   htab->sgotplt->size += 8;
1952                   *local_got = (bfd_vma) -2;
1953                 }
1954               if (! GOT_TLS_GDESC_P (*local_tls_type)
1955                   || GOT_TLS_GD_P (*local_tls_type))
1956                 {
1957                   *local_got = s->size;
1958                   s->size += 4;
1959                   if (GOT_TLS_GD_P (*local_tls_type)
1960                       || *local_tls_type == GOT_TLS_IE_BOTH)
1961                     s->size += 4;
1962                 }
1963               if (info->shared
1964                   || GOT_TLS_GD_ANY_P (*local_tls_type)
1965                   || (*local_tls_type & GOT_TLS_IE))
1966                 {
1967                   if (*local_tls_type == GOT_TLS_IE_BOTH)
1968                     srel->size += 2 * sizeof (Elf32_External_Rel);
1969                   else if (GOT_TLS_GD_P (*local_tls_type)
1970                            || ! GOT_TLS_GDESC_P (*local_tls_type))
1971                     srel->size += sizeof (Elf32_External_Rel);
1972                   if (GOT_TLS_GDESC_P (*local_tls_type))
1973                     htab->srelplt->size += sizeof (Elf32_External_Rel);
1974                 }
1975             }
1976           else
1977             *local_got = (bfd_vma) -1;
1978         }
1979     }
1980
1981   if (htab->tls_ldm_got.refcount > 0)
1982     {
1983       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1984          relocs.  */
1985       htab->tls_ldm_got.offset = htab->sgot->size;
1986       htab->sgot->size += 8;
1987       htab->srelgot->size += sizeof (Elf32_External_Rel);
1988     }
1989   else
1990     htab->tls_ldm_got.offset = -1;
1991
1992   /* Allocate global sym .plt and .got entries, and space for global
1993      sym dynamic relocs.  */
1994   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1995
1996   /* For every jump slot reserved in the sgotplt, reloc_count is
1997      incremented.  However, when we reserve space for TLS descriptors,
1998      it's not incremented, so in order to compute the space reserved
1999      for them, it suffices to multiply the reloc count by the jump
2000      slot size.  */
2001   if (htab->srelplt)
2002     htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2003
2004   /* We now have determined the sizes of the various dynamic sections.
2005      Allocate memory for them.  */
2006   relocs = FALSE;
2007   for (s = dynobj->sections; s != NULL; s = s->next)
2008     {
2009       bfd_boolean strip_section = TRUE;
2010
2011       if ((s->flags & SEC_LINKER_CREATED) == 0)
2012         continue;
2013
2014       if (s == htab->splt
2015           || s == htab->sgot
2016           || s == htab->sgotplt
2017           || s == htab->sdynbss)
2018         {
2019           /* Strip this section if we don't need it; see the
2020              comment below.  */
2021           /* We'd like to strip these sections if they aren't needed, but if
2022              we've exported dynamic symbols from them we must leave them.
2023              It's too late to tell BFD to get rid of the symbols.  */
2024
2025           if (htab->elf.hplt != NULL)
2026             strip_section = FALSE;
2027         }
2028       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2029         {
2030           if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
2031             relocs = TRUE;
2032
2033           /* We use the reloc_count field as a counter if we need
2034              to copy relocs into the output file.  */
2035           s->reloc_count = 0;
2036         }
2037       else
2038         {
2039           /* It's not one of our sections, so don't allocate space.  */
2040           continue;
2041         }
2042
2043       if (s->size == 0)
2044         {
2045           /* If we don't need this section, strip it from the
2046              output file.  This is mostly to handle .rel.bss and
2047              .rel.plt.  We must create both sections in
2048              create_dynamic_sections, because they must be created
2049              before the linker maps input sections to output
2050              sections.  The linker does that before
2051              adjust_dynamic_symbol is called, and it is that
2052              function which decides whether anything needs to go
2053              into these sections.  */
2054           if (strip_section)
2055             s->flags |= SEC_EXCLUDE;
2056           continue;
2057         }
2058
2059       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2060         continue;
2061
2062       /* Allocate memory for the section contents.  We use bfd_zalloc
2063          here in case unused entries are not reclaimed before the
2064          section's contents are written out.  This should not happen,
2065          but this way if it does, we get a R_386_NONE reloc instead
2066          of garbage.  */
2067       s->contents = bfd_zalloc (dynobj, s->size);
2068       if (s->contents == NULL)
2069         return FALSE;
2070     }
2071
2072   if (htab->elf.dynamic_sections_created)
2073     {
2074       /* Add some entries to the .dynamic section.  We fill in the
2075          values later, in elf_i386_finish_dynamic_sections, but we
2076          must add the entries now so that we get the correct size for
2077          the .dynamic section.  The DT_DEBUG entry is filled in by the
2078          dynamic linker and used by the debugger.  */
2079 #define add_dynamic_entry(TAG, VAL) \
2080   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2081
2082       if (info->executable)
2083         {
2084           if (!add_dynamic_entry (DT_DEBUG, 0))
2085             return FALSE;
2086         }
2087
2088       if (htab->splt->size != 0)
2089         {
2090           if (!add_dynamic_entry (DT_PLTGOT, 0)
2091               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2092               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2093               || !add_dynamic_entry (DT_JMPREL, 0))
2094             return FALSE;
2095         }
2096
2097       if (relocs)
2098         {
2099           if (!add_dynamic_entry (DT_REL, 0)
2100               || !add_dynamic_entry (DT_RELSZ, 0)
2101               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2102             return FALSE;
2103
2104           /* If any dynamic relocs apply to a read-only section,
2105              then we need a DT_TEXTREL entry.  */
2106           if ((info->flags & DF_TEXTREL) == 0)
2107             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2108                                     (PTR) info);
2109
2110           if ((info->flags & DF_TEXTREL) != 0)
2111             {
2112               if (!add_dynamic_entry (DT_TEXTREL, 0))
2113                 return FALSE;
2114             }
2115         }
2116     }
2117 #undef add_dynamic_entry
2118
2119   return TRUE;
2120 }
2121
2122 static bfd_boolean
2123 elf_i386_always_size_sections (bfd *output_bfd,
2124                                struct bfd_link_info *info)
2125 {
2126   asection *tls_sec = elf_hash_table (info)->tls_sec;
2127
2128   if (tls_sec)
2129     {
2130       struct elf_link_hash_entry *tlsbase;
2131
2132       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2133                                       "_TLS_MODULE_BASE_",
2134                                       FALSE, FALSE, FALSE);
2135
2136       if (tlsbase && tlsbase->type == STT_TLS)
2137         {
2138           struct bfd_link_hash_entry *bh = NULL;
2139           const struct elf_backend_data *bed
2140             = get_elf_backend_data (output_bfd);
2141
2142           if (!(_bfd_generic_link_add_one_symbol
2143                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2144                  tls_sec, 0, NULL, FALSE,
2145                  bed->collect, &bh)))
2146             return FALSE;
2147           tlsbase = (struct elf_link_hash_entry *)bh;
2148           tlsbase->def_regular = 1;
2149           tlsbase->other = STV_HIDDEN;
2150           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2151         }
2152     }
2153
2154   return TRUE;
2155 }
2156
2157 /* Set the correct type for an x86 ELF section.  We do this by the
2158    section name, which is a hack, but ought to work.  */
2159
2160 static bfd_boolean
2161 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2162                         Elf_Internal_Shdr *hdr,
2163                         asection *sec)
2164 {
2165   register const char *name;
2166
2167   name = bfd_get_section_name (abfd, sec);
2168
2169   /* This is an ugly, but unfortunately necessary hack that is
2170      needed when producing EFI binaries on x86. It tells
2171      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2172      containing ELF relocation info.  We need this hack in order to
2173      be able to generate ELF binaries that can be translated into
2174      EFI applications (which are essentially COFF objects).  Those
2175      files contain a COFF ".reloc" section inside an ELFNN object,
2176      which would normally cause BFD to segfault because it would
2177      attempt to interpret this section as containing relocation
2178      entries for section "oc".  With this hack enabled, ".reloc"
2179      will be treated as a normal data section, which will avoid the
2180      segfault.  However, you won't be able to create an ELFNN binary
2181      with a section named "oc" that needs relocations, but that's
2182      the kind of ugly side-effects you get when detecting section
2183      types based on their names...  In practice, this limitation is
2184      unlikely to bite.  */
2185   if (strcmp (name, ".reloc") == 0)
2186     hdr->sh_type = SHT_PROGBITS;
2187
2188   return TRUE;
2189 }
2190
2191 /* Return the base VMA address which should be subtracted from real addresses
2192    when resolving @dtpoff relocation.
2193    This is PT_TLS segment p_vaddr.  */
2194
2195 static bfd_vma
2196 dtpoff_base (struct bfd_link_info *info)
2197 {
2198   /* If tls_sec is NULL, we should have signalled an error already.  */
2199   if (elf_hash_table (info)->tls_sec == NULL)
2200     return 0;
2201   return elf_hash_table (info)->tls_sec->vma;
2202 }
2203
2204 /* Return the relocation value for @tpoff relocation
2205    if STT_TLS virtual address is ADDRESS.  */
2206
2207 static bfd_vma
2208 tpoff (struct bfd_link_info *info, bfd_vma address)
2209 {
2210   struct elf_link_hash_table *htab = elf_hash_table (info);
2211
2212   /* If tls_sec is NULL, we should have signalled an error already.  */
2213   if (htab->tls_sec == NULL)
2214     return 0;
2215   return htab->tls_size + htab->tls_sec->vma - address;
2216 }
2217
2218 /* Relocate an i386 ELF section.  */
2219
2220 static bfd_boolean
2221 elf_i386_relocate_section (bfd *output_bfd,
2222                            struct bfd_link_info *info,
2223                            bfd *input_bfd,
2224                            asection *input_section,
2225                            bfd_byte *contents,
2226                            Elf_Internal_Rela *relocs,
2227                            Elf_Internal_Sym *local_syms,
2228                            asection **local_sections)
2229 {
2230   struct elf_i386_link_hash_table *htab;
2231   Elf_Internal_Shdr *symtab_hdr;
2232   struct elf_link_hash_entry **sym_hashes;
2233   bfd_vma *local_got_offsets;
2234   bfd_vma *local_tlsdesc_gotents;
2235   Elf_Internal_Rela *rel;
2236   Elf_Internal_Rela *relend;
2237
2238   htab = elf_i386_hash_table (info);
2239   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2240   sym_hashes = elf_sym_hashes (input_bfd);
2241   local_got_offsets = elf_local_got_offsets (input_bfd);
2242   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
2243
2244   rel = relocs;
2245   relend = relocs + input_section->reloc_count;
2246   for (; rel < relend; rel++)
2247     {
2248       unsigned int r_type;
2249       reloc_howto_type *howto;
2250       unsigned long r_symndx;
2251       struct elf_link_hash_entry *h;
2252       Elf_Internal_Sym *sym;
2253       asection *sec;
2254       bfd_vma off, offplt;
2255       bfd_vma relocation;
2256       bfd_boolean unresolved_reloc;
2257       bfd_reloc_status_type r;
2258       unsigned int indx;
2259       int tls_type;
2260
2261       r_type = ELF32_R_TYPE (rel->r_info);
2262       if (r_type == R_386_GNU_VTINHERIT
2263           || r_type == R_386_GNU_VTENTRY)
2264         continue;
2265
2266       if ((indx = r_type) >= R_386_standard
2267           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2268               >= R_386_ext - R_386_standard)
2269           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2270               >= R_386_tls - R_386_ext))
2271         {
2272           (*_bfd_error_handler)
2273             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2274              input_bfd, input_section, r_type);
2275           bfd_set_error (bfd_error_bad_value);
2276           return FALSE;
2277         }
2278       howto = elf_howto_table + indx;
2279
2280       r_symndx = ELF32_R_SYM (rel->r_info);
2281       h = NULL;
2282       sym = NULL;
2283       sec = NULL;
2284       unresolved_reloc = FALSE;
2285       if (r_symndx < symtab_hdr->sh_info)
2286         {
2287           sym = local_syms + r_symndx;
2288           sec = local_sections[r_symndx];
2289           relocation = (sec->output_section->vma
2290                         + sec->output_offset
2291                         + sym->st_value);
2292
2293           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2294               && ((sec->flags & SEC_MERGE) != 0
2295                   || (info->relocatable
2296                       && sec->output_offset != 0)))
2297             {
2298               bfd_vma addend;
2299               bfd_byte *where = contents + rel->r_offset;
2300
2301               switch (howto->size)
2302                 {
2303                 case 0:
2304                   addend = bfd_get_8 (input_bfd, where);
2305                   if (howto->pc_relative)
2306                     {
2307                       addend = (addend ^ 0x80) - 0x80;
2308                       addend += 1;
2309                     }
2310                   break;
2311                 case 1:
2312                   addend = bfd_get_16 (input_bfd, where);
2313                   if (howto->pc_relative)
2314                     {
2315                       addend = (addend ^ 0x8000) - 0x8000;
2316                       addend += 2;
2317                     }
2318                   break;
2319                 case 2:
2320                   addend = bfd_get_32 (input_bfd, where);
2321                   if (howto->pc_relative)
2322                     {
2323                       addend = (addend ^ 0x80000000) - 0x80000000;
2324                       addend += 4;
2325                     }
2326                   break;
2327                 default:
2328                   abort ();
2329                 }
2330
2331               if (info->relocatable)
2332                 addend += sec->output_offset;
2333               else
2334                 {
2335                   asection *msec = sec;
2336                   addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
2337                                                    addend);
2338                   addend -= relocation;
2339                   addend += msec->output_section->vma + msec->output_offset;
2340                 }
2341
2342               switch (howto->size)
2343                 {
2344                 case 0:
2345                   /* FIXME: overflow checks.  */
2346                   if (howto->pc_relative)
2347                     addend -= 1;
2348                   bfd_put_8 (input_bfd, addend, where);
2349                   break;
2350                 case 1:
2351                   if (howto->pc_relative)
2352                     addend -= 2;
2353                   bfd_put_16 (input_bfd, addend, where);
2354                   break;
2355                 case 2:
2356                   if (howto->pc_relative)
2357                     addend -= 4;
2358                   bfd_put_32 (input_bfd, addend, where);
2359                   break;
2360                 }
2361             }
2362         }
2363       else
2364         {
2365           bfd_boolean warned;
2366
2367           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2368                                    r_symndx, symtab_hdr, sym_hashes,
2369                                    h, sec, relocation,
2370                                    unresolved_reloc, warned);
2371         }
2372
2373       if (sec != NULL && elf_discarded_section (sec))
2374         {
2375           /* For relocs against symbols from removed linkonce sections,
2376              or sections discarded by a linker script, we just want the
2377              section contents zeroed.  Avoid any special processing.  */
2378           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2379           rel->r_info = 0;
2380           rel->r_addend = 0;
2381           continue;
2382         }
2383
2384       if (info->relocatable)
2385         continue;
2386
2387       switch (r_type)
2388         {
2389         case R_386_GOT32:
2390           /* Relocation is to the entry for this symbol in the global
2391              offset table.  */
2392           if (htab->sgot == NULL)
2393             abort ();
2394
2395           if (h != NULL)
2396             {
2397               bfd_boolean dyn;
2398
2399               off = h->got.offset;
2400               dyn = htab->elf.dynamic_sections_created;
2401               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2402                   || (info->shared
2403                       && SYMBOL_REFERENCES_LOCAL (info, h))
2404                   || (ELF_ST_VISIBILITY (h->other)
2405                       && h->root.type == bfd_link_hash_undefweak))
2406                 {
2407                   /* This is actually a static link, or it is a
2408                      -Bsymbolic link and the symbol is defined
2409                      locally, or the symbol was forced to be local
2410                      because of a version file.  We must initialize
2411                      this entry in the global offset table.  Since the
2412                      offset must always be a multiple of 4, we use the
2413                      least significant bit to record whether we have
2414                      initialized it already.
2415
2416                      When doing a dynamic link, we create a .rel.got
2417                      relocation entry to initialize the value.  This
2418                      is done in the finish_dynamic_symbol routine.  */
2419                   if ((off & 1) != 0)
2420                     off &= ~1;
2421                   else
2422                     {
2423                       bfd_put_32 (output_bfd, relocation,
2424                                   htab->sgot->contents + off);
2425                       h->got.offset |= 1;
2426                     }
2427                 }
2428               else
2429                 unresolved_reloc = FALSE;
2430             }
2431           else
2432             {
2433               if (local_got_offsets == NULL)
2434                 abort ();
2435
2436               off = local_got_offsets[r_symndx];
2437
2438               /* The offset must always be a multiple of 4.  We use
2439                  the least significant bit to record whether we have
2440                  already generated the necessary reloc.  */
2441               if ((off & 1) != 0)
2442                 off &= ~1;
2443               else
2444                 {
2445                   bfd_put_32 (output_bfd, relocation,
2446                               htab->sgot->contents + off);
2447
2448                   if (info->shared)
2449                     {
2450                       asection *s;
2451                       Elf_Internal_Rela outrel;
2452                       bfd_byte *loc;
2453
2454                       s = htab->srelgot;
2455                       if (s == NULL)
2456                         abort ();
2457
2458                       outrel.r_offset = (htab->sgot->output_section->vma
2459                                          + htab->sgot->output_offset
2460                                          + off);
2461                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2462                       loc = s->contents;
2463                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2464                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2465                     }
2466
2467                   local_got_offsets[r_symndx] |= 1;
2468                 }
2469             }
2470
2471           if (off >= (bfd_vma) -2)
2472             abort ();
2473
2474           relocation = htab->sgot->output_section->vma
2475                        + htab->sgot->output_offset + off
2476                        - htab->sgotplt->output_section->vma
2477                        - htab->sgotplt->output_offset;
2478           break;
2479
2480         case R_386_GOTOFF:
2481           /* Relocation is relative to the start of the global offset
2482              table.  */
2483
2484           /* Check to make sure it isn't a protected function symbol
2485              for shared library since it may not be local when used
2486              as function address.  */
2487           if (info->shared
2488               && !info->executable
2489               && h
2490               && h->def_regular
2491               && h->type == STT_FUNC
2492               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2493             {
2494               (*_bfd_error_handler)
2495                 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2496                  input_bfd, h->root.root.string);
2497               bfd_set_error (bfd_error_bad_value);
2498               return FALSE;
2499             }
2500
2501           /* Note that sgot is not involved in this
2502              calculation.  We always want the start of .got.plt.  If we
2503              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2504              permitted by the ABI, we might have to change this
2505              calculation.  */
2506           relocation -= htab->sgotplt->output_section->vma
2507                         + htab->sgotplt->output_offset;
2508           break;
2509
2510         case R_386_GOTPC:
2511           /* Use global offset table as symbol value.  */
2512           relocation = htab->sgotplt->output_section->vma
2513                        + htab->sgotplt->output_offset;
2514           unresolved_reloc = FALSE;
2515           break;
2516
2517         case R_386_PLT32:
2518           /* Relocation is to the entry for this symbol in the
2519              procedure linkage table.  */
2520
2521           /* Resolve a PLT32 reloc against a local symbol directly,
2522              without using the procedure linkage table.  */
2523           if (h == NULL)
2524             break;
2525
2526           if (h->plt.offset == (bfd_vma) -1
2527               || htab->splt == NULL)
2528             {
2529               /* We didn't make a PLT entry for this symbol.  This
2530                  happens when statically linking PIC code, or when
2531                  using -Bsymbolic.  */
2532               break;
2533             }
2534
2535           relocation = (htab->splt->output_section->vma
2536                         + htab->splt->output_offset
2537                         + h->plt.offset);
2538           unresolved_reloc = FALSE;
2539           break;
2540
2541         case R_386_32:
2542         case R_386_PC32:
2543           if ((input_section->flags & SEC_ALLOC) == 0)
2544             break;
2545
2546           if ((info->shared
2547                && (h == NULL
2548                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2549                    || h->root.type != bfd_link_hash_undefweak)
2550                && (r_type != R_386_PC32
2551                    || !SYMBOL_CALLS_LOCAL (info, h)))
2552               || (ELIMINATE_COPY_RELOCS
2553                   && !info->shared
2554                   && h != NULL
2555                   && h->dynindx != -1
2556                   && !h->non_got_ref
2557                   && ((h->def_dynamic
2558                        && !h->def_regular)
2559                       || h->root.type == bfd_link_hash_undefweak
2560                       || h->root.type == bfd_link_hash_undefined)))
2561             {
2562               Elf_Internal_Rela outrel;
2563               bfd_byte *loc;
2564               bfd_boolean skip, relocate;
2565               asection *sreloc;
2566
2567               /* When generating a shared object, these relocations
2568                  are copied into the output file to be resolved at run
2569                  time.  */
2570
2571               skip = FALSE;
2572               relocate = FALSE;
2573
2574               outrel.r_offset =
2575                 _bfd_elf_section_offset (output_bfd, info, input_section,
2576                                          rel->r_offset);
2577               if (outrel.r_offset == (bfd_vma) -1)
2578                 skip = TRUE;
2579               else if (outrel.r_offset == (bfd_vma) -2)
2580                 skip = TRUE, relocate = TRUE;
2581               outrel.r_offset += (input_section->output_section->vma
2582                                   + input_section->output_offset);
2583
2584               if (skip)
2585                 memset (&outrel, 0, sizeof outrel);
2586               else if (h != NULL
2587                        && h->dynindx != -1
2588                        && (r_type == R_386_PC32
2589                            || !info->shared
2590                            || !SYMBOLIC_BIND (info, h)
2591                            || !h->def_regular))
2592                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2593               else
2594                 {
2595                   /* This symbol is local, or marked to become local.  */
2596                   relocate = TRUE;
2597                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2598                 }
2599
2600               sreloc = elf_section_data (input_section)->sreloc;
2601               if (sreloc == NULL)
2602                 abort ();
2603
2604               loc = sreloc->contents;
2605               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2606               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2607
2608               /* If this reloc is against an external symbol, we do
2609                  not want to fiddle with the addend.  Otherwise, we
2610                  need to include the symbol value so that it becomes
2611                  an addend for the dynamic reloc.  */
2612               if (! relocate)
2613                 continue;
2614             }
2615           break;
2616
2617         case R_386_TLS_IE:
2618           if (info->shared)
2619             {
2620               Elf_Internal_Rela outrel;
2621               bfd_byte *loc;
2622               asection *sreloc;
2623
2624               outrel.r_offset = rel->r_offset
2625                                 + input_section->output_section->vma
2626                                 + input_section->output_offset;
2627               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2628               sreloc = elf_section_data (input_section)->sreloc;
2629               if (sreloc == NULL)
2630                 abort ();
2631               loc = sreloc->contents;
2632               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2633               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2634             }
2635           /* Fall through */
2636
2637         case R_386_TLS_GD:
2638         case R_386_TLS_GOTDESC:
2639         case R_386_TLS_DESC_CALL:
2640         case R_386_TLS_IE_32:
2641         case R_386_TLS_GOTIE:
2642           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2643           tls_type = GOT_UNKNOWN;
2644           if (h == NULL && local_got_offsets)
2645             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2646           else if (h != NULL)
2647             {
2648               tls_type = elf_i386_hash_entry(h)->tls_type;
2649               if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2650                 r_type = R_386_TLS_LE_32;
2651             }
2652           if (tls_type == GOT_TLS_IE)
2653             tls_type = GOT_TLS_IE_NEG;
2654           if (r_type == R_386_TLS_GD
2655               || r_type == R_386_TLS_GOTDESC
2656               || r_type == R_386_TLS_DESC_CALL)
2657             {
2658               if (tls_type == GOT_TLS_IE_POS)
2659                 r_type = R_386_TLS_GOTIE;
2660               else if (tls_type & GOT_TLS_IE)
2661                 r_type = R_386_TLS_IE_32;
2662             }
2663
2664           if (r_type == R_386_TLS_LE_32)
2665             {
2666               BFD_ASSERT (! unresolved_reloc);
2667               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2668                 {
2669                   unsigned int val, type;
2670                   bfd_vma roff;
2671
2672                   /* GD->LE transition.  */
2673                   BFD_ASSERT (rel->r_offset >= 2);
2674                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2675                   BFD_ASSERT (type == 0x8d || type == 0x04);
2676                   BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2677                   BFD_ASSERT (bfd_get_8 (input_bfd,
2678                                          contents + rel->r_offset + 4)
2679                               == 0xe8);
2680                   BFD_ASSERT (rel + 1 < relend);
2681                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2682                   roff = rel->r_offset + 5;
2683                   val = bfd_get_8 (input_bfd,
2684                                    contents + rel->r_offset - 1);
2685                   if (type == 0x04)
2686                     {
2687                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2688                          Change it into:
2689                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2690                          (6 byte form of subl).  */
2691                       BFD_ASSERT (rel->r_offset >= 3);
2692                       BFD_ASSERT (bfd_get_8 (input_bfd,
2693                                              contents + rel->r_offset - 3)
2694                                   == 0x8d);
2695                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2696                       memcpy (contents + rel->r_offset - 3,
2697                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2698                     }
2699                   else
2700                     {
2701                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2702                       if (rel->r_offset + 10 <= input_section->size
2703                           && bfd_get_8 (input_bfd,
2704                                         contents + rel->r_offset + 9) == 0x90)
2705                         {
2706                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2707                              Change it into:
2708                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2709                              (6 byte form of subl).  */
2710                           memcpy (contents + rel->r_offset - 2,
2711                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2712                           roff = rel->r_offset + 6;
2713                         }
2714                       else
2715                         {
2716                           /* leal foo(%reg), %eax; call ___tls_get_addr
2717                              Change it into:
2718                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2719                              (5 byte form of subl).  */
2720                           memcpy (contents + rel->r_offset - 2,
2721                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2722                         }
2723                     }
2724                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2725                               contents + roff);
2726                   /* Skip R_386_PLT32.  */
2727                   rel++;
2728                   continue;
2729                 }
2730               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
2731                 {
2732                   /* GDesc -> LE transition.
2733                      It's originally something like:
2734                      leal x@tlsdesc(%ebx), %eax
2735
2736                      leal x@ntpoff, %eax
2737
2738                      Registers other than %eax may be set up here.  */
2739
2740                   unsigned int val, type;
2741                   bfd_vma roff;
2742
2743                   /* First, make sure it's a leal adding ebx to a
2744                      32-bit offset into any register, although it's
2745                      probably almost always going to be eax.  */
2746                   roff = rel->r_offset;
2747                   BFD_ASSERT (roff >= 2);
2748                   type = bfd_get_8 (input_bfd, contents + roff - 2);
2749                   BFD_ASSERT (type == 0x8d);
2750                   val = bfd_get_8 (input_bfd, contents + roff - 1);
2751                   BFD_ASSERT ((val & 0xc7) == 0x83);
2752                   BFD_ASSERT (roff + 4 <= input_section->size);
2753
2754                   /* Now modify the instruction as appropriate.  */
2755                   /* aoliva FIXME: remove the above and xor the byte
2756                      below with 0x86.  */
2757                   bfd_put_8 (output_bfd, val ^ 0x86,
2758                              contents + roff - 1);
2759                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2760                               contents + roff);
2761                   continue;
2762                 }
2763               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
2764                 {
2765                   /* GDesc -> LE transition.
2766                      It's originally:
2767                      call *(%eax)
2768                      Turn it into:
2769                      nop; nop  */
2770
2771                   unsigned int val, type;
2772                   bfd_vma roff;
2773
2774                   /* First, make sure it's a call *(%eax).  */
2775                   roff = rel->r_offset;
2776                   BFD_ASSERT (roff + 2 <= input_section->size);
2777                   type = bfd_get_8 (input_bfd, contents + roff);
2778                   BFD_ASSERT (type == 0xff);
2779                   val = bfd_get_8 (input_bfd, contents + roff + 1);
2780                   BFD_ASSERT (val == 0x10);
2781
2782                   /* Now modify the instruction as appropriate.  Use
2783                      xchg %ax,%ax instead of 2 nops.  */
2784                   bfd_put_8 (output_bfd, 0x66, contents + roff);
2785                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2786                   continue;
2787                 }
2788               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2789                 {
2790                   unsigned int val, type;
2791
2792                   /* IE->LE transition:
2793                      Originally it can be one of:
2794                      movl foo, %eax
2795                      movl foo, %reg
2796                      addl foo, %reg
2797                      We change it into:
2798                      movl $foo, %eax
2799                      movl $foo, %reg
2800                      addl $foo, %reg.  */
2801                   BFD_ASSERT (rel->r_offset >= 1);
2802                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2803                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2804                   if (val == 0xa1)
2805                     {
2806                       /* movl foo, %eax.  */
2807                       bfd_put_8 (output_bfd, 0xb8,
2808                                  contents + rel->r_offset - 1);
2809                     }
2810                   else
2811                     {
2812                       BFD_ASSERT (rel->r_offset >= 2);
2813                       type = bfd_get_8 (input_bfd,
2814                                         contents + rel->r_offset - 2);
2815                       switch (type)
2816                         {
2817                         case 0x8b:
2818                           /* movl */
2819                           BFD_ASSERT ((val & 0xc7) == 0x05);
2820                           bfd_put_8 (output_bfd, 0xc7,
2821                                      contents + rel->r_offset - 2);
2822                           bfd_put_8 (output_bfd,
2823                                      0xc0 | ((val >> 3) & 7),
2824                                      contents + rel->r_offset - 1);
2825                           break;
2826                         case 0x03:
2827                           /* addl */
2828                           BFD_ASSERT ((val & 0xc7) == 0x05);
2829                           bfd_put_8 (output_bfd, 0x81,
2830                                      contents + rel->r_offset - 2);
2831                           bfd_put_8 (output_bfd,
2832                                      0xc0 | ((val >> 3) & 7),
2833                                      contents + rel->r_offset - 1);
2834                           break;
2835                         default:
2836                           BFD_FAIL ();
2837                           break;
2838                         }
2839                     }
2840                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2841                               contents + rel->r_offset);
2842                   continue;
2843                 }
2844               else
2845                 {
2846                   unsigned int val, type;
2847
2848                   /* {IE_32,GOTIE}->LE transition:
2849                      Originally it can be one of:
2850                      subl foo(%reg1), %reg2
2851                      movl foo(%reg1), %reg2
2852                      addl foo(%reg1), %reg2
2853                      We change it into:
2854                      subl $foo, %reg2
2855                      movl $foo, %reg2 (6 byte form)
2856                      addl $foo, %reg2.  */
2857                   BFD_ASSERT (rel->r_offset >= 2);
2858                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2859                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2860                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2861                   BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2862                   if (type == 0x8b)
2863                     {
2864                       /* movl */
2865                       bfd_put_8 (output_bfd, 0xc7,
2866                                  contents + rel->r_offset - 2);
2867                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2868                                  contents + rel->r_offset - 1);
2869                     }
2870                   else if (type == 0x2b)
2871                     {
2872                       /* subl */
2873                       bfd_put_8 (output_bfd, 0x81,
2874                                  contents + rel->r_offset - 2);
2875                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2876                                  contents + rel->r_offset - 1);
2877                     }
2878                   else if (type == 0x03)
2879                     {
2880                       /* addl */
2881                       bfd_put_8 (output_bfd, 0x81,
2882                                  contents + rel->r_offset - 2);
2883                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2884                                  contents + rel->r_offset - 1);
2885                     }
2886                   else
2887                     BFD_FAIL ();
2888                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2889                     bfd_put_32 (output_bfd, -tpoff (info, relocation),
2890                                 contents + rel->r_offset);
2891                   else
2892                     bfd_put_32 (output_bfd, tpoff (info, relocation),
2893                                 contents + rel->r_offset);
2894                   continue;
2895                 }
2896             }
2897
2898           if (htab->sgot == NULL)
2899             abort ();
2900
2901           if (h != NULL)
2902             {
2903               off = h->got.offset;
2904               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
2905             }
2906           else
2907             {
2908               if (local_got_offsets == NULL)
2909                 abort ();
2910
2911               off = local_got_offsets[r_symndx];
2912               offplt = local_tlsdesc_gotents[r_symndx];
2913             }
2914
2915           if ((off & 1) != 0)
2916             off &= ~1;
2917           else
2918             {
2919               Elf_Internal_Rela outrel;
2920               bfd_byte *loc;
2921               int dr_type, indx;
2922               asection *sreloc;
2923
2924               if (htab->srelgot == NULL)
2925                 abort ();
2926
2927               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2928
2929               if (GOT_TLS_GDESC_P (tls_type))
2930                 {
2931                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
2932                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
2933                               <= htab->sgotplt->size);
2934                   outrel.r_offset = (htab->sgotplt->output_section->vma
2935                                      + htab->sgotplt->output_offset
2936                                      + offplt
2937                                      + htab->sgotplt_jump_table_size);
2938                   sreloc = htab->srelplt;
2939                   loc = sreloc->contents;
2940                   loc += (htab->next_tls_desc_index++
2941                           * sizeof (Elf32_External_Rel));
2942                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
2943                               <= sreloc->contents + sreloc->size);
2944                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2945                   if (indx == 0)
2946                     {
2947                       BFD_ASSERT (! unresolved_reloc);
2948                       bfd_put_32 (output_bfd,
2949                                   relocation - dtpoff_base (info),
2950                                   htab->sgotplt->contents + offplt
2951                                   + htab->sgotplt_jump_table_size + 4);
2952                     }
2953                   else
2954                     {
2955                       bfd_put_32 (output_bfd, 0,
2956                                   htab->sgotplt->contents + offplt
2957                                   + htab->sgotplt_jump_table_size + 4);
2958                     }
2959                 }
2960
2961               sreloc = htab->srelgot;
2962
2963               outrel.r_offset = (htab->sgot->output_section->vma
2964                                  + htab->sgot->output_offset + off);
2965
2966               if (GOT_TLS_GD_P (tls_type))
2967                 dr_type = R_386_TLS_DTPMOD32;
2968               else if (GOT_TLS_GDESC_P (tls_type))
2969                 goto dr_done;
2970               else if (tls_type == GOT_TLS_IE_POS)
2971                 dr_type = R_386_TLS_TPOFF;
2972               else
2973                 dr_type = R_386_TLS_TPOFF32;
2974
2975               if (dr_type == R_386_TLS_TPOFF && indx == 0)
2976                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2977                             htab->sgot->contents + off);
2978               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2979                 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
2980                             htab->sgot->contents + off);
2981               else if (dr_type != R_386_TLS_DESC)
2982                 bfd_put_32 (output_bfd, 0,
2983                             htab->sgot->contents + off);
2984               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2985
2986               loc = sreloc->contents;
2987               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2988               BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
2989                           <= sreloc->contents + sreloc->size);
2990               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2991
2992               if (GOT_TLS_GD_P (tls_type))
2993                 {
2994                   if (indx == 0)
2995                     {
2996                       BFD_ASSERT (! unresolved_reloc);
2997                       bfd_put_32 (output_bfd,
2998                                   relocation - dtpoff_base (info),
2999                                   htab->sgot->contents + off + 4);
3000                     }
3001                   else
3002                     {
3003                       bfd_put_32 (output_bfd, 0,
3004                                   htab->sgot->contents + off + 4);
3005                       outrel.r_info = ELF32_R_INFO (indx,
3006                                                     R_386_TLS_DTPOFF32);
3007                       outrel.r_offset += 4;
3008                       sreloc->reloc_count++;
3009                       loc += sizeof (Elf32_External_Rel);
3010                       BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3011                                   <= sreloc->contents + sreloc->size);
3012                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3013                     }
3014                 }
3015               else if (tls_type == GOT_TLS_IE_BOTH)
3016                 {
3017                   bfd_put_32 (output_bfd,
3018                               indx == 0 ? relocation - dtpoff_base (info) : 0,
3019                               htab->sgot->contents + off + 4);
3020                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3021                   outrel.r_offset += 4;
3022                   sreloc->reloc_count++;
3023                   loc += sizeof (Elf32_External_Rel);
3024                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3025                 }
3026
3027             dr_done:
3028               if (h != NULL)
3029                 h->got.offset |= 1;
3030               else
3031                 local_got_offsets[r_symndx] |= 1;
3032             }
3033
3034           if (off >= (bfd_vma) -2
3035               && ! GOT_TLS_GDESC_P (tls_type))
3036             abort ();
3037           if (r_type == R_386_TLS_GOTDESC
3038               || r_type == R_386_TLS_DESC_CALL)
3039             {
3040               relocation = htab->sgotplt_jump_table_size + offplt;
3041               unresolved_reloc = FALSE;
3042             }
3043           else if (r_type == ELF32_R_TYPE (rel->r_info))
3044             {
3045               bfd_vma g_o_t = htab->sgotplt->output_section->vma
3046                               + htab->sgotplt->output_offset;
3047               relocation = htab->sgot->output_section->vma
3048                 + htab->sgot->output_offset + off - g_o_t;
3049               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3050                   && tls_type == GOT_TLS_IE_BOTH)
3051                 relocation += 4;
3052               if (r_type == R_386_TLS_IE)
3053                 relocation += g_o_t;
3054               unresolved_reloc = FALSE;
3055             }
3056           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3057             {
3058               unsigned int val, type;
3059               bfd_vma roff;
3060
3061               /* GD->IE transition.  */
3062               BFD_ASSERT (rel->r_offset >= 2);
3063               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3064               BFD_ASSERT (type == 0x8d || type == 0x04);
3065               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
3066               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3067                           == 0xe8);
3068               BFD_ASSERT (rel + 1 < relend);
3069               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
3070               roff = rel->r_offset - 3;
3071               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3072               if (type == 0x04)
3073                 {
3074                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3075                      Change it into:
3076                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
3077                   BFD_ASSERT (rel->r_offset >= 3);
3078                   BFD_ASSERT (bfd_get_8 (input_bfd,
3079                                          contents + rel->r_offset - 3)
3080                               == 0x8d);
3081                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
3082                   val >>= 3;
3083                 }
3084               else
3085                 {
3086                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3087                      Change it into:
3088                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
3089                   BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
3090                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3091                   BFD_ASSERT (bfd_get_8 (input_bfd,
3092                                          contents + rel->r_offset + 9)
3093                               == 0x90);
3094                   roff = rel->r_offset - 2;
3095                 }
3096               memcpy (contents + roff,
3097                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3098               contents[roff + 7] = 0x80 | (val & 7);
3099               /* If foo is used only with foo@gotntpoff(%reg) and
3100                  foo@indntpoff, but not with foo@gottpoff(%reg), change
3101                  subl $foo@gottpoff(%reg), %eax
3102                  into:
3103                  addl $foo@gotntpoff(%reg), %eax.  */
3104               if (tls_type == GOT_TLS_IE_POS)
3105                 contents[roff + 6] = 0x03;
3106               bfd_put_32 (output_bfd,
3107                           htab->sgot->output_section->vma
3108                           + htab->sgot->output_offset + off
3109                           - htab->sgotplt->output_section->vma
3110                           - htab->sgotplt->output_offset,
3111                           contents + roff + 8);
3112               /* Skip R_386_PLT32.  */
3113               rel++;
3114               continue;
3115             }
3116           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3117             {
3118               /* GDesc -> IE transition.
3119                  It's originally something like:
3120                  leal x@tlsdesc(%ebx), %eax
3121
3122                  Change it to:
3123                  movl x@gotntpoff(%ebx), %eax # before nop; nop
3124                  or:
3125                  movl x@gottpoff(%ebx), %eax # before negl %eax
3126
3127                  Registers other than %eax may be set up here.  */
3128
3129               unsigned int val, type;
3130               bfd_vma roff;
3131
3132               /* First, make sure it's a leal adding ebx to a 32-bit
3133                  offset into any register, although it's probably
3134                  almost always going to be eax.  */
3135               roff = rel->r_offset;
3136               BFD_ASSERT (roff >= 2);
3137               type = bfd_get_8 (input_bfd, contents + roff - 2);
3138               BFD_ASSERT (type == 0x8d);
3139               val = bfd_get_8 (input_bfd, contents + roff - 1);
3140               BFD_ASSERT ((val & 0xc7) == 0x83);
3141               BFD_ASSERT (roff + 4 <= input_section->size);
3142
3143               /* Now modify the instruction as appropriate.  */
3144               /* To turn a leal into a movl in the form we use it, it
3145                  suffices to change the first byte from 0x8d to 0x8b.
3146                  aoliva FIXME: should we decide to keep the leal, all
3147                  we have to do is remove the statement below, and
3148                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
3149               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3150
3151               if (tls_type == GOT_TLS_IE_BOTH)
3152                 off += 4;
3153
3154               bfd_put_32 (output_bfd,
3155                           htab->sgot->output_section->vma
3156                           + htab->sgot->output_offset + off
3157                           - htab->sgotplt->output_section->vma
3158                           - htab->sgotplt->output_offset,
3159                           contents + roff);
3160               continue;
3161             }
3162           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3163             {
3164               /* GDesc -> IE transition.
3165                  It's originally:
3166                  call *(%eax)
3167
3168                  Change it to:
3169                  nop; nop
3170                  or
3171                  negl %eax
3172                  depending on how we transformed the TLS_GOTDESC above.
3173               */
3174
3175               unsigned int val, type;
3176               bfd_vma roff;
3177
3178               /* First, make sure it's a call *(%eax).  */
3179               roff = rel->r_offset;
3180               BFD_ASSERT (roff + 2 <= input_section->size);
3181               type = bfd_get_8 (input_bfd, contents + roff);
3182               BFD_ASSERT (type == 0xff);
3183               val = bfd_get_8 (input_bfd, contents + roff + 1);
3184               BFD_ASSERT (val == 0x10);
3185
3186               /* Now modify the instruction as appropriate.  */
3187               if (tls_type != GOT_TLS_IE_NEG)
3188                 {
3189                   /* xchg %ax,%ax */
3190                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3191                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3192                 }
3193               else
3194                 {
3195                   /* negl %eax */
3196                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
3197                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
3198                 }
3199
3200               continue;
3201             }
3202           else
3203             BFD_ASSERT (FALSE);
3204           break;
3205
3206         case R_386_TLS_LDM:
3207           if (! info->shared)
3208             {
3209               unsigned int val;
3210
3211               /* LD->LE transition:
3212                  Ensure it is:
3213                  leal foo(%reg), %eax; call ___tls_get_addr.
3214                  We change it into:
3215                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
3216               BFD_ASSERT (rel->r_offset >= 2);
3217               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
3218                           == 0x8d);
3219               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3220               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3221               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
3222               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3223                           == 0xe8);
3224               BFD_ASSERT (rel + 1 < relend);
3225               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
3226               memcpy (contents + rel->r_offset - 2,
3227                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3228               /* Skip R_386_PLT32.  */
3229               rel++;
3230               continue;
3231             }
3232
3233           if (htab->sgot == NULL)
3234             abort ();
3235
3236           off = htab->tls_ldm_got.offset;
3237           if (off & 1)
3238             off &= ~1;
3239           else
3240             {
3241               Elf_Internal_Rela outrel;
3242               bfd_byte *loc;
3243
3244               if (htab->srelgot == NULL)
3245                 abort ();
3246
3247               outrel.r_offset = (htab->sgot->output_section->vma
3248                                  + htab->sgot->output_offset + off);
3249
3250               bfd_put_32 (output_bfd, 0,
3251                           htab->sgot->contents + off);
3252               bfd_put_32 (output_bfd, 0,
3253                           htab->sgot->contents + off + 4);
3254               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
3255               loc = htab->srelgot->contents;
3256               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3257               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3258               htab->tls_ldm_got.offset |= 1;
3259             }
3260           relocation = htab->sgot->output_section->vma
3261                        + htab->sgot->output_offset + off
3262                        - htab->sgotplt->output_section->vma
3263                        - htab->sgotplt->output_offset;
3264           unresolved_reloc = FALSE;
3265           break;
3266
3267         case R_386_TLS_LDO_32:
3268           if (info->shared || (input_section->flags & SEC_CODE) == 0)
3269             relocation -= dtpoff_base (info);
3270           else
3271             /* When converting LDO to LE, we must negate.  */
3272             relocation = -tpoff (info, relocation);
3273           break;
3274
3275         case R_386_TLS_LE_32:
3276         case R_386_TLS_LE:
3277           if (info->shared)
3278             {
3279               Elf_Internal_Rela outrel;
3280               asection *sreloc;
3281               bfd_byte *loc;
3282               int indx;
3283
3284               outrel.r_offset = rel->r_offset
3285                                 + input_section->output_section->vma
3286                                 + input_section->output_offset;
3287               if (h != NULL && h->dynindx != -1)
3288                 indx = h->dynindx;
3289               else
3290                 indx = 0;
3291               if (r_type == R_386_TLS_LE_32)
3292                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3293               else
3294                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3295               sreloc = elf_section_data (input_section)->sreloc;
3296               if (sreloc == NULL)
3297                 abort ();
3298               loc = sreloc->contents;
3299               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3300               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3301               if (indx)
3302                 continue;
3303               else if (r_type == R_386_TLS_LE_32)
3304                 relocation = dtpoff_base (info) - relocation;
3305               else
3306                 relocation -= dtpoff_base (info);
3307             }
3308           else if (r_type == R_386_TLS_LE_32)
3309             relocation = tpoff (info, relocation);
3310           else
3311             relocation = -tpoff (info, relocation);
3312           break;
3313
3314         default:
3315           break;
3316         }
3317
3318       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3319          because such sections are not SEC_ALLOC and thus ld.so will
3320          not process them.  */
3321       if (unresolved_reloc
3322           && !((input_section->flags & SEC_DEBUGGING) != 0
3323                && h->def_dynamic))
3324         {
3325           (*_bfd_error_handler)
3326             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3327              input_bfd,
3328              input_section,
3329              (long) rel->r_offset,
3330              howto->name,
3331              h->root.root.string);
3332           return FALSE;
3333         }
3334
3335       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3336                                     contents, rel->r_offset,
3337                                     relocation, 0);
3338
3339       if (r != bfd_reloc_ok)
3340         {
3341           const char *name;
3342
3343           if (h != NULL)
3344             name = h->root.root.string;
3345           else
3346             {
3347               name = bfd_elf_string_from_elf_section (input_bfd,
3348                                                       symtab_hdr->sh_link,
3349                                                       sym->st_name);
3350               if (name == NULL)
3351                 return FALSE;
3352               if (*name == '\0')
3353                 name = bfd_section_name (input_bfd, sec);
3354             }
3355
3356           if (r == bfd_reloc_overflow)
3357             {
3358               if (! ((*info->callbacks->reloc_overflow)
3359                      (info, (h ? &h->root : NULL), name, howto->name,
3360                       (bfd_vma) 0, input_bfd, input_section,
3361                       rel->r_offset)))
3362                 return FALSE;
3363             }
3364           else
3365             {
3366               (*_bfd_error_handler)
3367                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3368                  input_bfd, input_section,
3369                  (long) rel->r_offset, name, (int) r);
3370               return FALSE;
3371             }
3372         }
3373     }
3374
3375   return TRUE;
3376 }
3377
3378 /* Finish up dynamic symbol handling.  We set the contents of various
3379    dynamic sections here.  */
3380
3381 static bfd_boolean
3382 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3383                                 struct bfd_link_info *info,
3384                                 struct elf_link_hash_entry *h,
3385                                 Elf_Internal_Sym *sym)
3386 {
3387   struct elf_i386_link_hash_table *htab;
3388
3389   htab = elf_i386_hash_table (info);
3390
3391   if (h->plt.offset != (bfd_vma) -1)
3392     {
3393       bfd_vma plt_index;
3394       bfd_vma got_offset;
3395       Elf_Internal_Rela rel;
3396       bfd_byte *loc;
3397
3398       /* This symbol has an entry in the procedure linkage table.  Set
3399          it up.  */
3400
3401       if (h->dynindx == -1
3402           || htab->splt == NULL
3403           || htab->sgotplt == NULL
3404           || htab->srelplt == NULL)
3405         abort ();
3406
3407       /* Get the index in the procedure linkage table which
3408          corresponds to this symbol.  This is the index of this symbol
3409          in all the symbols for which we are making plt entries.  The
3410          first entry in the procedure linkage table is reserved.  */
3411       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3412
3413       /* Get the offset into the .got table of the entry that
3414          corresponds to this function.  Each .got entry is 4 bytes.
3415          The first three are reserved.  */
3416       got_offset = (plt_index + 3) * 4;
3417
3418       /* Fill in the entry in the procedure linkage table.  */
3419       if (! info->shared)
3420         {
3421           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3422                   PLT_ENTRY_SIZE);
3423           bfd_put_32 (output_bfd,
3424                       (htab->sgotplt->output_section->vma
3425                        + htab->sgotplt->output_offset
3426                        + got_offset),
3427                       htab->splt->contents + h->plt.offset + 2);
3428
3429           if (htab->is_vxworks)
3430             {
3431               int s, k, reloc_index;
3432
3433               /* Create the R_386_32 relocation referencing the GOT
3434                  for this PLT entry.  */
3435
3436               /* S: Current slot number (zero-based).  */
3437               s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3438               /* K: Number of relocations for PLTResolve. */
3439               if (info->shared)
3440                 k = PLTRESOLVE_RELOCS_SHLIB;
3441               else
3442                 k = PLTRESOLVE_RELOCS;
3443               /* Skip the PLTresolve relocations, and the relocations for
3444                  the other PLT slots. */
3445               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3446               loc = (htab->srelplt2->contents + reloc_index
3447                      * sizeof (Elf32_External_Rel));
3448
3449               rel.r_offset = (htab->splt->output_section->vma
3450                               + htab->splt->output_offset
3451                               + h->plt.offset + 2),
3452               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3453               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3454
3455               /* Create the R_386_32 relocation referencing the beginning of
3456                  the PLT for this GOT entry.  */
3457               rel.r_offset = (htab->sgotplt->output_section->vma
3458                               + htab->sgotplt->output_offset
3459                               + got_offset);
3460               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3461               bfd_elf32_swap_reloc_out (output_bfd, &rel,
3462               loc + sizeof (Elf32_External_Rel));
3463             }
3464         }
3465       else
3466         {
3467           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3468                   PLT_ENTRY_SIZE);
3469           bfd_put_32 (output_bfd, got_offset,
3470                       htab->splt->contents + h->plt.offset + 2);
3471         }
3472
3473       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3474                   htab->splt->contents + h->plt.offset + 7);
3475       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3476                   htab->splt->contents + h->plt.offset + 12);
3477
3478       /* Fill in the entry in the global offset table.  */
3479       bfd_put_32 (output_bfd,
3480                   (htab->splt->output_section->vma
3481                    + htab->splt->output_offset
3482                    + h->plt.offset
3483                    + 6),
3484                   htab->sgotplt->contents + got_offset);
3485
3486       /* Fill in the entry in the .rel.plt section.  */
3487       rel.r_offset = (htab->sgotplt->output_section->vma
3488                       + htab->sgotplt->output_offset
3489                       + got_offset);
3490       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3491       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3492       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3493
3494       if (!h->def_regular)
3495         {
3496           /* Mark the symbol as undefined, rather than as defined in
3497              the .plt section.  Leave the value if there were any
3498              relocations where pointer equality matters (this is a clue
3499              for the dynamic linker, to make function pointer
3500              comparisons work between an application and shared
3501              library), otherwise set it to zero.  If a function is only
3502              called from a binary, there is no need to slow down
3503              shared libraries because of that.  */
3504           sym->st_shndx = SHN_UNDEF;
3505           if (!h->pointer_equality_needed)
3506             sym->st_value = 0;
3507         }
3508     }
3509
3510   if (h->got.offset != (bfd_vma) -1
3511       && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
3512       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3513     {
3514       Elf_Internal_Rela rel;
3515       bfd_byte *loc;
3516
3517       /* This symbol has an entry in the global offset table.  Set it
3518          up.  */
3519
3520       if (htab->sgot == NULL || htab->srelgot == NULL)
3521         abort ();
3522
3523       rel.r_offset = (htab->sgot->output_section->vma
3524                       + htab->sgot->output_offset
3525                       + (h->got.offset & ~(bfd_vma) 1));
3526
3527       /* If this is a static link, or it is a -Bsymbolic link and the
3528          symbol is defined locally or was forced to be local because
3529          of a version file, we just want to emit a RELATIVE reloc.
3530          The entry in the global offset table will already have been
3531          initialized in the relocate_section function.  */
3532       if (info->shared
3533           && SYMBOL_REFERENCES_LOCAL (info, h))
3534         {
3535           BFD_ASSERT((h->got.offset & 1) != 0);
3536           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3537         }
3538       else
3539         {
3540           BFD_ASSERT((h->got.offset & 1) == 0);
3541           bfd_put_32 (output_bfd, (bfd_vma) 0,
3542                       htab->sgot->contents + h->got.offset);
3543           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3544         }
3545
3546       loc = htab->srelgot->contents;
3547       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3548       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3549     }
3550
3551   if (h->needs_copy)
3552     {
3553       Elf_Internal_Rela rel;
3554       bfd_byte *loc;
3555
3556       /* This symbol needs a copy reloc.  Set it up.  */
3557
3558       if (h->dynindx == -1
3559           || (h->root.type != bfd_link_hash_defined
3560               && h->root.type != bfd_link_hash_defweak)
3561           || htab->srelbss == NULL)
3562         abort ();
3563
3564       rel.r_offset = (h->root.u.def.value
3565                       + h->root.u.def.section->output_section->vma
3566                       + h->root.u.def.section->output_offset);
3567       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3568       loc = htab->srelbss->contents;
3569       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3570       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3571     }
3572
3573   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3574      On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3575      is relative to the ".got" section.  */
3576   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3577       || (!htab->is_vxworks && h == htab->elf.hgot))
3578     sym->st_shndx = SHN_ABS;
3579
3580   return TRUE;
3581 }
3582
3583 /* Used to decide how to sort relocs in an optimal manner for the
3584    dynamic linker, before writing them out.  */
3585
3586 static enum elf_reloc_type_class
3587 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3588 {
3589   switch (ELF32_R_TYPE (rela->r_info))
3590     {
3591     case R_386_RELATIVE:
3592       return reloc_class_relative;
3593     case R_386_JUMP_SLOT:
3594       return reloc_class_plt;
3595     case R_386_COPY:
3596       return reloc_class_copy;
3597     default:
3598       return reloc_class_normal;
3599     }
3600 }
3601
3602 /* Finish up the dynamic sections.  */
3603
3604 static bfd_boolean
3605 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3606                                   struct bfd_link_info *info)
3607 {
3608   struct elf_i386_link_hash_table *htab;
3609   bfd *dynobj;
3610   asection *sdyn;
3611
3612   htab = elf_i386_hash_table (info);
3613   dynobj = htab->elf.dynobj;
3614   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3615
3616   if (htab->elf.dynamic_sections_created)
3617     {
3618       Elf32_External_Dyn *dyncon, *dynconend;
3619
3620       if (sdyn == NULL || htab->sgot == NULL)
3621         abort ();
3622
3623       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3624       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3625       for (; dyncon < dynconend; dyncon++)
3626         {
3627           Elf_Internal_Dyn dyn;
3628           asection *s;
3629
3630           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3631
3632           switch (dyn.d_tag)
3633             {
3634             default:
3635               continue;
3636
3637             case DT_PLTGOT:
3638               s = htab->sgotplt;
3639               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3640               break;
3641
3642             case DT_JMPREL:
3643               s = htab->srelplt;
3644               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3645               break;
3646
3647             case DT_PLTRELSZ:
3648               s = htab->srelplt;
3649               dyn.d_un.d_val = s->size;
3650               break;
3651
3652             case DT_RELSZ:
3653               /* My reading of the SVR4 ABI indicates that the
3654                  procedure linkage table relocs (DT_JMPREL) should be
3655                  included in the overall relocs (DT_REL).  This is
3656                  what Solaris does.  However, UnixWare can not handle
3657                  that case.  Therefore, we override the DT_RELSZ entry
3658                  here to make it not include the JMPREL relocs.  */
3659               s = htab->srelplt;
3660               if (s == NULL)
3661                 continue;
3662               dyn.d_un.d_val -= s->size;
3663               break;
3664
3665             case DT_REL:
3666               /* We may not be using the standard ELF linker script.
3667                  If .rel.plt is the first .rel section, we adjust
3668                  DT_REL to not include it.  */
3669               s = htab->srelplt;
3670               if (s == NULL)
3671                 continue;
3672               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3673                 continue;
3674               dyn.d_un.d_ptr += s->size;
3675               break;
3676             }
3677
3678           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3679         }
3680
3681       /* Fill in the first entry in the procedure linkage table.  */
3682       if (htab->splt && htab->splt->size > 0)
3683         {
3684           if (info->shared)
3685             {
3686               memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3687                       sizeof (elf_i386_pic_plt0_entry));
3688               memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3689                       htab->plt0_pad_byte,
3690                       PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3691             }
3692           else
3693             {
3694               memcpy (htab->splt->contents, elf_i386_plt0_entry,
3695                       sizeof(elf_i386_plt0_entry));
3696               memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3697                       htab->plt0_pad_byte,
3698                       PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
3699               bfd_put_32 (output_bfd,
3700                           (htab->sgotplt->output_section->vma
3701                            + htab->sgotplt->output_offset
3702                            + 4),
3703                           htab->splt->contents + 2);
3704               bfd_put_32 (output_bfd,
3705                           (htab->sgotplt->output_section->vma
3706                            + htab->sgotplt->output_offset
3707                            + 8),
3708                           htab->splt->contents + 8);
3709
3710               if (htab->is_vxworks)
3711                 {
3712                   Elf_Internal_Rela rel;
3713
3714                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3715                      On IA32 we use REL relocations so the addend goes in
3716                      the PLT directly.  */
3717                   rel.r_offset = (htab->splt->output_section->vma
3718                                   + htab->splt->output_offset
3719                                   + 2);
3720                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3721                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3722                                             htab->srelplt2->contents);
3723                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
3724                   rel.r_offset = (htab->splt->output_section->vma
3725                                   + htab->splt->output_offset
3726                                   + 8);
3727                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3728                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3729                                             htab->srelplt2->contents +
3730                                             sizeof (Elf32_External_Rel));
3731                 }
3732             }
3733
3734           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3735              really seem like the right value.  */
3736           elf_section_data (htab->splt->output_section)
3737             ->this_hdr.sh_entsize = 4;
3738
3739           /* Correct the .rel.plt.unloaded relocations.  */
3740           if (htab->is_vxworks && !info->shared)
3741             {
3742               int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
3743               unsigned char *p;
3744
3745               p = htab->srelplt2->contents;
3746               if (info->shared)
3747                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
3748               else
3749                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
3750
3751               for (; num_plts; num_plts--)
3752                 {
3753                   Elf_Internal_Rela rel;
3754                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3755                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3756                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3757                   p += sizeof (Elf32_External_Rel);
3758
3759                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3760                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3761                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3762                   p += sizeof (Elf32_External_Rel);
3763                 }
3764             }
3765         }
3766     }
3767
3768   if (htab->sgotplt)
3769     {
3770       /* Fill in the first three entries in the global offset table.  */
3771       if (htab->sgotplt->size > 0)
3772         {
3773           bfd_put_32 (output_bfd,
3774                       (sdyn == NULL ? 0
3775                        : sdyn->output_section->vma + sdyn->output_offset),
3776                       htab->sgotplt->contents);
3777           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3778           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3779         }
3780
3781       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3782     }
3783
3784   if (htab->sgot && htab->sgot->size > 0)
3785     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3786
3787   return TRUE;
3788 }
3789
3790 /* Return address for Ith PLT stub in section PLT, for relocation REL
3791    or (bfd_vma) -1 if it should not be included.  */
3792
3793 static bfd_vma
3794 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
3795                       const arelent *rel ATTRIBUTE_UNUSED)
3796 {
3797   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3798 }
3799
3800 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
3801
3802 static bfd_boolean
3803 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
3804 {
3805   if (h->plt.offset != (bfd_vma) -1
3806       && !h->def_regular
3807       && !h->pointer_equality_needed)
3808     return FALSE;
3809
3810   return _bfd_elf_hash_symbol (h);
3811 }
3812
3813 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3814 #define TARGET_LITTLE_NAME              "elf32-i386"
3815 #define ELF_ARCH                        bfd_arch_i386
3816 #define ELF_MACHINE_CODE                EM_386
3817 #define ELF_MAXPAGESIZE                 0x1000
3818
3819 #define elf_backend_can_gc_sections     1
3820 #define elf_backend_can_refcount        1
3821 #define elf_backend_want_got_plt        1
3822 #define elf_backend_plt_readonly        1
3823 #define elf_backend_want_plt_sym        0
3824 #define elf_backend_got_header_size     12
3825
3826 /* Support RELA for objdump of prelink objects.  */
3827 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3828 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3829
3830 #define bfd_elf32_mkobject                    elf_i386_mkobject
3831
3832 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3833 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3834 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3835 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
3836
3837 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3838 #define elf_backend_check_relocs              elf_i386_check_relocs
3839 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3840 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3841 #define elf_backend_fake_sections             elf_i386_fake_sections
3842 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3843 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3844 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3845 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3846 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3847 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3848 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3849 #define elf_backend_relocate_section          elf_i386_relocate_section
3850 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3851 #define elf_backend_always_size_sections      elf_i386_always_size_sections
3852 #define elf_backend_omit_section_dynsym \
3853   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
3854 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
3855 #define elf_backend_hash_symbol               elf_i386_hash_symbol
3856
3857 #include "elf32-target.h"
3858
3859 /* FreeBSD support.  */
3860
3861 #undef  TARGET_LITTLE_SYM
3862 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3863 #undef  TARGET_LITTLE_NAME
3864 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3865 #undef  ELF_OSABI
3866 #define ELF_OSABI                       ELFOSABI_FREEBSD
3867
3868 /* The kernel recognizes executables as valid only if they carry a
3869    "FreeBSD" label in the ELF header.  So we put this label on all
3870    executables and (for simplicity) also all other object files.  */
3871
3872 static void
3873 elf_i386_post_process_headers (bfd *abfd,
3874                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3875 {
3876   Elf_Internal_Ehdr *i_ehdrp;
3877
3878   i_ehdrp = elf_elfheader (abfd);
3879
3880   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3881   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
3882 #ifdef OLD_FREEBSD_ABI_LABEL
3883   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3884   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3885 #endif
3886 }
3887
3888 #undef  elf_backend_post_process_headers
3889 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3890 #undef  elf32_bed
3891 #define elf32_bed                               elf32_i386_fbsd_bed
3892
3893 #include "elf32-target.h"
3894
3895 /* VxWorks support.  */
3896
3897 #undef  TARGET_LITTLE_SYM
3898 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
3899 #undef  TARGET_LITTLE_NAME
3900 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
3901 #undef  ELF_OSABI
3902
3903 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks.  */
3904
3905 static struct bfd_link_hash_table *
3906 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3907 {
3908   struct bfd_link_hash_table *ret;
3909   struct elf_i386_link_hash_table *htab;
3910
3911   ret = elf_i386_link_hash_table_create (abfd);
3912   if (ret)
3913     {
3914       htab = (struct elf_i386_link_hash_table *) ret;
3915       htab->is_vxworks = 1;
3916       htab->plt0_pad_byte = 0x90;
3917     }
3918
3919   return ret;
3920 }
3921
3922
3923 #undef  elf_backend_post_process_headers
3924 #undef bfd_elf32_bfd_link_hash_table_create
3925 #define bfd_elf32_bfd_link_hash_table_create \
3926   elf_i386_vxworks_link_hash_table_create
3927 #undef elf_backend_add_symbol_hook
3928 #define elf_backend_add_symbol_hook \
3929   elf_vxworks_add_symbol_hook
3930 #undef elf_backend_link_output_symbol_hook
3931 #define elf_backend_link_output_symbol_hook \
3932   elf_vxworks_link_output_symbol_hook
3933 #undef elf_backend_emit_relocs
3934 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
3935 #undef elf_backend_final_write_processing
3936 #define elf_backend_final_write_processing \
3937   elf_vxworks_final_write_processing
3938
3939 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3940    define it.  */
3941 #undef elf_backend_want_plt_sym
3942 #define elf_backend_want_plt_sym        1
3943
3944 #undef  elf32_bed
3945 #define elf32_bed                               elf32_i386_vxworks_bed
3946
3947 #include "elf32-target.h"