contrib/binutils-2.17/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_MASK    0x0f
 586 #define GOT_TLS_IE_IE   0x10
 587 #define GOT_TLS_IE_GD   0x20
 588 #define GOT_TLS_IE_MASK 0x30
 589 #define GOT_TLS_GD_BOTH_P(type)                                         \
 590   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
 591 #define GOT_TLS_GD_P(type)                                              \
 592   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
 593 #define GOT_TLS_GDESC_P(type)                                           \
 594   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
 595 #define GOT_TLS_GD_ANY_P(type)                                          \
 596   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
 597   unsigned char tls_type;
 598
 599   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
 600      starting at the end of the jump table.  */
 601   bfd_vma tlsdesc_got;
 602 };
 603
 604 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
 605
 606 struct elf_i386_obj_tdata
 607 {
 608   struct elf_obj_tdata root;
 609
 610   /* tls_type for each local got entry.  */
 611   char *local_got_tls_type;
 612
 613   /* GOTPLT entries for TLS descriptors.  */
 614   bfd_vma *local_tlsdesc_gotent;
 615 };
 616
 617 #define elf_i386_tdata(abfd) \
 618   ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
 619
 620 #define elf_i386_local_got_tls_type(abfd) \
 621   (elf_i386_tdata (abfd)->local_got_tls_type)
 622
 623 #define elf_i386_local_tlsdesc_gotent(abfd) \
 624   (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
 625
 626 static bfd_boolean
 627 elf_i386_mkobject (bfd *abfd)
 628 {
 629   bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
 630   abfd->tdata.any = bfd_zalloc (abfd, amt);
 631   if (abfd->tdata.any == NULL)
 632     return FALSE;
 633   return TRUE;
 634 }
 635
 636 /* i386 ELF linker hash table.  */
 637
 638 struct elf_i386_link_hash_table
 639 {
 640   struct elf_link_hash_table elf;
 641
 642   /* Short-cuts to get to dynamic linker sections.  */
 643   asection *sgot;
 644   asection *sgotplt;
 645   asection *srelgot;
 646   asection *splt;
 647   asection *srelplt;
 648   asection *sdynbss;
 649   asection *srelbss;
 650
 651   /* The (unloaded but important) .rel.plt.unloaded section on VxWorks.  */
 652   asection *srelplt2;
 653
 654   /* True if the target system is VxWorks.  */
 655   int is_vxworks;
 656
 657   /* Value used to fill the last word of the first plt entry.  */
 658   bfd_byte plt0_pad_byte;
 659
 660   /* The index of the next unused R_386_TLS_DESC slot in .rel.plt.  */
 661   bfd_vma next_tls_desc_index;
 662
 663   union {
 664     bfd_signed_vma refcount;
 665     bfd_vma offset;
 666   } tls_ldm_got;
 667
 668   /* The amount of space used by the reserved portion of the sgotplt
 669      section, plus whatever space is used by the jump slots.  */
 670   bfd_vma sgotplt_jump_table_size;
 671
 672   /* Small local sym to section mapping cache.  */
 673   struct sym_sec_cache sym_sec;
 674 };
 675
 676 /* Get the i386 ELF linker hash table from a link_info structure.  */
 677
 678 #define elf_i386_hash_table(p) \
 679   ((struct elf_i386_link_hash_table *) ((p)->hash))
 680
 681 #define elf_i386_compute_jump_table_size(htab) \
 682   ((htab)->next_tls_desc_index * 4)
 683
 684 /* Create an entry in an i386 ELF linker hash table.  */
 685
 686 static struct bfd_hash_entry *
 687 link_hash_newfunc (struct bfd_hash_entry *entry,
 688                    struct bfd_hash_table *table,
 689                    const char *string)
 690 {
 691   /* Allocate the structure if it has not already been allocated by a
 692      subclass.  */
 693   if (entry == NULL)
 694     {
 695       entry = bfd_hash_allocate (table,
 696                                  sizeof (struct elf_i386_link_hash_entry));
 697       if (entry == NULL)
 698         return entry;
 699     }
 700
 701   /* Call the allocation method of the superclass.  */
 702   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 703   if (entry != NULL)
 704     {
 705       struct elf_i386_link_hash_entry *eh;
 706
 707       eh = (struct elf_i386_link_hash_entry *) entry;
 708       eh->dyn_relocs = NULL;
 709       eh->tls_type = GOT_UNKNOWN;
 710       eh->tlsdesc_got = (bfd_vma) -1;
 711     }
 712
 713   return entry;
 714 }
 715
 716 /* Create an i386 ELF linker hash table.  */
 717
 718 static struct bfd_link_hash_table *
 719 elf_i386_link_hash_table_create (bfd *abfd)
 720 {
 721   struct elf_i386_link_hash_table *ret;
 722   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
 723
 724   ret = bfd_malloc (amt);
 725   if (ret == NULL)
 726     return NULL;
 727
 728   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 729                                       sizeof (struct elf_i386_link_hash_entry)))
 730     {
 731       free (ret);
 732       return NULL;
 733     }
 734
 735   ret->sgot = NULL;
 736   ret->sgotplt = NULL;
 737   ret->srelgot = NULL;
 738   ret->splt = NULL;
 739   ret->srelplt = NULL;
 740   ret->sdynbss = NULL;
 741   ret->srelbss = NULL;
 742   ret->tls_ldm_got.refcount = 0;
 743   ret->next_tls_desc_index = 0;
 744   ret->sgotplt_jump_table_size = 0;
 745   ret->sym_sec.abfd = NULL;
 746   ret->is_vxworks = 0;
 747   ret->srelplt2 = NULL;
 748   ret->plt0_pad_byte = 0;
 749
 750   return &ret->elf.root;
 751 }
 752
 753 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
 754    shortcuts to them in our hash table.  */
 755
 756 static bfd_boolean
 757 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 758 {
 759   struct elf_i386_link_hash_table *htab;
 760
 761   if (! _bfd_elf_create_got_section (dynobj, info))
 762     return FALSE;
 763
 764   htab = elf_i386_hash_table (info);
 765   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 766   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 767   if (!htab->sgot || !htab->sgotplt)
 768     abort ();
 769
 770   htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
 771                                                (SEC_ALLOC | SEC_LOAD
 772                                                 | SEC_HAS_CONTENTS
 773                                                 | SEC_IN_MEMORY
 774                                                 | SEC_LINKER_CREATED
 775                                                 | SEC_READONLY));
 776   if (htab->srelgot == NULL
 777       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 778     return FALSE;
 779   return TRUE;
 780 }
 781
 782 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 783    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 784    hash table.  */
 785
 786 static bfd_boolean
 787 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 788 {
 789   struct elf_i386_link_hash_table *htab;
 790
 791   htab = elf_i386_hash_table (info);
 792   if (!htab->sgot && !create_got_section (dynobj, info))
 793     return FALSE;
 794
 795   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 796     return FALSE;
 797
 798   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 799   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
 800   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 801   if (!info->shared)
 802     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
 803
 804   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 805       || (!info->shared && !htab->srelbss))
 806     abort ();
 807
 808   if (htab->is_vxworks
 809       && !elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
 810     return FALSE;
 811
 812   return TRUE;
 813 }
 814
 815 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 816
 817 static void
 818 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
 819                                struct elf_link_hash_entry *dir,
 820                                struct elf_link_hash_entry *ind)
 821 {
 822   struct elf_i386_link_hash_entry *edir, *eind;
 823
 824   edir = (struct elf_i386_link_hash_entry *) dir;
 825   eind = (struct elf_i386_link_hash_entry *) ind;
 826
 827   if (eind->dyn_relocs != NULL)
 828     {
 829       if (edir->dyn_relocs != NULL)
 830         {
 831           struct elf_i386_dyn_relocs **pp;
 832           struct elf_i386_dyn_relocs *p;
 833
 834           /* Add reloc counts against the indirect sym to the direct sym
 835              list.  Merge any entries against the same section.  */
 836           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 837             {
 838               struct elf_i386_dyn_relocs *q;
 839
 840               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 841                 if (q->sec == p->sec)
 842                   {
 843                     q->pc_count += p->pc_count;
 844                     q->count += p->count;
 845                     *pp = p->next;
 846                     break;
 847                   }
 848               if (q == NULL)
 849                 pp = &p->next;
 850             }
 851           *pp = edir->dyn_relocs;
 852         }
 853
 854       edir->dyn_relocs = eind->dyn_relocs;
 855       eind->dyn_relocs = NULL;
 856     }
 857
 858   if (ind->root.type == bfd_link_hash_indirect
 859       && dir->got.refcount <= 0)
 860     {
 861       edir->tls_type = eind->tls_type;
 862       eind->tls_type = GOT_UNKNOWN;
 863     }
 864
 865   if (ELIMINATE_COPY_RELOCS
 866       && ind->root.type != bfd_link_hash_indirect
 867       && dir->dynamic_adjusted)
 868     {
 869       /* If called to transfer flags for a weakdef during processing
 870          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 871          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 872       dir->ref_dynamic |= ind->ref_dynamic;
 873       dir->ref_regular |= ind->ref_regular;
 874       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 875       dir->needs_plt |= ind->needs_plt;
 876       dir->pointer_equality_needed |= ind->pointer_equality_needed;
 877     }
 878   else
 879     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 880 }
 881
 882 static int
 883 elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
 884 {
 885   if (info->shared)
 886     return r_type;
 887
 888   switch (r_type)
 889     {
 890     case R_386_TLS_GD:
 891     case R_386_TLS_GOTDESC:
 892     case R_386_TLS_DESC_CALL:
 893     case R_386_TLS_IE_32:
 894       if (is_local)
 895         return R_386_TLS_LE_32;
 896       return R_386_TLS_IE_32;
 897     case R_386_TLS_IE:
 898     case R_386_TLS_GOTIE:
 899       if (is_local)
 900         return R_386_TLS_LE_32;
 901       return r_type;
 902     case R_386_TLS_LDM:
 903       return R_386_TLS_LE_32;
 904     }
 905
 906   return r_type;
 907 }
 908
 909 /* Look through the relocs for a section during the first phase, and
 910    calculate needed space in the global offset table, procedure linkage
 911    table, and dynamic reloc sections.  */
 912
 913 static bfd_boolean
 914 elf_i386_check_relocs (bfd *abfd,
 915                        struct bfd_link_info *info,
 916                        asection *sec,
 917                        const Elf_Internal_Rela *relocs)
 918 {
 919   struct elf_i386_link_hash_table *htab;
 920   Elf_Internal_Shdr *symtab_hdr;
 921   struct elf_link_hash_entry **sym_hashes;
 922   const Elf_Internal_Rela *rel;
 923   const Elf_Internal_Rela *rel_end;
 924   asection *sreloc;
 925
 926   if (info->relocatable)
 927     return TRUE;
 928
 929   htab = elf_i386_hash_table (info);
 930   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 931   sym_hashes = elf_sym_hashes (abfd);
 932
 933   sreloc = NULL;
 934
 935   rel_end = relocs + sec->reloc_count;
 936   for (rel = relocs; rel < rel_end; rel++)
 937     {
 938       unsigned int r_type;
 939       unsigned long r_symndx;
 940       struct elf_link_hash_entry *h;
 941
 942       r_symndx = ELF32_R_SYM (rel->r_info);
 943       r_type = ELF32_R_TYPE (rel->r_info);
 944
 945       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 946         {
 947           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
 948                                  abfd,
 949                                  r_symndx);
 950           return FALSE;
 951         }
 952
 953       if (r_symndx < symtab_hdr->sh_info)
 954         h = NULL;
 955       else
 956         {
 957           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 958           while (h->root.type == bfd_link_hash_indirect
 959                  || h->root.type == bfd_link_hash_warning)
 960             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 961         }
 962
 963       r_type = elf_i386_tls_transition (info, r_type, h == NULL);
 964
 965       switch (r_type)
 966         {
 967         case R_386_TLS_LDM:
 968           htab->tls_ldm_got.refcount += 1;
 969           goto create_got;
 970
 971         case R_386_PLT32:
 972           /* This symbol requires a procedure linkage table entry.  We
 973              actually build the entry in adjust_dynamic_symbol,
 974              because this might be a case of linking PIC code which is
 975              never referenced by a dynamic object, in which case we
 976              don't need to generate a procedure linkage table entry
 977              after all.  */
 978
 979           /* If this is a local symbol, we resolve it directly without
 980              creating a procedure linkage table entry.  */
 981           if (h == NULL)
 982             continue;
 983
 984           h->needs_plt = 1;
 985           h->plt.refcount += 1;
 986           break;
 987
 988         case R_386_TLS_IE_32:
 989         case R_386_TLS_IE:
 990         case R_386_TLS_GOTIE:
 991           if (info->shared)
 992             info->flags |= DF_STATIC_TLS;
 993           /* Fall through */
 994
 995         case R_386_GOT32:
 996         case R_386_TLS_GD:
 997         case R_386_TLS_GOTDESC:
 998         case R_386_TLS_DESC_CALL:
 999           /* This symbol requires a global offset table entry.  */
1000           {
1001             int tls_type, old_tls_type;
1002
1003             switch (r_type)
1004               {
1005               default:
1006               case R_386_GOT32: tls_type = GOT_NORMAL; break;
1007               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1008               case R_386_TLS_GOTDESC:
1009               case R_386_TLS_DESC_CALL:
1010                 tls_type = GOT_TLS_GDESC; break;
1011               case R_386_TLS_IE_32:
1012                 if (ELF32_R_TYPE (rel->r_info) == r_type)
1013                   tls_type = GOT_TLS_IE_NEG;
1014                 else if (h
1015                          && ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
1016                   /* If this is a GD->IE transition, we may use either
1017                      of R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  But if
1018                      we may have both R_386_TLS_IE and R_386_TLS_GD,
1019                      we can't share the same R_386_TLS_TPOFF since
1020                      they require different offsets. So we remember
1021                      it comes from R_386_TLS_GD.  */
1022                   tls_type = GOT_TLS_IE | GOT_TLS_IE_GD;
1023                 else
1024                   tls_type = GOT_TLS_IE;
1025                 break;
1026               case R_386_TLS_IE:
1027                 if (h)
1028                   {
1029                     /* We remember it comes from R_386_TLS_IE.  */
1030                     tls_type = GOT_TLS_IE_POS | GOT_TLS_IE_IE;
1031                     break;
1032                   }
1033               case R_386_TLS_GOTIE:
1034                 tls_type = GOT_TLS_IE_POS; break;
1035               }
1036
1037             if (h != NULL)
1038               {
1039                 h->got.refcount += 1;
1040                 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1041               }
1042             else
1043               {
1044                 bfd_signed_vma *local_got_refcounts;
1045
1046                 /* This is a global offset table entry for a local symbol.  */
1047                 local_got_refcounts = elf_local_got_refcounts (abfd);
1048                 if (local_got_refcounts == NULL)
1049                   {
1050                     bfd_size_type size;
1051
1052                     size = symtab_hdr->sh_info;
1053                     size *= (sizeof (bfd_signed_vma)
1054                              + sizeof (bfd_vma) + sizeof(char));
1055                     local_got_refcounts = bfd_zalloc (abfd, size);
1056                     if (local_got_refcounts == NULL)
1057                       return FALSE;
1058                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1059                     elf_i386_local_tlsdesc_gotent (abfd)
1060                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1061                     elf_i386_local_got_tls_type (abfd)
1062                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1063                   }
1064                 local_got_refcounts[r_symndx] += 1;
1065                 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1066               }
1067
1068             if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1069               tls_type |= old_tls_type;
1070             /* If a TLS symbol is accessed using IE at least once,
1071                there is no point to use dynamic model for it.  */
1072             else if (old_tls_type != tls_type
1073                      && old_tls_type != GOT_UNKNOWN
1074                      && (! GOT_TLS_GD_ANY_P (old_tls_type)
1075                          || (tls_type & GOT_TLS_IE) == 0))
1076               {
1077                 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1078                   tls_type = old_tls_type;
1079                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1080                          && GOT_TLS_GD_ANY_P (tls_type))
1081                   tls_type |= old_tls_type;
1082                 else
1083                   {
1084                     (*_bfd_error_handler)
1085                       (_("%B: `%s' accessed both as normal and "
1086                          "thread local symbol"),
1087                        abfd,
1088                        h ? h->root.root.string : "<local>");
1089                     return FALSE;
1090                   }
1091               }
1092
1093             if (old_tls_type != tls_type)
1094               {
1095                 if (h != NULL)
1096                   elf_i386_hash_entry (h)->tls_type = tls_type;
1097                 else
1098                   elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1099               }
1100           }
1101           /* Fall through */
1102
1103         case R_386_GOTOFF:
1104         case R_386_GOTPC:
1105         create_got:
1106           if (htab->sgot == NULL)
1107             {
1108               if (htab->elf.dynobj == NULL)
1109                 htab->elf.dynobj = abfd;
1110               if (!create_got_section (htab->elf.dynobj, info))
1111                 return FALSE;
1112             }
1113           if (r_type != R_386_TLS_IE)
1114             break;
1115           /* Fall through */
1116
1117         case R_386_TLS_LE_32:
1118         case R_386_TLS_LE:
1119           if (!info->shared)
1120             break;
1121           info->flags |= DF_STATIC_TLS;
1122           /* Fall through */
1123
1124         case R_386_32:
1125         case R_386_PC32:
1126           if (h != NULL && !info->shared)
1127             {
1128               /* If this reloc is in a read-only section, we might
1129                  need a copy reloc.  We can't check reliably at this
1130                  stage whether the section is read-only, as input
1131                  sections have not yet been mapped to output sections.
1132                  Tentatively set the flag for now, and correct in
1133                  adjust_dynamic_symbol.  */
1134               h->non_got_ref = 1;
1135
1136               /* We may need a .plt entry if the function this reloc
1137                  refers to is in a shared lib.  */
1138               h->plt.refcount += 1;
1139               if (r_type != R_386_PC32)
1140                 h->pointer_equality_needed = 1;
1141             }
1142
1143           /* If we are creating a shared library, and this is a reloc
1144              against a global symbol, or a non PC relative reloc
1145              against a local symbol, then we need to copy the reloc
1146              into the shared library.  However, if we are linking with
1147              -Bsymbolic, we do not need to copy a reloc against a
1148              global symbol which is defined in an object we are
1149              including in the link (i.e., DEF_REGULAR is set).  At
1150              this point we have not seen all the input files, so it is
1151              possible that DEF_REGULAR is not set now but will be set
1152              later (it is never cleared).  In case of a weak definition,
1153              DEF_REGULAR may be cleared later by a strong definition in
1154              a shared library.  We account for that possibility below by
1155              storing information in the relocs_copied field of the hash
1156              table entry.  A similar situation occurs when creating
1157              shared libraries and symbol visibility changes render the
1158              symbol local.
1159
1160              If on the other hand, we are creating an executable, we
1161              may need to keep relocations for symbols satisfied by a
1162              dynamic library if we manage to avoid copy relocs for the
1163              symbol.  */
1164           if ((info->shared
1165                && (sec->flags & SEC_ALLOC) != 0
1166                && (r_type != R_386_PC32
1167                    || (h != NULL
1168                        && (! info->symbolic
1169                            || h->root.type == bfd_link_hash_defweak
1170                            || !h->def_regular))))
1171               || (ELIMINATE_COPY_RELOCS
1172                   && !info->shared
1173                   && (sec->flags & SEC_ALLOC) != 0
1174                   && h != NULL
1175                   && (h->root.type == bfd_link_hash_defweak
1176                       || !h->def_regular)))
1177             {
1178               struct elf_i386_dyn_relocs *p;
1179               struct elf_i386_dyn_relocs **head;
1180
1181               /* We must copy these reloc types into the output file.
1182                  Create a reloc section in dynobj and make room for
1183                  this reloc.  */
1184               if (sreloc == NULL)
1185                 {
1186                   const char *name;
1187                   bfd *dynobj;
1188                   unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1189                   unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1190
1191                   name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1192                   if (name == NULL)
1193                     return FALSE;
1194
1195                   if (strncmp (name, ".rel", 4) != 0
1196                       || strcmp (bfd_get_section_name (abfd, sec),
1197                                  name + 4) != 0)
1198                     {
1199                       (*_bfd_error_handler)
1200                         (_("%B: bad relocation section name `%s\'"),
1201                          abfd, name);
1202                     }
1203
1204                   if (htab->elf.dynobj == NULL)
1205                     htab->elf.dynobj = abfd;
1206
1207                   dynobj = htab->elf.dynobj;
1208                   sreloc = bfd_get_section_by_name (dynobj, name);
1209                   if (sreloc == NULL)
1210                     {
1211                       flagword flags;
1212
1213                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1214                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1215                       if ((sec->flags & SEC_ALLOC) != 0)
1216                         flags |= SEC_ALLOC | SEC_LOAD;
1217                       sreloc = bfd_make_section_with_flags (dynobj,
1218                                                             name,
1219                                                             flags);
1220                       if (sreloc == NULL
1221                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1222                         return FALSE;
1223                     }
1224                   elf_section_data (sec)->sreloc = sreloc;
1225                 }
1226
1227               /* If this is a global symbol, we count the number of
1228                  relocations we need for this symbol.  */
1229               if (h != NULL)
1230                 {
1231                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1232                 }
1233               else
1234                 {
1235                   void **vpp;
1236                   /* Track dynamic relocs needed for local syms too.
1237                      We really need local syms available to do this
1238                      easily.  Oh well.  */
1239
1240                   asection *s;
1241                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1242                                                  sec, r_symndx);
1243                   if (s == NULL)
1244                     return FALSE;
1245
1246                   vpp = &elf_section_data (s)->local_dynrel;
1247                   head = (struct elf_i386_dyn_relocs **)vpp;
1248                 }
1249
1250               p = *head;
1251               if (p == NULL || p->sec != sec)
1252                 {
1253                   bfd_size_type amt = sizeof *p;
1254                   p = bfd_alloc (htab->elf.dynobj, amt);
1255                   if (p == NULL)
1256                     return FALSE;
1257                   p->next = *head;
1258                   *head = p;
1259                   p->sec = sec;
1260                   p->count = 0;
1261                   p->pc_count = 0;
1262                 }
1263
1264               p->count += 1;
1265               if (r_type == R_386_PC32)
1266                 p->pc_count += 1;
1267             }
1268           break;
1269
1270           /* This relocation describes the C++ object vtable hierarchy.
1271              Reconstruct it for later use during GC.  */
1272         case R_386_GNU_VTINHERIT:
1273           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1274             return FALSE;
1275           break;
1276
1277           /* This relocation describes which C++ vtable entries are actually
1278              used.  Record for later use during GC.  */
1279         case R_386_GNU_VTENTRY:
1280           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1281             return FALSE;
1282           break;
1283
1284         default:
1285           break;
1286         }
1287     }
1288
1289   return TRUE;
1290 }
1291
1292 /* Return the section that should be marked against GC for a given
1293    relocation.  */
1294
1295 static asection *
1296 elf_i386_gc_mark_hook (asection *sec,
1297                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
1298                        Elf_Internal_Rela *rel,
1299                        struct elf_link_hash_entry *h,
1300                        Elf_Internal_Sym *sym)
1301 {
1302   if (h != NULL)
1303     {
1304       switch (ELF32_R_TYPE (rel->r_info))
1305         {
1306         case R_386_GNU_VTINHERIT:
1307         case R_386_GNU_VTENTRY:
1308           break;
1309
1310         default:
1311           switch (h->root.type)
1312             {
1313             case bfd_link_hash_defined:
1314             case bfd_link_hash_defweak:
1315               return h->root.u.def.section;
1316
1317             case bfd_link_hash_common:
1318               return h->root.u.c.p->section;
1319
1320             default:
1321               break;
1322             }
1323         }
1324     }
1325   else
1326     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1327
1328   return NULL;
1329 }
1330
1331 /* Update the got entry reference counts for the section being removed.  */
1332
1333 static bfd_boolean
1334 elf_i386_gc_sweep_hook (bfd *abfd,
1335                         struct bfd_link_info *info,
1336                         asection *sec,
1337                         const Elf_Internal_Rela *relocs)
1338 {
1339   Elf_Internal_Shdr *symtab_hdr;
1340   struct elf_link_hash_entry **sym_hashes;
1341   bfd_signed_vma *local_got_refcounts;
1342   const Elf_Internal_Rela *rel, *relend;
1343
1344   elf_section_data (sec)->local_dynrel = NULL;
1345
1346   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1347   sym_hashes = elf_sym_hashes (abfd);
1348   local_got_refcounts = elf_local_got_refcounts (abfd);
1349
1350   relend = relocs + sec->reloc_count;
1351   for (rel = relocs; rel < relend; rel++)
1352     {
1353       unsigned long r_symndx;
1354       unsigned int r_type;
1355       struct elf_link_hash_entry *h = NULL;
1356
1357       r_symndx = ELF32_R_SYM (rel->r_info);
1358       if (r_symndx >= symtab_hdr->sh_info)
1359         {
1360           struct elf_i386_link_hash_entry *eh;
1361           struct elf_i386_dyn_relocs **pp;
1362           struct elf_i386_dyn_relocs *p;
1363
1364           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1365           while (h->root.type == bfd_link_hash_indirect
1366                  || h->root.type == bfd_link_hash_warning)
1367             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1368           eh = (struct elf_i386_link_hash_entry *) h;
1369
1370           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1371             if (p->sec == sec)
1372               {
1373                 /* Everything must go for SEC.  */
1374                 *pp = p->next;
1375                 break;
1376               }
1377         }
1378
1379       r_type = ELF32_R_TYPE (rel->r_info);
1380       r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1381       switch (r_type)
1382         {
1383         case R_386_TLS_LDM:
1384           if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1385             elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1386           break;
1387
1388         case R_386_TLS_GD:
1389         case R_386_TLS_GOTDESC:
1390         case R_386_TLS_DESC_CALL:
1391         case R_386_TLS_IE_32:
1392         case R_386_TLS_IE:
1393         case R_386_TLS_GOTIE:
1394         case R_386_GOT32:
1395           if (h != NULL)
1396             {
1397               if (h->got.refcount > 0)
1398                 h->got.refcount -= 1;
1399             }
1400           else if (local_got_refcounts != NULL)
1401             {
1402               if (local_got_refcounts[r_symndx] > 0)
1403                 local_got_refcounts[r_symndx] -= 1;
1404             }
1405           break;
1406
1407         case R_386_32:
1408         case R_386_PC32:
1409           if (info->shared)
1410             break;
1411           /* Fall through */
1412
1413         case R_386_PLT32:
1414           if (h != NULL)
1415             {
1416               if (h->plt.refcount > 0)
1417                 h->plt.refcount -= 1;
1418             }
1419           break;
1420
1421         default:
1422           break;
1423         }
1424     }
1425
1426   return TRUE;
1427 }
1428
1429 /* Adjust a symbol defined by a dynamic object and referenced by a
1430    regular object.  The current definition is in some section of the
1431    dynamic object, but we're not including those sections.  We have to
1432    change the definition to something the rest of the link can
1433    understand.  */
1434
1435 static bfd_boolean
1436 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1437                                 struct elf_link_hash_entry *h)
1438 {
1439   struct elf_i386_link_hash_table *htab;
1440   asection *s;
1441   unsigned int power_of_two;
1442
1443   /* If this is a function, put it in the procedure linkage table.  We
1444      will fill in the contents of the procedure linkage table later,
1445      when we know the address of the .got section.  */
1446   if (h->type == STT_FUNC
1447       || h->needs_plt)
1448     {
1449       if (h->plt.refcount <= 0
1450           || SYMBOL_CALLS_LOCAL (info, h)
1451           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1452               && h->root.type == bfd_link_hash_undefweak))
1453         {
1454           /* This case can occur if we saw a PLT32 reloc in an input
1455              file, but the symbol was never referred to by a dynamic
1456              object, or if all references were garbage collected.  In
1457              such a case, we don't actually need to build a procedure
1458              linkage table, and we can just do a PC32 reloc instead.  */
1459           h->plt.offset = (bfd_vma) -1;
1460           h->needs_plt = 0;
1461         }
1462
1463       return TRUE;
1464     }
1465   else
1466     /* It's possible that we incorrectly decided a .plt reloc was
1467        needed for an R_386_PC32 reloc to a non-function sym in
1468        check_relocs.  We can't decide accurately between function and
1469        non-function syms in check-relocs;  Objects loaded later in
1470        the link may change h->type.  So fix it now.  */
1471     h->plt.offset = (bfd_vma) -1;
1472
1473   /* If this is a weak symbol, and there is a real definition, the
1474      processor independent code will have arranged for us to see the
1475      real definition first, and we can just use the same value.  */
1476   if (h->u.weakdef != NULL)
1477     {
1478       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1479                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1480       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1481       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1482       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1483         h->non_got_ref = h->u.weakdef->non_got_ref;
1484       return TRUE;
1485     }
1486
1487   /* This is a reference to a symbol defined by a dynamic object which
1488      is not a function.  */
1489
1490   /* If we are creating a shared library, we must presume that the
1491      only references to the symbol are via the global offset table.
1492      For such cases we need not do anything here; the relocations will
1493      be handled correctly by relocate_section.  */
1494   if (info->shared)
1495     return TRUE;
1496
1497   /* If there are no references to this symbol that do not use the
1498      GOT, we don't need to generate a copy reloc.  */
1499   if (!h->non_got_ref)
1500     return TRUE;
1501
1502   /* If -z nocopyreloc was given, we won't generate them either.  */
1503   if (info->nocopyreloc)
1504     {
1505       h->non_got_ref = 0;
1506       return TRUE;
1507     }
1508
1509   htab = elf_i386_hash_table (info);
1510
1511   /* If there aren't any dynamic relocs in read-only sections, then
1512      we can keep the dynamic relocs and avoid the copy reloc.  This
1513      doesn't work on VxWorks, where we can not have dynamic relocations
1514      (other than copy and jump slot relocations) in an executable.  */
1515   if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
1516     {
1517       struct elf_i386_link_hash_entry * eh;
1518       struct elf_i386_dyn_relocs *p;
1519
1520       eh = (struct elf_i386_link_hash_entry *) h;
1521       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1522         {
1523           s = p->sec->output_section;
1524           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1525             break;
1526         }
1527
1528       if (p == NULL)
1529         {
1530           h->non_got_ref = 0;
1531           return TRUE;
1532         }
1533     }
1534
1535   if (h->size == 0)
1536     {
1537       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1538                              h->root.root.string);
1539       return TRUE;
1540     }
1541
1542   /* We must allocate the symbol in our .dynbss section, which will
1543      become part of the .bss section of the executable.  There will be
1544      an entry for this symbol in the .dynsym section.  The dynamic
1545      object will contain position independent code, so all references
1546      from the dynamic object to this symbol will go through the global
1547      offset table.  The dynamic linker will use the .dynsym entry to
1548      determine the address it must put in the global offset table, so
1549      both the dynamic object and the regular object will refer to the
1550      same memory location for the variable.  */
1551
1552   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1553      copy the initial value out of the dynamic object and into the
1554      runtime process image.  */
1555   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1556     {
1557       htab->srelbss->size += sizeof (Elf32_External_Rel);
1558       h->needs_copy = 1;
1559     }
1560
1561   /* We need to figure out the alignment required for this symbol.  I
1562      have no idea how ELF linkers handle this.  */
1563   power_of_two = bfd_log2 (h->size);
1564   if (power_of_two > 3)
1565     power_of_two = 3;
1566
1567   /* Apply the required alignment.  */
1568   s = htab->sdynbss;
1569   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1570   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1571     {
1572       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1573         return FALSE;
1574     }
1575
1576   /* Define the symbol as being at this point in the section.  */
1577   h->root.u.def.section = s;
1578   h->root.u.def.value = s->size;
1579
1580   /* Increment the section size to make room for the symbol.  */
1581   s->size += h->size;
1582
1583   return TRUE;
1584 }
1585
1586 /* Allocate space in .plt, .got and associated reloc sections for
1587    dynamic relocs.  */
1588
1589 static bfd_boolean
1590 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1591 {
1592   struct bfd_link_info *info;
1593   struct elf_i386_link_hash_table *htab;
1594   struct elf_i386_link_hash_entry *eh;
1595   struct elf_i386_dyn_relocs *p;
1596
1597   if (h->root.type == bfd_link_hash_indirect)
1598     return TRUE;
1599
1600   if (h->root.type == bfd_link_hash_warning)
1601     /* When warning symbols are created, they **replace** the "real"
1602        entry in the hash table, thus we never get to see the real
1603        symbol in a hash traversal.  So look at it now.  */
1604     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1605
1606   info = (struct bfd_link_info *) inf;
1607   htab = elf_i386_hash_table (info);
1608
1609   if (htab->elf.dynamic_sections_created
1610       && h->plt.refcount > 0)
1611     {
1612       /* Make sure this symbol is output as a dynamic symbol.
1613          Undefined weak syms won't yet be marked as dynamic.  */
1614       if (h->dynindx == -1
1615           && !h->forced_local)
1616         {
1617           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1618             return FALSE;
1619         }
1620
1621       if (info->shared
1622           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1623         {
1624           asection *s = htab->splt;
1625
1626           /* If this is the first .plt entry, make room for the special
1627              first entry.  */
1628           if (s->size == 0)
1629             s->size += PLT_ENTRY_SIZE;
1630
1631           h->plt.offset = s->size;
1632
1633           /* If this symbol is not defined in a regular file, and we are
1634              not generating a shared library, then set the symbol to this
1635              location in the .plt.  This is required to make function
1636              pointers compare as equal between the normal executable and
1637              the shared library.  */
1638           if (! info->shared
1639               && !h->def_regular)
1640             {
1641               h->root.u.def.section = s;
1642               h->root.u.def.value = h->plt.offset;
1643             }
1644
1645           /* Make room for this entry.  */
1646           s->size += PLT_ENTRY_SIZE;
1647
1648           /* We also need to make an entry in the .got.plt section, which
1649              will be placed in the .got section by the linker script.  */
1650           htab->sgotplt->size += 4;
1651
1652           /* We also need to make an entry in the .rel.plt section.  */
1653           htab->srelplt->size += sizeof (Elf32_External_Rel);
1654           htab->next_tls_desc_index++;
1655
1656           if (htab->is_vxworks && !info->shared)
1657             {
1658               /* VxWorks has a second set of relocations for each PLT entry
1659                  in executables.  They go in a separate relocation section,
1660                  which is processed by the kernel loader.  */
1661
1662               /* There are two relocations for the initial PLT entry: an
1663                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1664                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
1665
1666               if (h->plt.offset == PLT_ENTRY_SIZE)
1667                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1668
1669               /* There are two extra relocations for each subsequent PLT entry:
1670                  an R_386_32 relocation for the GOT entry, and an R_386_32
1671                  relocation for the PLT entry.  */
1672
1673               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1674             }
1675         }
1676       else
1677         {
1678           h->plt.offset = (bfd_vma) -1;
1679           h->needs_plt = 0;
1680         }
1681     }
1682   else
1683     {
1684       h->plt.offset = (bfd_vma) -1;
1685       h->needs_plt = 0;
1686     }
1687
1688   eh = (struct elf_i386_link_hash_entry *) h;
1689   eh->tlsdesc_got = (bfd_vma) -1;
1690
1691   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1692      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
1693   if (h->got.refcount > 0
1694       && !info->shared
1695       && h->dynindx == -1
1696       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1697     h->got.offset = (bfd_vma) -1;
1698   else if (h->got.refcount > 0)
1699     {
1700       asection *s;
1701       bfd_boolean dyn;
1702       int tls_type = elf_i386_hash_entry(h)->tls_type;
1703
1704       /* If we have both R_386_TLS_IE and R_386_TLS_GD, GOT_TLS_IE_BOTH
1705          should be used.  */
1706       if ((tls_type & GOT_TLS_IE_MASK)
1707           == (GOT_TLS_IE_IE | GOT_TLS_IE_GD))
1708         tls_type = GOT_TLS_IE_BOTH;
1709       else
1710         tls_type &= GOT_TLS_MASK;
1711
1712       /* Make sure this symbol is output as a dynamic symbol.
1713          Undefined weak syms won't yet be marked as dynamic.  */
1714       if (h->dynindx == -1
1715           && !h->forced_local)
1716         {
1717           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1718             return FALSE;
1719         }
1720
1721       s = htab->sgot;
1722       if (GOT_TLS_GDESC_P (tls_type))
1723         {
1724           eh->tlsdesc_got = htab->sgotplt->size
1725             - elf_i386_compute_jump_table_size (htab);
1726           htab->sgotplt->size += 8;
1727           h->got.offset = (bfd_vma) -2;
1728         }
1729       if (! GOT_TLS_GDESC_P (tls_type)
1730           || GOT_TLS_GD_P (tls_type))
1731         {
1732           h->got.offset = s->size;
1733           s->size += 4;
1734           /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
1735           if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
1736             s->size += 4;
1737         }
1738       dyn = htab->elf.dynamic_sections_created;
1739       /* R_386_TLS_IE_32 needs one dynamic relocation,
1740          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1741          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1742          need two), R_386_TLS_GD needs one if local symbol and two if
1743          global.  */
1744       if (tls_type == GOT_TLS_IE_BOTH)
1745         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1746       else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1747                || (tls_type & GOT_TLS_IE))
1748         htab->srelgot->size += sizeof (Elf32_External_Rel);
1749       else if (GOT_TLS_GD_P (tls_type))
1750         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1751       else if (! GOT_TLS_GDESC_P (tls_type)
1752                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1753                    || h->root.type != bfd_link_hash_undefweak)
1754                && (info->shared
1755                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1756         htab->srelgot->size += sizeof (Elf32_External_Rel);
1757       if (GOT_TLS_GDESC_P (tls_type))
1758         htab->srelplt->size += sizeof (Elf32_External_Rel);
1759     }
1760   else
1761     h->got.offset = (bfd_vma) -1;
1762
1763   if (eh->dyn_relocs == NULL)
1764     return TRUE;
1765
1766   /* In the shared -Bsymbolic case, discard space allocated for
1767      dynamic pc-relative relocs against symbols which turn out to be
1768      defined in regular objects.  For the normal shared case, discard
1769      space for pc-relative relocs that have become local due to symbol
1770      visibility changes.  */
1771
1772   if (info->shared)
1773     {
1774       /* The only reloc that uses pc_count is R_386_PC32, which will
1775          appear on a call or on something like ".long foo - .".  We
1776          want calls to protected symbols to resolve directly to the
1777          function rather than going via the plt.  If people want
1778          function pointer comparisons to work as expected then they
1779          should avoid writing assembly like ".long foo - .".  */
1780       if (SYMBOL_CALLS_LOCAL (info, h))
1781         {
1782           struct elf_i386_dyn_relocs **pp;
1783
1784           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1785             {
1786               p->count -= p->pc_count;
1787               p->pc_count = 0;
1788               if (p->count == 0)
1789                 *pp = p->next;
1790               else
1791                 pp = &p->next;
1792             }
1793         }
1794
1795       /* Also discard relocs on undefined weak syms with non-default
1796          visibility.  */
1797       if (eh->dyn_relocs != NULL
1798           && h->root.type == bfd_link_hash_undefweak)
1799         {
1800           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1801             eh->dyn_relocs = NULL;
1802
1803           /* Make sure undefined weak symbols are output as a dynamic
1804              symbol in PIEs.  */
1805           else if (h->dynindx == -1
1806                    && !h->forced_local)
1807             {
1808               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1809                 return FALSE;
1810             }
1811         }
1812     }
1813   else if (ELIMINATE_COPY_RELOCS)
1814     {
1815       /* For the non-shared case, discard space for relocs against
1816          symbols which turn out to need copy relocs or are not
1817          dynamic.  */
1818
1819       if (!h->non_got_ref
1820           && ((h->def_dynamic
1821                && !h->def_regular)
1822               || (htab->elf.dynamic_sections_created
1823                   && (h->root.type == bfd_link_hash_undefweak
1824                       || h->root.type == bfd_link_hash_undefined))))
1825         {
1826           /* Make sure this symbol is output as a dynamic symbol.
1827              Undefined weak syms won't yet be marked as dynamic.  */
1828           if (h->dynindx == -1
1829               && !h->forced_local)
1830             {
1831               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1832                 return FALSE;
1833             }
1834
1835           /* If that succeeded, we know we'll be keeping all the
1836              relocs.  */
1837           if (h->dynindx != -1)
1838             goto keep;
1839         }
1840
1841       eh->dyn_relocs = NULL;
1842
1843     keep: ;
1844     }
1845
1846   /* Finally, allocate space.  */
1847   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1848     {
1849       asection *sreloc = elf_section_data (p->sec)->sreloc;
1850       sreloc->size += p->count * sizeof (Elf32_External_Rel);
1851     }
1852
1853   return TRUE;
1854 }
1855
1856 /* Find any dynamic relocs that apply to read-only sections.  */
1857
1858 static bfd_boolean
1859 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1860 {
1861   struct elf_i386_link_hash_entry *eh;
1862   struct elf_i386_dyn_relocs *p;
1863
1864   if (h->root.type == bfd_link_hash_warning)
1865     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1866
1867   eh = (struct elf_i386_link_hash_entry *) h;
1868   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1869     {
1870       asection *s = p->sec->output_section;
1871
1872       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1873         {
1874           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1875
1876           info->flags |= DF_TEXTREL;
1877
1878           /* Not an error, just cut short the traversal.  */
1879           return FALSE;
1880         }
1881     }
1882   return TRUE;
1883 }
1884
1885 /* Set the sizes of the dynamic sections.  */
1886
1887 static bfd_boolean
1888 elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1889                                 struct bfd_link_info *info)
1890 {
1891   struct elf_i386_link_hash_table *htab;
1892   bfd *dynobj;
1893   asection *s;
1894   bfd_boolean relocs;
1895   bfd *ibfd;
1896
1897   htab = elf_i386_hash_table (info);
1898   dynobj = htab->elf.dynobj;
1899   if (dynobj == NULL)
1900     abort ();
1901
1902   if (htab->elf.dynamic_sections_created)
1903     {
1904       /* Set the contents of the .interp section to the interpreter.  */
1905       if (info->executable)
1906         {
1907           s = bfd_get_section_by_name (dynobj, ".interp");
1908           if (s == NULL)
1909             abort ();
1910           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1911           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1912         }
1913     }
1914
1915   /* Set up .got offsets for local syms, and space for local dynamic
1916      relocs.  */
1917   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1918     {
1919       bfd_signed_vma *local_got;
1920       bfd_signed_vma *end_local_got;
1921       char *local_tls_type;
1922       bfd_vma *local_tlsdesc_gotent;
1923       bfd_size_type locsymcount;
1924       Elf_Internal_Shdr *symtab_hdr;
1925       asection *srel;
1926
1927       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1928         continue;
1929
1930       for (s = ibfd->sections; s != NULL; s = s->next)
1931         {
1932           struct elf_i386_dyn_relocs *p;
1933
1934           for (p = ((struct elf_i386_dyn_relocs *)
1935                      elf_section_data (s)->local_dynrel);
1936                p != NULL;
1937                p = p->next)
1938             {
1939               if (!bfd_is_abs_section (p->sec)
1940                   && bfd_is_abs_section (p->sec->output_section))
1941                 {
1942                   /* Input section has been discarded, either because
1943                      it is a copy of a linkonce section or due to
1944                      linker script /DISCARD/, so we'll be discarding
1945                      the relocs too.  */
1946                 }
1947               else if (p->count != 0)
1948                 {
1949                   srel = elf_section_data (p->sec)->sreloc;
1950                   srel->size += p->count * sizeof (Elf32_External_Rel);
1951                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1952                     info->flags |= DF_TEXTREL;
1953                 }
1954             }
1955         }
1956
1957       local_got = elf_local_got_refcounts (ibfd);
1958       if (!local_got)
1959         continue;
1960
1961       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1962       locsymcount = symtab_hdr->sh_info;
1963       end_local_got = local_got + locsymcount;
1964       local_tls_type = elf_i386_local_got_tls_type (ibfd);
1965       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
1966       s = htab->sgot;
1967       srel = htab->srelgot;
1968       for (; local_got < end_local_got;
1969            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1970         {
1971           *local_tlsdesc_gotent = (bfd_vma) -1;
1972           if (*local_got > 0)
1973             {
1974               if (GOT_TLS_GDESC_P (*local_tls_type))
1975                 {
1976                   *local_tlsdesc_gotent = htab->sgotplt->size
1977                     - elf_i386_compute_jump_table_size (htab);
1978                   htab->sgotplt->size += 8;
1979                   *local_got = (bfd_vma) -2;
1980                 }
1981               if (! GOT_TLS_GDESC_P (*local_tls_type)
1982                   || GOT_TLS_GD_P (*local_tls_type))
1983                 {
1984                   *local_got = s->size;
1985                   s->size += 4;
1986                   if (GOT_TLS_GD_P (*local_tls_type)
1987                       || *local_tls_type == GOT_TLS_IE_BOTH)
1988                     s->size += 4;
1989                 }
1990               if (info->shared
1991                   || GOT_TLS_GD_ANY_P (*local_tls_type)
1992                   || (*local_tls_type & GOT_TLS_IE))
1993                 {
1994                   if (*local_tls_type == GOT_TLS_IE_BOTH)
1995                     srel->size += 2 * sizeof (Elf32_External_Rel);
1996                   else if (GOT_TLS_GD_P (*local_tls_type)
1997                            || ! GOT_TLS_GDESC_P (*local_tls_type))
1998                     srel->size += sizeof (Elf32_External_Rel);
1999                   if (GOT_TLS_GDESC_P (*local_tls_type))
2000                     htab->srelplt->size += sizeof (Elf32_External_Rel);
2001                 }
2002             }
2003           else
2004             *local_got = (bfd_vma) -1;
2005         }
2006     }
2007
2008   if (htab->tls_ldm_got.refcount > 0)
2009     {
2010       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2011          relocs.  */
2012       htab->tls_ldm_got.offset = htab->sgot->size;
2013       htab->sgot->size += 8;
2014       htab->srelgot->size += sizeof (Elf32_External_Rel);
2015     }
2016   else
2017     htab->tls_ldm_got.offset = -1;
2018
2019   /* Allocate global sym .plt and .got entries, and space for global
2020      sym dynamic relocs.  */
2021   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2022
2023   /* For every jump slot reserved in the sgotplt, reloc_count is
2024      incremented.  However, when we reserve space for TLS descriptors,
2025      it's not incremented, so in order to compute the space reserved
2026      for them, it suffices to multiply the reloc count by the jump
2027      slot size.  */
2028   if (htab->srelplt)
2029     htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2030
2031   /* We now have determined the sizes of the various dynamic sections.
2032      Allocate memory for them.  */
2033   relocs = FALSE;
2034   for (s = dynobj->sections; s != NULL; s = s->next)
2035     {
2036       bfd_boolean strip_section = TRUE;
2037
2038       if ((s->flags & SEC_LINKER_CREATED) == 0)
2039         continue;
2040
2041       if (s == htab->splt
2042           || s == htab->sgot
2043           || s == htab->sgotplt
2044           || s == htab->sdynbss)
2045         {
2046           /* Strip this section if we don't need it; see the
2047              comment below.  */
2048           /* We'd like to strip these sections if they aren't needed, but if
2049              we've exported dynamic symbols from them we must leave them.
2050              It's too late to tell BFD to get rid of the symbols.  */
2051
2052           if (htab->elf.hplt != NULL)
2053             strip_section = FALSE;
2054         }
2055       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
2056         {
2057           if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
2058             relocs = TRUE;
2059
2060           /* We use the reloc_count field as a counter if we need
2061              to copy relocs into the output file.  */
2062           s->reloc_count = 0;
2063         }
2064       else
2065         {
2066           /* It's not one of our sections, so don't allocate space.  */
2067           continue;
2068         }
2069
2070       if (s->size == 0)
2071         {
2072           /* If we don't need this section, strip it from the
2073              output file.  This is mostly to handle .rel.bss and
2074              .rel.plt.  We must create both sections in
2075              create_dynamic_sections, because they must be created
2076              before the linker maps input sections to output
2077              sections.  The linker does that before
2078              adjust_dynamic_symbol is called, and it is that
2079              function which decides whether anything needs to go
2080              into these sections.  */
2081           if (strip_section)
2082             s->flags |= SEC_EXCLUDE;
2083           continue;
2084         }
2085
2086       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2087         continue;
2088
2089       /* Allocate memory for the section contents.  We use bfd_zalloc
2090          here in case unused entries are not reclaimed before the
2091          section's contents are written out.  This should not happen,
2092          but this way if it does, we get a R_386_NONE reloc instead
2093          of garbage.  */
2094       s->contents = bfd_zalloc (dynobj, s->size);
2095       if (s->contents == NULL)
2096         return FALSE;
2097     }
2098
2099   if (htab->elf.dynamic_sections_created)
2100     {
2101       /* Add some entries to the .dynamic section.  We fill in the
2102          values later, in elf_i386_finish_dynamic_sections, but we
2103          must add the entries now so that we get the correct size for
2104          the .dynamic section.  The DT_DEBUG entry is filled in by the
2105          dynamic linker and used by the debugger.  */
2106 #define add_dynamic_entry(TAG, VAL) \
2107   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2108
2109       if (info->executable)
2110         {
2111           if (!add_dynamic_entry (DT_DEBUG, 0))
2112             return FALSE;
2113         }
2114
2115       if (htab->splt->size != 0)
2116         {
2117           if (!add_dynamic_entry (DT_PLTGOT, 0)
2118               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2119               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2120               || !add_dynamic_entry (DT_JMPREL, 0))
2121             return FALSE;
2122         }
2123
2124       if (relocs)
2125         {
2126           if (!add_dynamic_entry (DT_REL, 0)
2127               || !add_dynamic_entry (DT_RELSZ, 0)
2128               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2129             return FALSE;
2130
2131           /* If any dynamic relocs apply to a read-only section,
2132              then we need a DT_TEXTREL entry.  */
2133           if ((info->flags & DF_TEXTREL) == 0)
2134             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2135                                     (PTR) info);
2136
2137           if ((info->flags & DF_TEXTREL) != 0)
2138             {
2139               if (!add_dynamic_entry (DT_TEXTREL, 0))
2140                 return FALSE;
2141             }
2142         }
2143     }
2144 #undef add_dynamic_entry
2145
2146   return TRUE;
2147 }
2148
2149 static bfd_boolean
2150 elf_i386_always_size_sections (bfd *output_bfd,
2151                                struct bfd_link_info *info)
2152 {
2153   asection *tls_sec = elf_hash_table (info)->tls_sec;
2154
2155   if (tls_sec)
2156     {
2157       struct elf_link_hash_entry *tlsbase;
2158
2159       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2160                                       "_TLS_MODULE_BASE_",
2161                                       FALSE, FALSE, FALSE);
2162
2163       if (tlsbase && tlsbase->type == STT_TLS)
2164         {
2165           struct bfd_link_hash_entry *bh = NULL;
2166           const struct elf_backend_data *bed
2167             = get_elf_backend_data (output_bfd);
2168
2169           if (!(_bfd_generic_link_add_one_symbol
2170                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2171                  tls_sec, 0, NULL, FALSE,
2172                  bed->collect, &bh)))
2173             return FALSE;
2174           tlsbase = (struct elf_link_hash_entry *)bh;
2175           tlsbase->def_regular = 1;
2176           tlsbase->other = STV_HIDDEN;
2177           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2178         }
2179     }
2180
2181   return TRUE;
2182 }
2183
2184 /* Set the correct type for an x86 ELF section.  We do this by the
2185    section name, which is a hack, but ought to work.  */
2186
2187 static bfd_boolean
2188 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2189                         Elf_Internal_Shdr *hdr,
2190                         asection *sec)
2191 {
2192   register const char *name;
2193
2194   name = bfd_get_section_name (abfd, sec);
2195
2196   /* This is an ugly, but unfortunately necessary hack that is
2197      needed when producing EFI binaries on x86. It tells
2198      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2199      containing ELF relocation info.  We need this hack in order to
2200      be able to generate ELF binaries that can be translated into
2201      EFI applications (which are essentially COFF objects).  Those
2202      files contain a COFF ".reloc" section inside an ELFNN object,
2203      which would normally cause BFD to segfault because it would
2204      attempt to interpret this section as containing relocation
2205      entries for section "oc".  With this hack enabled, ".reloc"
2206      will be treated as a normal data section, which will avoid the
2207      segfault.  However, you won't be able to create an ELFNN binary
2208      with a section named "oc" that needs relocations, but that's
2209      the kind of ugly side-effects you get when detecting section
2210      types based on their names...  In practice, this limitation is
2211      unlikely to bite.  */
2212   if (strcmp (name, ".reloc") == 0)
2213     hdr->sh_type = SHT_PROGBITS;
2214
2215   return TRUE;
2216 }
2217
2218 /* Return the base VMA address which should be subtracted from real addresses
2219    when resolving @dtpoff relocation.
2220    This is PT_TLS segment p_vaddr.  */
2221
2222 static bfd_vma
2223 dtpoff_base (struct bfd_link_info *info)
2224 {
2225   /* If tls_sec is NULL, we should have signalled an error already.  */
2226   if (elf_hash_table (info)->tls_sec == NULL)
2227     return 0;
2228   return elf_hash_table (info)->tls_sec->vma;
2229 }
2230
2231 /* Return the relocation value for @tpoff relocation
2232    if STT_TLS virtual address is ADDRESS.  */
2233
2234 static bfd_vma
2235 tpoff (struct bfd_link_info *info, bfd_vma address)
2236 {
2237   struct elf_link_hash_table *htab = elf_hash_table (info);
2238
2239   /* If tls_sec is NULL, we should have signalled an error already.  */
2240   if (htab->tls_sec == NULL)
2241     return 0;
2242   return htab->tls_size + htab->tls_sec->vma - address;
2243 }
2244
2245 /* Relocate an i386 ELF section.  */
2246
2247 static bfd_boolean
2248 elf_i386_relocate_section (bfd *output_bfd,
2249                            struct bfd_link_info *info,
2250                            bfd *input_bfd,
2251                            asection *input_section,
2252                            bfd_byte *contents,
2253                            Elf_Internal_Rela *relocs,
2254                            Elf_Internal_Sym *local_syms,
2255                            asection **local_sections)
2256 {
2257   struct elf_i386_link_hash_table *htab;
2258   Elf_Internal_Shdr *symtab_hdr;
2259   struct elf_link_hash_entry **sym_hashes;
2260   bfd_vma *local_got_offsets;
2261   bfd_vma *local_tlsdesc_gotents;
2262   Elf_Internal_Rela *rel;
2263   Elf_Internal_Rela *relend;
2264
2265   htab = elf_i386_hash_table (info);
2266   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2267   sym_hashes = elf_sym_hashes (input_bfd);
2268   local_got_offsets = elf_local_got_offsets (input_bfd);
2269   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
2270
2271   rel = relocs;
2272   relend = relocs + input_section->reloc_count;
2273   for (; rel < relend; rel++)
2274     {
2275       unsigned int r_type;
2276       reloc_howto_type *howto;
2277       unsigned long r_symndx;
2278       struct elf_link_hash_entry *h;
2279       Elf_Internal_Sym *sym;
2280       asection *sec;
2281       bfd_vma off, offplt;
2282       bfd_vma relocation;
2283       bfd_boolean unresolved_reloc;
2284       bfd_reloc_status_type r;
2285       unsigned int indx;
2286       int tls_type;
2287
2288       r_type = ELF32_R_TYPE (rel->r_info);
2289       if (r_type == R_386_GNU_VTINHERIT
2290           || r_type == R_386_GNU_VTENTRY)
2291         continue;
2292
2293       if ((indx = r_type) >= R_386_standard
2294           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2295               >= R_386_ext - R_386_standard)
2296           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2297               >= R_386_tls - R_386_ext))
2298         {
2299           (*_bfd_error_handler)
2300             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2301              input_bfd, input_section, r_type);
2302           bfd_set_error (bfd_error_bad_value);
2303           return FALSE;
2304         }
2305       howto = elf_howto_table + indx;
2306
2307       r_symndx = ELF32_R_SYM (rel->r_info);
2308
2309       if (info->relocatable)
2310         {
2311           bfd_vma val;
2312           bfd_byte *where;
2313
2314           /* This is a relocatable link.  We don't have to change
2315              anything, unless the reloc is against a section symbol,
2316              in which case we have to adjust according to where the
2317              section symbol winds up in the output section.  */
2318           if (r_symndx >= symtab_hdr->sh_info)
2319             continue;
2320
2321           sym = local_syms + r_symndx;
2322           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2323             continue;
2324
2325           sec = local_sections[r_symndx];
2326           val = sec->output_offset;
2327           if (val == 0)
2328             continue;
2329
2330           where = contents + rel->r_offset;
2331           switch (howto->size)
2332             {
2333               /* FIXME: overflow checks.  */
2334             case 0:
2335               val += bfd_get_8 (input_bfd, where);
2336               bfd_put_8 (input_bfd, val, where);
2337               break;
2338             case 1:
2339               val += bfd_get_16 (input_bfd, where);
2340               bfd_put_16 (input_bfd, val, where);
2341               break;
2342             case 2:
2343               val += bfd_get_32 (input_bfd, where);
2344               bfd_put_32 (input_bfd, val, where);
2345               break;
2346             default:
2347               abort ();
2348             }
2349           continue;
2350         }
2351
2352       /* This is a final link.  */
2353       h = NULL;
2354       sym = NULL;
2355       sec = NULL;
2356       unresolved_reloc = FALSE;
2357       if (r_symndx < symtab_hdr->sh_info)
2358         {
2359           sym = local_syms + r_symndx;
2360           sec = local_sections[r_symndx];
2361           relocation = (sec->output_section->vma
2362                         + sec->output_offset
2363                         + sym->st_value);
2364           if ((sec->flags & SEC_MERGE)
2365               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2366             {
2367               asection *msec;
2368               bfd_vma addend;
2369               bfd_byte *where = contents + rel->r_offset;
2370
2371               switch (howto->size)
2372                 {
2373                 case 0:
2374                   addend = bfd_get_8 (input_bfd, where);
2375                   if (howto->pc_relative)
2376                     {
2377                       addend = (addend ^ 0x80) - 0x80;
2378                       addend += 1;
2379                     }
2380                   break;
2381                 case 1:
2382                   addend = bfd_get_16 (input_bfd, where);
2383                   if (howto->pc_relative)
2384                     {
2385                       addend = (addend ^ 0x8000) - 0x8000;
2386                       addend += 2;
2387                     }
2388                   break;
2389                 case 2:
2390                   addend = bfd_get_32 (input_bfd, where);
2391                   if (howto->pc_relative)
2392                     {
2393                       addend = (addend ^ 0x80000000) - 0x80000000;
2394                       addend += 4;
2395                     }
2396                   break;
2397                 default:
2398                   abort ();
2399                 }
2400
2401               msec = sec;
2402               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2403               addend -= relocation;
2404               addend += msec->output_section->vma + msec->output_offset;
2405
2406               switch (howto->size)
2407                 {
2408                 case 0:
2409                   /* FIXME: overflow checks.  */
2410                   if (howto->pc_relative)
2411                     addend -= 1;
2412                   bfd_put_8 (input_bfd, addend, where);
2413                   break;
2414                 case 1:
2415                   if (howto->pc_relative)
2416                     addend -= 2;
2417                   bfd_put_16 (input_bfd, addend, where);
2418                   break;
2419                 case 2:
2420                   if (howto->pc_relative)
2421                     addend -= 4;
2422                   bfd_put_32 (input_bfd, addend, where);
2423                   break;
2424                 }
2425             }
2426         }
2427       else
2428         {
2429           bfd_boolean warned;
2430
2431           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2432                                    r_symndx, symtab_hdr, sym_hashes,
2433                                    h, sec, relocation,
2434                                    unresolved_reloc, warned);
2435         }
2436
2437       if (r_symndx == 0)
2438         {
2439         /* r_symndx will be zero only for relocs against symbols from
2440            removed linkonce sections, or sections discarded by a linker
2441            script.  For these relocs, we just want the section contents
2442            zeroed.  Avoid any special processing in the switch below.  */
2443           r_type = R_386_NONE;
2444
2445           relocation = 0;
2446           if (howto->pc_relative)
2447             relocation = (input_section->output_section->vma
2448                           + input_section->output_offset
2449                           + rel->r_offset);
2450         }
2451
2452       switch (r_type)
2453         {
2454         case R_386_GOT32:
2455           /* Relocation is to the entry for this symbol in the global
2456              offset table.  */
2457           if (htab->sgot == NULL)
2458             abort ();
2459
2460           if (h != NULL)
2461             {
2462               bfd_boolean dyn;
2463
2464               off = h->got.offset;
2465               dyn = htab->elf.dynamic_sections_created;
2466               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2467                   || (info->shared
2468                       && SYMBOL_REFERENCES_LOCAL (info, h))
2469                   || (ELF_ST_VISIBILITY (h->other)
2470                       && h->root.type == bfd_link_hash_undefweak))
2471                 {
2472                   /* This is actually a static link, or it is a
2473                      -Bsymbolic link and the symbol is defined
2474                      locally, or the symbol was forced to be local
2475                      because of a version file.  We must initialize
2476                      this entry in the global offset table.  Since the
2477                      offset must always be a multiple of 4, we use the
2478                      least significant bit to record whether we have
2479                      initialized it already.
2480
2481                      When doing a dynamic link, we create a .rel.got
2482                      relocation entry to initialize the value.  This
2483                      is done in the finish_dynamic_symbol routine.  */
2484                   if ((off & 1) != 0)
2485                     off &= ~1;
2486                   else
2487                     {
2488                       bfd_put_32 (output_bfd, relocation,
2489                                   htab->sgot->contents + off);
2490                       h->got.offset |= 1;
2491                     }
2492                 }
2493               else
2494                 unresolved_reloc = FALSE;
2495             }
2496           else
2497             {
2498               if (local_got_offsets == NULL)
2499                 abort ();
2500
2501               off = local_got_offsets[r_symndx];
2502
2503               /* The offset must always be a multiple of 4.  We use
2504                  the least significant bit to record whether we have
2505                  already generated the necessary reloc.  */
2506               if ((off & 1) != 0)
2507                 off &= ~1;
2508               else
2509                 {
2510                   bfd_put_32 (output_bfd, relocation,
2511                               htab->sgot->contents + off);
2512
2513                   if (info->shared)
2514                     {
2515                       asection *s;
2516                       Elf_Internal_Rela outrel;
2517                       bfd_byte *loc;
2518
2519                       s = htab->srelgot;
2520                       if (s == NULL)
2521                         abort ();
2522
2523                       outrel.r_offset = (htab->sgot->output_section->vma
2524                                          + htab->sgot->output_offset
2525                                          + off);
2526                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2527                       loc = s->contents;
2528                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2529                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2530                     }
2531
2532                   local_got_offsets[r_symndx] |= 1;
2533                 }
2534             }
2535
2536           if (off >= (bfd_vma) -2)
2537             abort ();
2538
2539           relocation = htab->sgot->output_section->vma
2540                        + htab->sgot->output_offset + off
2541                        - htab->sgotplt->output_section->vma
2542                        - htab->sgotplt->output_offset;
2543           break;
2544
2545         case R_386_GOTOFF:
2546           /* Relocation is relative to the start of the global offset
2547              table.  */
2548
2549           /* Check to make sure it isn't a protected function symbol
2550              for shared library since it may not be local when used
2551              as function address.  */
2552           if (info->shared
2553               && !info->executable
2554               && h
2555               && h->def_regular
2556               && h->type == STT_FUNC
2557               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2558             {
2559               (*_bfd_error_handler)
2560                 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2561                  input_bfd, h->root.root.string);
2562               bfd_set_error (bfd_error_bad_value);
2563               return FALSE;
2564             }
2565
2566           /* Note that sgot is not involved in this
2567              calculation.  We always want the start of .got.plt.  If we
2568              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2569              permitted by the ABI, we might have to change this
2570              calculation.  */
2571           relocation -= htab->sgotplt->output_section->vma
2572                         + htab->sgotplt->output_offset;
2573           break;
2574
2575         case R_386_GOTPC:
2576           /* Use global offset table as symbol value.  */
2577           relocation = htab->sgotplt->output_section->vma
2578                        + htab->sgotplt->output_offset;
2579           unresolved_reloc = FALSE;
2580           break;
2581
2582         case R_386_PLT32:
2583           /* Relocation is to the entry for this symbol in the
2584              procedure linkage table.  */
2585
2586           /* Resolve a PLT32 reloc against a local symbol directly,
2587              without using the procedure linkage table.  */
2588           if (h == NULL)
2589             break;
2590
2591           if (h->plt.offset == (bfd_vma) -1
2592               || htab->splt == NULL)
2593             {
2594               /* We didn't make a PLT entry for this symbol.  This
2595                  happens when statically linking PIC code, or when
2596                  using -Bsymbolic.  */
2597               break;
2598             }
2599
2600           relocation = (htab->splt->output_section->vma
2601                         + htab->splt->output_offset
2602                         + h->plt.offset);
2603           unresolved_reloc = FALSE;
2604           break;
2605
2606         case R_386_32:
2607         case R_386_PC32:
2608           if ((input_section->flags & SEC_ALLOC) == 0)
2609             break;
2610
2611           if ((info->shared
2612                && (h == NULL
2613                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2614                    || h->root.type != bfd_link_hash_undefweak)
2615                && (r_type != R_386_PC32
2616                    || !SYMBOL_CALLS_LOCAL (info, h)))
2617               || (ELIMINATE_COPY_RELOCS
2618                   && !info->shared
2619                   && h != NULL
2620                   && h->dynindx != -1
2621                   && !h->non_got_ref
2622                   && ((h->def_dynamic
2623                        && !h->def_regular)
2624                       || h->root.type == bfd_link_hash_undefweak
2625                       || h->root.type == bfd_link_hash_undefined)))
2626             {
2627               Elf_Internal_Rela outrel;
2628               bfd_byte *loc;
2629               bfd_boolean skip, relocate;
2630               asection *sreloc;
2631
2632               /* When generating a shared object, these relocations
2633                  are copied into the output file to be resolved at run
2634                  time.  */
2635
2636               skip = FALSE;
2637               relocate = FALSE;
2638
2639               outrel.r_offset =
2640                 _bfd_elf_section_offset (output_bfd, info, input_section,
2641                                          rel->r_offset);
2642               if (outrel.r_offset == (bfd_vma) -1)
2643                 skip = TRUE;
2644               else if (outrel.r_offset == (bfd_vma) -2)
2645                 skip = TRUE, relocate = TRUE;
2646               outrel.r_offset += (input_section->output_section->vma
2647                                   + input_section->output_offset);
2648
2649               if (skip)
2650                 memset (&outrel, 0, sizeof outrel);
2651               else if (h != NULL
2652                        && h->dynindx != -1
2653                        && (r_type == R_386_PC32
2654                            || !info->shared
2655                            || !info->symbolic
2656                            || !h->def_regular))
2657                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2658               else
2659                 {
2660                   /* This symbol is local, or marked to become local.  */
2661                   relocate = TRUE;
2662                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2663                 }
2664
2665               sreloc = elf_section_data (input_section)->sreloc;
2666               if (sreloc == NULL)
2667                 abort ();
2668
2669               loc = sreloc->contents;
2670               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2671               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2672
2673               /* If this reloc is against an external symbol, we do
2674                  not want to fiddle with the addend.  Otherwise, we
2675                  need to include the symbol value so that it becomes
2676                  an addend for the dynamic reloc.  */
2677               if (! relocate)
2678                 continue;
2679             }
2680           break;
2681
2682         case R_386_TLS_IE:
2683           if (info->shared)
2684             {
2685               Elf_Internal_Rela outrel;
2686               bfd_byte *loc;
2687               asection *sreloc;
2688
2689               outrel.r_offset = rel->r_offset
2690                                 + input_section->output_section->vma
2691                                 + input_section->output_offset;
2692               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2693               sreloc = elf_section_data (input_section)->sreloc;
2694               if (sreloc == NULL)
2695                 abort ();
2696               loc = sreloc->contents;
2697               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2698               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2699             }
2700           /* Fall through */
2701
2702         case R_386_TLS_GD:
2703         case R_386_TLS_GOTDESC:
2704         case R_386_TLS_DESC_CALL:
2705         case R_386_TLS_IE_32:
2706         case R_386_TLS_GOTIE:
2707           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2708           tls_type = GOT_UNKNOWN;
2709           if (h == NULL && local_got_offsets)
2710             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2711           else if (h != NULL)
2712             {
2713               tls_type = elf_i386_hash_entry(h)->tls_type;
2714               /* If we have both R_386_TLS_IE and R_386_TLS_GD,
2715                  GOT_TLS_IE_BOTH should be used.  */
2716               if ((tls_type & GOT_TLS_IE_MASK)
2717                   == (GOT_TLS_IE_IE | GOT_TLS_IE_GD))
2718                 tls_type = GOT_TLS_IE_BOTH;
2719               else
2720                 tls_type &= GOT_TLS_MASK;
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 += (htab->next_tls_desc_index++
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->elf.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->elf.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       || (!htab->is_vxworks && h == htab->elf.hgot))
3653     sym->st_shndx = SHN_ABS;
3654
3655   return TRUE;
3656 }
3657
3658 /* Used to decide how to sort relocs in an optimal manner for the
3659    dynamic linker, before writing them out.  */
3660
3661 static enum elf_reloc_type_class
3662 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3663 {
3664   switch (ELF32_R_TYPE (rela->r_info))
3665     {
3666     case R_386_RELATIVE:
3667       return reloc_class_relative;
3668     case R_386_JUMP_SLOT:
3669       return reloc_class_plt;
3670     case R_386_COPY:
3671       return reloc_class_copy;
3672     default:
3673       return reloc_class_normal;
3674     }
3675 }
3676
3677 /* Finish up the dynamic sections.  */
3678
3679 static bfd_boolean
3680 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3681                                   struct bfd_link_info *info)
3682 {
3683   struct elf_i386_link_hash_table *htab;
3684   bfd *dynobj;
3685   asection *sdyn;
3686
3687   htab = elf_i386_hash_table (info);
3688   dynobj = htab->elf.dynobj;
3689   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3690
3691   if (htab->elf.dynamic_sections_created)
3692     {
3693       Elf32_External_Dyn *dyncon, *dynconend;
3694
3695       if (sdyn == NULL || htab->sgot == NULL)
3696         abort ();
3697
3698       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3699       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3700       for (; dyncon < dynconend; dyncon++)
3701         {
3702           Elf_Internal_Dyn dyn;
3703           asection *s;
3704
3705           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3706
3707           switch (dyn.d_tag)
3708             {
3709             default:
3710               continue;
3711
3712             case DT_PLTGOT:
3713               s = htab->sgotplt;
3714               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3715               break;
3716
3717             case DT_JMPREL:
3718               s = htab->srelplt;
3719               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3720               break;
3721
3722             case DT_PLTRELSZ:
3723               s = htab->srelplt;
3724               dyn.d_un.d_val = s->size;
3725               break;
3726
3727             case DT_RELSZ:
3728               /* My reading of the SVR4 ABI indicates that the
3729                  procedure linkage table relocs (DT_JMPREL) should be
3730                  included in the overall relocs (DT_REL).  This is
3731                  what Solaris does.  However, UnixWare can not handle
3732                  that case.  Therefore, we override the DT_RELSZ entry
3733                  here to make it not include the JMPREL relocs.  */
3734               s = htab->srelplt;
3735               if (s == NULL)
3736                 continue;
3737               dyn.d_un.d_val -= s->size;
3738               break;
3739
3740             case DT_REL:
3741               /* We may not be using the standard ELF linker script.
3742                  If .rel.plt is the first .rel section, we adjust
3743                  DT_REL to not include it.  */
3744               s = htab->srelplt;
3745               if (s == NULL)
3746                 continue;
3747               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3748                 continue;
3749               dyn.d_un.d_ptr += s->size;
3750               break;
3751             }
3752
3753           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3754         }
3755
3756       /* Fill in the first entry in the procedure linkage table.  */
3757       if (htab->splt && htab->splt->size > 0)
3758         {
3759           if (info->shared)
3760             {
3761               memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3762                       sizeof (elf_i386_pic_plt0_entry));
3763               memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3764                       htab->plt0_pad_byte,
3765                       PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3766             }
3767           else
3768             {
3769               memcpy (htab->splt->contents, elf_i386_plt0_entry,
3770                       sizeof(elf_i386_plt0_entry));
3771               memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3772                       htab->plt0_pad_byte,
3773                       PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
3774               bfd_put_32 (output_bfd,
3775                           (htab->sgotplt->output_section->vma
3776                            + htab->sgotplt->output_offset
3777                            + 4),
3778                           htab->splt->contents + 2);
3779               bfd_put_32 (output_bfd,
3780                           (htab->sgotplt->output_section->vma
3781                            + htab->sgotplt->output_offset
3782                            + 8),
3783                           htab->splt->contents + 8);
3784
3785               if (htab->is_vxworks)
3786                 {
3787                   Elf_Internal_Rela rel;
3788
3789                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3790                      On IA32 we use REL relocations so the addend goes in
3791                      the PLT directly.  */
3792                   rel.r_offset = (htab->splt->output_section->vma
3793                                   + htab->splt->output_offset
3794                                   + 2);
3795                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3796                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3797                                             htab->srelplt2->contents);
3798                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
3799                   rel.r_offset = (htab->splt->output_section->vma
3800                                   + htab->splt->output_offset
3801                                   + 8);
3802                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3803                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3804                                             htab->srelplt2->contents +
3805                                             sizeof (Elf32_External_Rel));
3806                 }
3807             }
3808
3809           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3810              really seem like the right value.  */
3811           elf_section_data (htab->splt->output_section)
3812             ->this_hdr.sh_entsize = 4;
3813
3814           /* Correct the .rel.plt.unloaded relocations.  */
3815           if (htab->is_vxworks && !info->shared)
3816             {
3817               int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
3818               unsigned char *p;
3819
3820               p = htab->srelplt2->contents;
3821               if (info->shared)
3822                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
3823               else
3824                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
3825
3826               for (; num_plts; num_plts--)
3827                 {
3828                   Elf_Internal_Rela rel;
3829                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3830                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3831                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3832                   p += sizeof (Elf32_External_Rel);
3833
3834                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3835                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3836                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3837                   p += sizeof (Elf32_External_Rel);
3838                 }
3839             }
3840         }
3841     }
3842
3843   if (htab->sgotplt)
3844     {
3845       /* Fill in the first three entries in the global offset table.  */
3846       if (htab->sgotplt->size > 0)
3847         {
3848           bfd_put_32 (output_bfd,
3849                       (sdyn == NULL ? 0
3850                        : sdyn->output_section->vma + sdyn->output_offset),
3851                       htab->sgotplt->contents);
3852           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3853           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3854         }
3855
3856       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3857     }
3858
3859   if (htab->sgot && htab->sgot->size > 0)
3860     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3861
3862   return TRUE;
3863 }
3864
3865 /* Return address for Ith PLT stub in section PLT, for relocation REL
3866    or (bfd_vma) -1 if it should not be included.  */
3867
3868 static bfd_vma
3869 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
3870                       const arelent *rel ATTRIBUTE_UNUSED)
3871 {
3872   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3873 }
3874
3875
3876 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3877 #define TARGET_LITTLE_NAME              "elf32-i386"
3878 #define ELF_ARCH                        bfd_arch_i386
3879 #define ELF_MACHINE_CODE                EM_386
3880 #define ELF_MAXPAGESIZE                 0x1000
3881
3882 #define elf_backend_can_gc_sections     1
3883 #define elf_backend_can_refcount        1
3884 #define elf_backend_want_got_plt        1
3885 #define elf_backend_plt_readonly        1
3886 #define elf_backend_want_plt_sym        0
3887 #define elf_backend_got_header_size     12
3888
3889 /* Support RELA for objdump of prelink objects.  */
3890 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3891 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3892
3893 #define bfd_elf32_mkobject                    elf_i386_mkobject
3894
3895 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3896 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3897 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3898
3899 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3900 #define elf_backend_check_relocs              elf_i386_check_relocs
3901 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3902 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3903 #define elf_backend_fake_sections             elf_i386_fake_sections
3904 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3905 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3906 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3907 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3908 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3909 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3910 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3911 #define elf_backend_relocate_section          elf_i386_relocate_section
3912 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3913 #define elf_backend_always_size_sections      elf_i386_always_size_sections
3914 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
3915
3916 #include "elf32-target.h"
3917
3918 /* FreeBSD support.  */
3919
3920 #undef  TARGET_LITTLE_SYM
3921 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3922 #undef  TARGET_LITTLE_NAME
3923 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3924
3925 /* The kernel recognizes executables as valid only if they carry a
3926    "FreeBSD" label in the ELF header.  So we put this label on all
3927    executables and (for simplicity) also all other object files.  */
3928
3929 static void
3930 elf_i386_post_process_headers (bfd *abfd,
3931                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3932 {
3933   Elf_Internal_Ehdr *i_ehdrp;
3934
3935   i_ehdrp = elf_elfheader (abfd);
3936
3937   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3938   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3939 #ifdef OLD_FREEBSD_ABI_LABEL
3940   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3941   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3942 #endif
3943 }
3944
3945 #undef  elf_backend_post_process_headers
3946 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3947 #undef  elf32_bed
3948 #define elf32_bed                               elf32_i386_fbsd_bed
3949
3950 #include "elf32-target.h"
3951
3952 /* VxWorks support.  */
3953
3954 #undef  TARGET_LITTLE_SYM
3955 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
3956 #undef  TARGET_LITTLE_NAME
3957 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
3958
3959
3960 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks.  */
3961
3962 static struct bfd_link_hash_table *
3963 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3964 {
3965   struct bfd_link_hash_table *ret;
3966   struct elf_i386_link_hash_table *htab;
3967
3968   ret = elf_i386_link_hash_table_create (abfd);
3969   if (ret)
3970     {
3971       htab = (struct elf_i386_link_hash_table *) ret;
3972       htab->is_vxworks = 1;
3973       htab->plt0_pad_byte = 0x90;
3974     }
3975
3976   return ret;
3977 }
3978
3979
3980 #undef  elf_backend_post_process_headers
3981 #undef bfd_elf32_bfd_link_hash_table_create
3982 #define bfd_elf32_bfd_link_hash_table_create \
3983   elf_i386_vxworks_link_hash_table_create
3984 #undef elf_backend_add_symbol_hook
3985 #define elf_backend_add_symbol_hook \
3986   elf_vxworks_add_symbol_hook
3987 #undef elf_backend_link_output_symbol_hook
3988 #define elf_backend_link_output_symbol_hook \
3989   elf_vxworks_link_output_symbol_hook
3990 #undef elf_backend_emit_relocs
3991 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
3992 #undef elf_backend_final_write_processing
3993 #define elf_backend_final_write_processing \
3994   elf_vxworks_final_write_processing
3995
3996 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3997    define it.  */
3998 #undef elf_backend_want_plt_sym
3999 #define elf_backend_want_plt_sym        1
4000
4001 #undef  elf32_bed
4002 #define elf32_bed                               elf32_i386_vxworks_bed
4003
4004 #include "elf32-target.h"