bfd/elf32-i386.c

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