bfd/elf32-i386.c

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