contrib/gdb-7/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, 2008, 2009, 2010, 2011, 2012
   4    Free Software Foundation, Inc.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28 #include "elf-nacl.h"
  29 #include "elf-vxworks.h"
  30 #include "bfd_stdint.h"
  31 #include "objalloc.h"
  32 #include "hashtab.h"
  33 #include "dwarf2.h"
  34
  35 /* 386 uses REL relocations instead of RELA.  */
  36 #define USE_REL 1
  37
  38 #include "elf/i386.h"
  39
  40 static reloc_howto_type elf_howto_table[]=
  41 {
  42   HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
  43         bfd_elf_generic_reloc, "R_386_NONE",
  44         TRUE, 0x00000000, 0x00000000, FALSE),
  45   HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  46         bfd_elf_generic_reloc, "R_386_32",
  47         TRUE, 0xffffffff, 0xffffffff, FALSE),
  48   HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  49         bfd_elf_generic_reloc, "R_386_PC32",
  50         TRUE, 0xffffffff, 0xffffffff, TRUE),
  51   HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  52         bfd_elf_generic_reloc, "R_386_GOT32",
  53         TRUE, 0xffffffff, 0xffffffff, FALSE),
  54   HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  55         bfd_elf_generic_reloc, "R_386_PLT32",
  56         TRUE, 0xffffffff, 0xffffffff, TRUE),
  57   HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  58         bfd_elf_generic_reloc, "R_386_COPY",
  59         TRUE, 0xffffffff, 0xffffffff, FALSE),
  60   HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  61         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
  62         TRUE, 0xffffffff, 0xffffffff, FALSE),
  63   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  64         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
  65         TRUE, 0xffffffff, 0xffffffff, FALSE),
  66   HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  67         bfd_elf_generic_reloc, "R_386_RELATIVE",
  68         TRUE, 0xffffffff, 0xffffffff, FALSE),
  69   HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  70         bfd_elf_generic_reloc, "R_386_GOTOFF",
  71         TRUE, 0xffffffff, 0xffffffff, FALSE),
  72   HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  73         bfd_elf_generic_reloc, "R_386_GOTPC",
  74         TRUE, 0xffffffff, 0xffffffff, TRUE),
  75
  76   /* We have a gap in the reloc numbers here.
  77      R_386_standard counts the number up to this point, and
  78      R_386_ext_offset is the value to subtract from a reloc type of
  79      R_386_16 thru R_386_PC8 to form an index into this table.  */
  80 #define R_386_standard (R_386_GOTPC + 1)
  81 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
  82
  83   /* These relocs are a GNU extension.  */
  84   HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  85         bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
  86         TRUE, 0xffffffff, 0xffffffff, FALSE),
  87   HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  88         bfd_elf_generic_reloc, "R_386_TLS_IE",
  89         TRUE, 0xffffffff, 0xffffffff, FALSE),
  90   HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  91         bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
  92         TRUE, 0xffffffff, 0xffffffff, FALSE),
  93   HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  94         bfd_elf_generic_reloc, "R_386_TLS_LE",
  95         TRUE, 0xffffffff, 0xffffffff, FALSE),
  96   HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  97         bfd_elf_generic_reloc, "R_386_TLS_GD",
  98         TRUE, 0xffffffff, 0xffffffff, FALSE),
  99   HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 100         bfd_elf_generic_reloc, "R_386_TLS_LDM",
 101         TRUE, 0xffffffff, 0xffffffff, FALSE),
 102   HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 103         bfd_elf_generic_reloc, "R_386_16",
 104         TRUE, 0xffff, 0xffff, FALSE),
 105   HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
 106         bfd_elf_generic_reloc, "R_386_PC16",
 107         TRUE, 0xffff, 0xffff, TRUE),
 108   HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
 109         bfd_elf_generic_reloc, "R_386_8",
 110         TRUE, 0xff, 0xff, FALSE),
 111   HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
 112         bfd_elf_generic_reloc, "R_386_PC8",
 113         TRUE, 0xff, 0xff, TRUE),
 114
 115 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
 116 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
 117   /* These are common with Solaris TLS implementation.  */
 118   HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 119         bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
 120         TRUE, 0xffffffff, 0xffffffff, FALSE),
 121   HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 122         bfd_elf_generic_reloc, "R_386_TLS_IE_32",
 123         TRUE, 0xffffffff, 0xffffffff, FALSE),
 124   HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 125         bfd_elf_generic_reloc, "R_386_TLS_LE_32",
 126         TRUE, 0xffffffff, 0xffffffff, FALSE),
 127   HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 128         bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
 129         TRUE, 0xffffffff, 0xffffffff, FALSE),
 130   HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 131         bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
 132         TRUE, 0xffffffff, 0xffffffff, FALSE),
 133   HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 134         bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
 135         TRUE, 0xffffffff, 0xffffffff, FALSE),
 136   HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
 137         bfd_elf_generic_reloc, "R_386_SIZE32",
 138         TRUE, 0xffffffff, 0xffffffff, FALSE),
 139   HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 140         bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
 141         TRUE, 0xffffffff, 0xffffffff, FALSE),
 142   HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 143         bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
 144         FALSE, 0, 0, FALSE),
 145   HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 146         bfd_elf_generic_reloc, "R_386_TLS_DESC",
 147         TRUE, 0xffffffff, 0xffffffff, FALSE),
 148   HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 149         bfd_elf_generic_reloc, "R_386_IRELATIVE",
 150         TRUE, 0xffffffff, 0xffffffff, FALSE),
 151
 152   /* Another gap.  */
 153 #define R_386_irelative (R_386_IRELATIVE + 1 - R_386_tls_offset)
 154 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_irelative)
 155
 156 /* GNU extension to record C++ vtable hierarchy.  */
 157   HOWTO (R_386_GNU_VTINHERIT,   /* type */
 158          0,                     /* rightshift */
 159          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 160          0,                     /* bitsize */
 161          FALSE,                 /* pc_relative */
 162          0,                     /* bitpos */
 163          complain_overflow_dont, /* complain_on_overflow */
 164          NULL,                  /* special_function */
 165          "R_386_GNU_VTINHERIT", /* name */
 166          FALSE,                 /* partial_inplace */
 167          0,                     /* src_mask */
 168          0,                     /* dst_mask */
 169          FALSE),                /* pcrel_offset */
 170
 171 /* GNU extension to record C++ vtable member usage.  */
 172   HOWTO (R_386_GNU_VTENTRY,     /* type */
 173          0,                     /* rightshift */
 174          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 175          0,                     /* bitsize */
 176          FALSE,                 /* pc_relative */
 177          0,                     /* bitpos */
 178          complain_overflow_dont, /* complain_on_overflow */
 179          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 180          "R_386_GNU_VTENTRY",   /* name */
 181          FALSE,                 /* partial_inplace */
 182          0,                     /* src_mask */
 183          0,                     /* dst_mask */
 184          FALSE)                 /* pcrel_offset */
 185
 186 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
 187
 188 };
 189
 190 #ifdef DEBUG_GEN_RELOC
 191 #define TRACE(str) \
 192   fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 193 #else
 194 #define TRACE(str)
 195 #endif
 196
 197 static reloc_howto_type *
 198 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 199                             bfd_reloc_code_real_type code)
 200 {
 201   switch (code)
 202     {
 203     case BFD_RELOC_NONE:
 204       TRACE ("BFD_RELOC_NONE");
 205       return &elf_howto_table[R_386_NONE];
 206
 207     case BFD_RELOC_32:
 208       TRACE ("BFD_RELOC_32");
 209       return &elf_howto_table[R_386_32];
 210
 211     case BFD_RELOC_CTOR:
 212       TRACE ("BFD_RELOC_CTOR");
 213       return &elf_howto_table[R_386_32];
 214
 215     case BFD_RELOC_32_PCREL:
 216       TRACE ("BFD_RELOC_PC32");
 217       return &elf_howto_table[R_386_PC32];
 218
 219     case BFD_RELOC_386_GOT32:
 220       TRACE ("BFD_RELOC_386_GOT32");
 221       return &elf_howto_table[R_386_GOT32];
 222
 223     case BFD_RELOC_386_PLT32:
 224       TRACE ("BFD_RELOC_386_PLT32");
 225       return &elf_howto_table[R_386_PLT32];
 226
 227     case BFD_RELOC_386_COPY:
 228       TRACE ("BFD_RELOC_386_COPY");
 229       return &elf_howto_table[R_386_COPY];
 230
 231     case BFD_RELOC_386_GLOB_DAT:
 232       TRACE ("BFD_RELOC_386_GLOB_DAT");
 233       return &elf_howto_table[R_386_GLOB_DAT];
 234
 235     case BFD_RELOC_386_JUMP_SLOT:
 236       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 237       return &elf_howto_table[R_386_JUMP_SLOT];
 238
 239     case BFD_RELOC_386_RELATIVE:
 240       TRACE ("BFD_RELOC_386_RELATIVE");
 241       return &elf_howto_table[R_386_RELATIVE];
 242
 243     case BFD_RELOC_386_GOTOFF:
 244       TRACE ("BFD_RELOC_386_GOTOFF");
 245       return &elf_howto_table[R_386_GOTOFF];
 246
 247     case BFD_RELOC_386_GOTPC:
 248       TRACE ("BFD_RELOC_386_GOTPC");
 249       return &elf_howto_table[R_386_GOTPC];
 250
 251       /* These relocs are a GNU extension.  */
 252     case BFD_RELOC_386_TLS_TPOFF:
 253       TRACE ("BFD_RELOC_386_TLS_TPOFF");
 254       return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
 255
 256     case BFD_RELOC_386_TLS_IE:
 257       TRACE ("BFD_RELOC_386_TLS_IE");
 258       return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
 259
 260     case BFD_RELOC_386_TLS_GOTIE:
 261       TRACE ("BFD_RELOC_386_TLS_GOTIE");
 262       return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
 263
 264     case BFD_RELOC_386_TLS_LE:
 265       TRACE ("BFD_RELOC_386_TLS_LE");
 266       return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
 267
 268     case BFD_RELOC_386_TLS_GD:
 269       TRACE ("BFD_RELOC_386_TLS_GD");
 270       return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
 271
 272     case BFD_RELOC_386_TLS_LDM:
 273       TRACE ("BFD_RELOC_386_TLS_LDM");
 274       return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
 275
 276     case BFD_RELOC_16:
 277       TRACE ("BFD_RELOC_16");
 278       return &elf_howto_table[R_386_16 - R_386_ext_offset];
 279
 280     case BFD_RELOC_16_PCREL:
 281       TRACE ("BFD_RELOC_16_PCREL");
 282       return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
 283
 284     case BFD_RELOC_8:
 285       TRACE ("BFD_RELOC_8");
 286       return &elf_howto_table[R_386_8 - R_386_ext_offset];
 287
 288     case BFD_RELOC_8_PCREL:
 289       TRACE ("BFD_RELOC_8_PCREL");
 290       return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
 291
 292     /* Common with Sun TLS implementation.  */
 293     case BFD_RELOC_386_TLS_LDO_32:
 294       TRACE ("BFD_RELOC_386_TLS_LDO_32");
 295       return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
 296
 297     case BFD_RELOC_386_TLS_IE_32:
 298       TRACE ("BFD_RELOC_386_TLS_IE_32");
 299       return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
 300
 301     case BFD_RELOC_386_TLS_LE_32:
 302       TRACE ("BFD_RELOC_386_TLS_LE_32");
 303       return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
 304
 305     case BFD_RELOC_386_TLS_DTPMOD32:
 306       TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
 307       return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
 308
 309     case BFD_RELOC_386_TLS_DTPOFF32:
 310       TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
 311       return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
 312
 313     case BFD_RELOC_386_TLS_TPOFF32:
 314       TRACE ("BFD_RELOC_386_TLS_TPOFF32");
 315       return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
 316
 317     case BFD_RELOC_SIZE32:
 318       TRACE ("BFD_RELOC_SIZE32");
 319       return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
 320
 321     case BFD_RELOC_386_TLS_GOTDESC:
 322       TRACE ("BFD_RELOC_386_TLS_GOTDESC");
 323       return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
 324
 325     case BFD_RELOC_386_TLS_DESC_CALL:
 326       TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
 327       return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
 328
 329     case BFD_RELOC_386_TLS_DESC:
 330       TRACE ("BFD_RELOC_386_TLS_DESC");
 331       return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
 332
 333     case BFD_RELOC_386_IRELATIVE:
 334       TRACE ("BFD_RELOC_386_IRELATIVE");
 335       return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
 336
 337     case BFD_RELOC_VTABLE_INHERIT:
 338       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 339       return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
 340
 341     case BFD_RELOC_VTABLE_ENTRY:
 342       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 343       return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
 344
 345     default:
 346       break;
 347     }
 348
 349   TRACE ("Unknown");
 350   return 0;
 351 }
 352
 353 static reloc_howto_type *
 354 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 355                             const char *r_name)
 356 {
 357   unsigned int i;
 358
 359   for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
 360     if (elf_howto_table[i].name != NULL
 361         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 362       return &elf_howto_table[i];
 363
 364   return NULL;
 365 }
 366
 367 static reloc_howto_type *
 368 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
 369 {
 370   unsigned int indx;
 371
 372   if ((indx = r_type) >= R_386_standard
 373       && ((indx = r_type - R_386_ext_offset) - R_386_standard
 374           >= R_386_ext - R_386_standard)
 375       && ((indx = r_type - R_386_tls_offset) - R_386_ext
 376           >= R_386_irelative - R_386_ext)
 377       && ((indx = r_type - R_386_vt_offset) - R_386_irelative
 378           >= R_386_vt - R_386_irelative))
 379     {
 380       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 381                              abfd, (int) r_type);
 382       indx = R_386_NONE;
 383     }
 384   BFD_ASSERT (elf_howto_table [indx].type == r_type);
 385   return &elf_howto_table[indx];
 386 }
 387
 388 static void
 389 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
 390                             arelent *cache_ptr,
 391                             Elf_Internal_Rela *dst)
 392 {
 393   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 394   cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
 395 }
 396
 397 /* Return whether a symbol name implies a local label.  The UnixWare
 398    2.1 cc generates temporary symbols that start with .X, so we
 399    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
 400    If so, we should move the .X recognition into
 401    _bfd_elf_is_local_label_name.  */
 402
 403 static bfd_boolean
 404 elf_i386_is_local_label_name (bfd *abfd, const char *name)
 405 {
 406   if (name[0] == '.' && name[1] == 'X')
 407     return TRUE;
 408
 409   return _bfd_elf_is_local_label_name (abfd, name);
 410 }
 411 \f
 412 /* Support for core dump NOTE sections.  */
 413
 414 static bfd_boolean
 415 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 416 {
 417   int offset;
 418   size_t size;
 419
 420   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
 421     {
 422       int pr_version = bfd_get_32 (abfd, note->descdata);
 423
 424       if (pr_version != 1)
 425         return FALSE;
 426
 427       /* pr_cursig */
 428       elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
 429
 430       /* pr_pid */
 431       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
 432
 433       /* pr_reg */
 434       offset = 28;
 435       size = bfd_get_32 (abfd, note->descdata + 8);
 436     }
 437   else
 438     {
 439       switch (note->descsz)
 440         {
 441         default:
 442           return FALSE;
 443
 444         case 144:               /* Linux/i386 */
 445           /* pr_cursig */
 446           elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
 447
 448           /* pr_pid */
 449           elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
 450
 451           /* pr_reg */
 452           offset = 72;
 453           size = 68;
 454
 455           break;
 456         }
 457     }
 458
 459   /* Make a ".reg/999" section.  */
 460   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 461                                           size, note->descpos + offset);
 462 }
 463
 464 static bfd_boolean
 465 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 466 {
 467   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
 468     {
 469       int pr_version = bfd_get_32 (abfd, note->descdata);
 470
 471       if (pr_version != 1)
 472         return FALSE;
 473
 474       elf_tdata (abfd)->core->program
 475         = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
 476       elf_tdata (abfd)->core->command
 477         = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
 478     }
 479   else
 480     {
 481       switch (note->descsz)
 482         {
 483         default:
 484           return FALSE;
 485
 486         case 124:               /* Linux/i386 elf_prpsinfo.  */
 487           elf_tdata (abfd)->core->pid
 488             = bfd_get_32 (abfd, note->descdata + 12);
 489           elf_tdata (abfd)->core->program
 490             = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 491           elf_tdata (abfd)->core->command
 492             = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 493         }
 494     }
 495
 496   /* Note that for some reason, a spurious space is tacked
 497      onto the end of the args in some (at least one anyway)
 498      implementations, so strip it off if it exists.  */
 499   {
 500     char *command = elf_tdata (abfd)->core->command;
 501     int n = strlen (command);
 502
 503     if (0 < n && command[n - 1] == ' ')
 504       command[n - 1] = '\0';
 505   }
 506
 507   return TRUE;
 508 }
 509 \f
 510 /* Functions for the i386 ELF linker.
 511
 512    In order to gain some understanding of code in this file without
 513    knowing all the intricate details of the linker, note the
 514    following:
 515
 516    Functions named elf_i386_* are called by external routines, other
 517    functions are only called locally.  elf_i386_* functions appear
 518    in this file more or less in the order in which they are called
 519    from external routines.  eg. elf_i386_check_relocs is called
 520    early in the link process, elf_i386_finish_dynamic_sections is
 521    one of the last functions.  */
 522
 523
 524 /* The name of the dynamic interpreter.  This is put in the .interp
 525    section.  */
 526
 527 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 528
 529 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 530    copying dynamic variables from a shared lib into an app's dynbss
 531    section, and instead use a dynamic relocation to point into the
 532    shared lib.  */
 533 #define ELIMINATE_COPY_RELOCS 1
 534
 535 /* The size in bytes of an entry in the procedure linkage table.  */
 536
 537 #define PLT_ENTRY_SIZE 16
 538
 539 /* The first entry in an absolute procedure linkage table looks like
 540    this.  See the SVR4 ABI i386 supplement to see how this works.
 541    Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte.  */
 542
 543 static const bfd_byte elf_i386_plt0_entry[12] =
 544 {
 545   0xff, 0x35,   /* pushl contents of address */
 546   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 547   0xff, 0x25,   /* jmp indirect */
 548   0, 0, 0, 0    /* replaced with address of .got + 8.  */
 549 };
 550
 551 /* Subsequent entries in an absolute procedure linkage table look like
 552    this.  */
 553
 554 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
 555 {
 556   0xff, 0x25,   /* jmp indirect */
 557   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 558   0x68,         /* pushl immediate */
 559   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 560   0xe9,         /* jmp relative */
 561   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 562 };
 563
 564 /* The first entry in a PIC procedure linkage table look like this.
 565    Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte.  */
 566
 567 static const bfd_byte elf_i386_pic_plt0_entry[12] =
 568 {
 569   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 570   0xff, 0xa3, 8, 0, 0, 0        /* jmp *8(%ebx) */
 571 };
 572
 573 /* Subsequent entries in a PIC procedure linkage table look like this.  */
 574
 575 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
 576 {
 577   0xff, 0xa3,   /* jmp *offset(%ebx) */
 578   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 579   0x68,         /* pushl immediate */
 580   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 581   0xe9,         /* jmp relative */
 582   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 583 };
 584
 585 /* .eh_frame covering the .plt section.  */
 586
 587 static const bfd_byte elf_i386_eh_frame_plt[] =
 588 {
 589 #define PLT_CIE_LENGTH          20
 590 #define PLT_FDE_LENGTH          36
 591 #define PLT_FDE_START_OFFSET    4 + PLT_CIE_LENGTH + 8
 592 #define PLT_FDE_LEN_OFFSET      4 + PLT_CIE_LENGTH + 12
 593   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 594   0, 0, 0, 0,                   /* CIE ID */
 595   1,                            /* CIE version */
 596   'z', 'R', 0,                  /* Augmentation string */
 597   1,                            /* Code alignment factor */
 598   0x7c,                         /* Data alignment factor */
 599   8,                            /* Return address column */
 600   1,                            /* Augmentation size */
 601   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 602   DW_CFA_def_cfa, 4, 4,         /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
 603   DW_CFA_offset + 8, 1,         /* DW_CFA_offset: r8 (eip) at cfa-4 */
 604   DW_CFA_nop, DW_CFA_nop,
 605
 606   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 607   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 608   0, 0, 0, 0,                   /* R_386_PC32 .plt goes here */
 609   0, 0, 0, 0,                   /* .plt size goes here */
 610   0,                            /* Augmentation size */
 611   DW_CFA_def_cfa_offset, 8,     /* DW_CFA_def_cfa_offset: 8 */
 612   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 613   DW_CFA_def_cfa_offset, 12,    /* DW_CFA_def_cfa_offset: 12 */
 614   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 615   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 616   11,                           /* Block length */
 617   DW_OP_breg4, 4,               /* DW_OP_breg4 (esp): 4 */
 618   DW_OP_breg8, 0,               /* DW_OP_breg8 (eip): 0 */
 619   DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
 620   DW_OP_lit2, DW_OP_shl, DW_OP_plus,
 621   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 622 };
 623
 624 struct elf_i386_plt_layout
 625 {
 626   /* The first entry in an absolute procedure linkage table looks like this.  */
 627   const bfd_byte *plt0_entry;
 628   unsigned int plt0_entry_size;
 629
 630   /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2].  */
 631   unsigned int plt0_got1_offset;
 632   unsigned int plt0_got2_offset;
 633
 634   /* Later entries in an absolute procedure linkage table look like this.  */
 635   const bfd_byte *plt_entry;
 636   unsigned int plt_entry_size;
 637
 638   /* Offsets into plt_entry that are to be replaced with...  */
 639   unsigned int plt_got_offset;    /* ... address of this symbol in .got. */
 640   unsigned int plt_reloc_offset;  /* ... offset into relocation table. */
 641   unsigned int plt_plt_offset;    /* ... offset to start of .plt. */
 642
 643   /* Offset into plt_entry where the initial value of the GOT entry points.  */
 644   unsigned int plt_lazy_offset;
 645
 646   /* The first entry in a PIC procedure linkage table looks like this.  */
 647   const bfd_byte *pic_plt0_entry;
 648
 649   /* Subsequent entries in a PIC procedure linkage table look like this.  */
 650   const bfd_byte *pic_plt_entry;
 651
 652   /* .eh_frame covering the .plt section.  */
 653   const bfd_byte *eh_frame_plt;
 654   unsigned int eh_frame_plt_size;
 655 };
 656
 657 #define GET_PLT_ENTRY_SIZE(abfd) \
 658   get_elf_i386_backend_data (abfd)->plt->plt_entry_size
 659
 660 /* These are the standard parameters.  */
 661 static const struct elf_i386_plt_layout elf_i386_plt =
 662   {
 663     elf_i386_plt0_entry,                /* plt0_entry */
 664     sizeof (elf_i386_plt0_entry),       /* plt0_entry_size */
 665     2,                                  /* plt0_got1_offset */
 666     8,                                  /* plt0_got2_offset */
 667     elf_i386_plt_entry,                 /* plt_entry */
 668     PLT_ENTRY_SIZE,                     /* plt_entry_size */
 669     2,                                  /* plt_got_offset */
 670     7,                                  /* plt_reloc_offset */
 671     12,                                 /* plt_plt_offset */
 672     6,                                  /* plt_lazy_offset */
 673     elf_i386_pic_plt0_entry,            /* pic_plt0_entry */
 674     elf_i386_pic_plt_entry,             /* pic_plt_entry */
 675     elf_i386_eh_frame_plt,              /* eh_frame_plt */
 676     sizeof (elf_i386_eh_frame_plt),     /* eh_frame_plt_size */
 677   };
 678 \f
 679
 680 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
 681    for the PLTResolve stub and then for each PLT entry.  */
 682 #define PLTRESOLVE_RELOCS_SHLIB 0
 683 #define PLTRESOLVE_RELOCS 2
 684 #define PLT_NON_JUMP_SLOT_RELOCS 2
 685
 686 /* Architecture-specific backend data for i386.  */
 687
 688 struct elf_i386_backend_data
 689 {
 690   /* Parameters describing PLT generation.  */
 691   const struct elf_i386_plt_layout *plt;
 692
 693   /* Value used to fill the unused bytes of the first PLT entry.  */
 694   bfd_byte plt0_pad_byte;
 695
 696   /* True if the target system is VxWorks.  */
 697   int is_vxworks;
 698 };
 699
 700 #define get_elf_i386_backend_data(abfd) \
 701   ((const struct elf_i386_backend_data *) \
 702    get_elf_backend_data (abfd)->arch_data)
 703
 704 /* These are the standard parameters.  */
 705 static const struct elf_i386_backend_data elf_i386_arch_bed =
 706   {
 707     &elf_i386_plt,                      /* plt */
 708     0,                                  /* plt0_pad_byte */
 709     0,                                  /* is_vxworks */
 710   };
 711
 712 #define elf_backend_arch_data   &elf_i386_arch_bed
 713
 714 /* i386 ELF linker hash entry.  */
 715
 716 struct elf_i386_link_hash_entry
 717 {
 718   struct elf_link_hash_entry elf;
 719
 720   /* Track dynamic relocs copied for this symbol.  */
 721   struct elf_dyn_relocs *dyn_relocs;
 722
 723 #define GOT_UNKNOWN     0
 724 #define GOT_NORMAL      1
 725 #define GOT_TLS_GD      2
 726 #define GOT_TLS_IE      4
 727 #define GOT_TLS_IE_POS  5
 728 #define GOT_TLS_IE_NEG  6
 729 #define GOT_TLS_IE_BOTH 7
 730 #define GOT_TLS_GDESC   8
 731 #define GOT_TLS_GD_BOTH_P(type)                                         \
 732   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
 733 #define GOT_TLS_GD_P(type)                                              \
 734   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
 735 #define GOT_TLS_GDESC_P(type)                                           \
 736   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
 737 #define GOT_TLS_GD_ANY_P(type)                                          \
 738   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
 739   unsigned char tls_type;
 740
 741   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
 742      starting at the end of the jump table.  */
 743   bfd_vma tlsdesc_got;
 744 };
 745
 746 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
 747
 748 struct elf_i386_obj_tdata
 749 {
 750   struct elf_obj_tdata root;
 751
 752   /* tls_type for each local got entry.  */
 753   char *local_got_tls_type;
 754
 755   /* GOTPLT entries for TLS descriptors.  */
 756   bfd_vma *local_tlsdesc_gotent;
 757 };
 758
 759 #define elf_i386_tdata(abfd) \
 760   ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
 761
 762 #define elf_i386_local_got_tls_type(abfd) \
 763   (elf_i386_tdata (abfd)->local_got_tls_type)
 764
 765 #define elf_i386_local_tlsdesc_gotent(abfd) \
 766   (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
 767
 768 #define is_i386_elf(bfd)                                \
 769   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
 770    && elf_tdata (bfd) != NULL                           \
 771    && elf_object_id (bfd) == I386_ELF_DATA)
 772
 773 static bfd_boolean
 774 elf_i386_mkobject (bfd *abfd)
 775 {
 776   return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
 777                                   I386_ELF_DATA);
 778 }
 779
 780 /* i386 ELF linker hash table.  */
 781
 782 struct elf_i386_link_hash_table
 783 {
 784   struct elf_link_hash_table elf;
 785
 786   /* Short-cuts to get to dynamic linker sections.  */
 787   asection *sdynbss;
 788   asection *srelbss;
 789   asection *plt_eh_frame;
 790
 791   union
 792   {
 793     bfd_signed_vma refcount;
 794     bfd_vma offset;
 795   } tls_ldm_got;
 796
 797   /* The amount of space used by the reserved portion of the sgotplt
 798      section, plus whatever space is used by the jump slots.  */
 799   bfd_vma sgotplt_jump_table_size;
 800
 801   /* Small local sym cache.  */
 802   struct sym_cache sym_cache;
 803
 804   /* _TLS_MODULE_BASE_ symbol.  */
 805   struct bfd_link_hash_entry *tls_module_base;
 806
 807   /* Used by local STT_GNU_IFUNC symbols.  */
 808   htab_t loc_hash_table;
 809   void * loc_hash_memory;
 810
 811   /* The (unloaded but important) .rel.plt.unloaded section on VxWorks.  */
 812   asection *srelplt2;
 813
 814   /* The index of the next unused R_386_TLS_DESC slot in .rel.plt.  */
 815   bfd_vma next_tls_desc_index;
 816
 817   /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt.  */
 818   bfd_vma next_jump_slot_index;
 819
 820   /* The index of the next unused R_386_IRELATIVE slot in .rel.plt.  */
 821   bfd_vma next_irelative_index;
 822 };
 823
 824 /* Get the i386 ELF linker hash table from a link_info structure.  */
 825
 826 #define elf_i386_hash_table(p) \
 827   (elf_hash_table_id  ((struct elf_link_hash_table *) ((p)->hash)) \
 828   == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
 829
 830 #define elf_i386_compute_jump_table_size(htab) \
 831   ((htab)->next_tls_desc_index * 4)
 832
 833 /* Create an entry in an i386 ELF linker hash table.  */
 834
 835 static struct bfd_hash_entry *
 836 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
 837                             struct bfd_hash_table *table,
 838                             const char *string)
 839 {
 840   /* Allocate the structure if it has not already been allocated by a
 841      subclass.  */
 842   if (entry == NULL)
 843     {
 844       entry = (struct bfd_hash_entry *)
 845           bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
 846       if (entry == NULL)
 847         return entry;
 848     }
 849
 850   /* Call the allocation method of the superclass.  */
 851   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 852   if (entry != NULL)
 853     {
 854       struct elf_i386_link_hash_entry *eh;
 855
 856       eh = (struct elf_i386_link_hash_entry *) entry;
 857       eh->dyn_relocs = NULL;
 858       eh->tls_type = GOT_UNKNOWN;
 859       eh->tlsdesc_got = (bfd_vma) -1;
 860     }
 861
 862   return entry;
 863 }
 864
 865 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
 866   for local symbol so that we can handle local STT_GNU_IFUNC symbols
 867   as global symbol.  We reuse indx and dynstr_index for local symbol
 868   hash since they aren't used by global symbols in this backend.  */
 869
 870 static hashval_t
 871 elf_i386_local_htab_hash (const void *ptr)
 872 {
 873   struct elf_link_hash_entry *h
 874     = (struct elf_link_hash_entry *) ptr;
 875   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
 876 }
 877
 878 /* Compare local hash entries.  */
 879
 880 static int
 881 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
 882 {
 883   struct elf_link_hash_entry *h1
 884      = (struct elf_link_hash_entry *) ptr1;
 885   struct elf_link_hash_entry *h2
 886     = (struct elf_link_hash_entry *) ptr2;
 887
 888   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
 889 }
 890
 891 /* Find and/or create a hash entry for local symbol.  */
 892
 893 static struct elf_link_hash_entry *
 894 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
 895                              bfd *abfd, const Elf_Internal_Rela *rel,
 896                              bfd_boolean create)
 897 {
 898   struct elf_i386_link_hash_entry e, *ret;
 899   asection *sec = abfd->sections;
 900   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
 901                                        ELF32_R_SYM (rel->r_info));
 902   void **slot;
 903
 904   e.elf.indx = sec->id;
 905   e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
 906   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
 907                                    create ? INSERT : NO_INSERT);
 908
 909   if (!slot)
 910     return NULL;
 911
 912   if (*slot)
 913     {
 914       ret = (struct elf_i386_link_hash_entry *) *slot;
 915       return &ret->elf;
 916     }
 917
 918   ret = (struct elf_i386_link_hash_entry *)
 919         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
 920                         sizeof (struct elf_i386_link_hash_entry));
 921   if (ret)
 922     {
 923       memset (ret, 0, sizeof (*ret));
 924       ret->elf.indx = sec->id;
 925       ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
 926       ret->elf.dynindx = -1;
 927       *slot = ret;
 928     }
 929   return &ret->elf;
 930 }
 931
 932 /* Create an i386 ELF linker hash table.  */
 933
 934 static struct bfd_link_hash_table *
 935 elf_i386_link_hash_table_create (bfd *abfd)
 936 {
 937   struct elf_i386_link_hash_table *ret;
 938   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
 939
 940   ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
 941   if (ret == NULL)
 942     return NULL;
 943
 944   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
 945                                       elf_i386_link_hash_newfunc,
 946                                       sizeof (struct elf_i386_link_hash_entry),
 947                                       I386_ELF_DATA))
 948     {
 949       free (ret);
 950       return NULL;
 951     }
 952
 953   ret->loc_hash_table = htab_try_create (1024,
 954                                          elf_i386_local_htab_hash,
 955                                          elf_i386_local_htab_eq,
 956                                          NULL);
 957   ret->loc_hash_memory = objalloc_create ();
 958   if (!ret->loc_hash_table || !ret->loc_hash_memory)
 959     {
 960       free (ret);
 961       return NULL;
 962     }
 963
 964   return &ret->elf.root;
 965 }
 966
 967 /* Destroy an i386 ELF linker hash table.  */
 968
 969 static void
 970 elf_i386_link_hash_table_free (struct bfd_link_hash_table *hash)
 971 {
 972   struct elf_i386_link_hash_table *htab
 973     = (struct elf_i386_link_hash_table *) hash;
 974
 975   if (htab->loc_hash_table)
 976     htab_delete (htab->loc_hash_table);
 977   if (htab->loc_hash_memory)
 978     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
 979   _bfd_elf_link_hash_table_free (hash);
 980 }
 981
 982 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 983    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 984    hash table.  */
 985
 986 static bfd_boolean
 987 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 988 {
 989   struct elf_i386_link_hash_table *htab;
 990
 991   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 992     return FALSE;
 993
 994   htab = elf_i386_hash_table (info);
 995   if (htab == NULL)
 996     return FALSE;
 997
 998   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
 999   if (!info->shared)
1000     htab->srelbss = bfd_get_linker_section (dynobj, ".rel.bss");
1001
1002   if (!htab->sdynbss
1003       || (!info->shared && !htab->srelbss))
1004     abort ();
1005
1006   if (get_elf_i386_backend_data (dynobj)->is_vxworks
1007       && !elf_vxworks_create_dynamic_sections (dynobj, info,
1008                                                &htab->srelplt2))
1009     return FALSE;
1010
1011   if (!info->no_ld_generated_unwind_info
1012       && htab->plt_eh_frame == NULL
1013       && htab->elf.splt != NULL)
1014     {
1015       flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1016                         | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1017                         | SEC_LINKER_CREATED);
1018       htab->plt_eh_frame
1019         = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1020       if (htab->plt_eh_frame == NULL
1021           || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1022         return FALSE;
1023     }
1024
1025   return TRUE;
1026 }
1027
1028 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1029
1030 static void
1031 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1032                                struct elf_link_hash_entry *dir,
1033                                struct elf_link_hash_entry *ind)
1034 {
1035   struct elf_i386_link_hash_entry *edir, *eind;
1036
1037   edir = (struct elf_i386_link_hash_entry *) dir;
1038   eind = (struct elf_i386_link_hash_entry *) ind;
1039
1040   if (eind->dyn_relocs != NULL)
1041     {
1042       if (edir->dyn_relocs != NULL)
1043         {
1044           struct elf_dyn_relocs **pp;
1045           struct elf_dyn_relocs *p;
1046
1047           /* Add reloc counts against the indirect sym to the direct sym
1048              list.  Merge any entries against the same section.  */
1049           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1050             {
1051               struct elf_dyn_relocs *q;
1052
1053               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1054                 if (q->sec == p->sec)
1055                   {
1056                     q->pc_count += p->pc_count;
1057                     q->count += p->count;
1058                     *pp = p->next;
1059                     break;
1060                   }
1061               if (q == NULL)
1062                 pp = &p->next;
1063             }
1064           *pp = edir->dyn_relocs;
1065         }
1066
1067       edir->dyn_relocs = eind->dyn_relocs;
1068       eind->dyn_relocs = NULL;
1069     }
1070
1071   if (ind->root.type == bfd_link_hash_indirect
1072       && dir->got.refcount <= 0)
1073     {
1074       edir->tls_type = eind->tls_type;
1075       eind->tls_type = GOT_UNKNOWN;
1076     }
1077
1078   if (ELIMINATE_COPY_RELOCS
1079       && ind->root.type != bfd_link_hash_indirect
1080       && dir->dynamic_adjusted)
1081     {
1082       /* If called to transfer flags for a weakdef during processing
1083          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1084          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1085       dir->ref_dynamic |= ind->ref_dynamic;
1086       dir->ref_regular |= ind->ref_regular;
1087       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1088       dir->needs_plt |= ind->needs_plt;
1089       dir->pointer_equality_needed |= ind->pointer_equality_needed;
1090     }
1091   else
1092     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1093 }
1094
1095 /* Return TRUE if the TLS access code sequence support transition
1096    from R_TYPE.  */
1097
1098 static bfd_boolean
1099 elf_i386_check_tls_transition (bfd *abfd, asection *sec,
1100                                bfd_byte *contents,
1101                                Elf_Internal_Shdr *symtab_hdr,
1102                                struct elf_link_hash_entry **sym_hashes,
1103                                unsigned int r_type,
1104                                const Elf_Internal_Rela *rel,
1105                                const Elf_Internal_Rela *relend)
1106 {
1107   unsigned int val, type;
1108   unsigned long r_symndx;
1109   struct elf_link_hash_entry *h;
1110   bfd_vma offset;
1111
1112   /* Get the section contents.  */
1113   if (contents == NULL)
1114     {
1115       if (elf_section_data (sec)->this_hdr.contents != NULL)
1116         contents = elf_section_data (sec)->this_hdr.contents;
1117       else
1118         {
1119           /* FIXME: How to better handle error condition?  */
1120           if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1121             return FALSE;
1122
1123           /* Cache the section contents for elf_link_input_bfd.  */
1124           elf_section_data (sec)->this_hdr.contents = contents;
1125         }
1126     }
1127
1128   offset = rel->r_offset;
1129   switch (r_type)
1130     {
1131     case R_386_TLS_GD:
1132     case R_386_TLS_LDM:
1133       if (offset < 2 || (rel + 1) >= relend)
1134         return FALSE;
1135
1136       type = bfd_get_8 (abfd, contents + offset - 2);
1137       if (r_type == R_386_TLS_GD)
1138         {
1139           /* Check transition from GD access model.  Only
1140                 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1141                 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1142              can transit to different access model.  */
1143           if ((offset + 10) > sec->size ||
1144               (type != 0x8d && type != 0x04))
1145             return FALSE;
1146
1147           val = bfd_get_8 (abfd, contents + offset - 1);
1148           if (type == 0x04)
1149             {
1150               /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1151               if (offset < 3)
1152                 return FALSE;
1153
1154               if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1155                 return FALSE;
1156
1157               if ((val & 0xc7) != 0x05 || val == (4 << 3))
1158                 return FALSE;
1159             }
1160           else
1161             {
1162               /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop  */
1163               if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1164                 return FALSE;
1165
1166               if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1167                 return FALSE;
1168             }
1169         }
1170       else
1171         {
1172           /* Check transition from LD access model.  Only
1173                 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1174              can transit to different access model.  */
1175           if (type != 0x8d || (offset + 9) > sec->size)
1176             return FALSE;
1177
1178           val = bfd_get_8 (abfd, contents + offset - 1);
1179           if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1180             return FALSE;
1181         }
1182
1183       if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1184         return FALSE;
1185
1186       r_symndx = ELF32_R_SYM (rel[1].r_info);
1187       if (r_symndx < symtab_hdr->sh_info)
1188         return FALSE;
1189
1190       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1191       /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1192          may be versioned.  */
1193       return (h != NULL
1194               && h->root.root.string != NULL
1195               && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1196                   || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
1197               && (strncmp (h->root.root.string, "___tls_get_addr",
1198                            15) == 0));
1199
1200     case R_386_TLS_IE:
1201       /* Check transition from IE access model:
1202                 movl foo@indntpoff(%rip), %eax
1203                 movl foo@indntpoff(%rip), %reg
1204                 addl foo@indntpoff(%rip), %reg
1205        */
1206
1207       if (offset < 1 || (offset + 4) > sec->size)
1208         return FALSE;
1209
1210       /* Check "movl foo@tpoff(%rip), %eax" first.  */
1211       val = bfd_get_8 (abfd, contents + offset - 1);
1212       if (val == 0xa1)
1213         return TRUE;
1214
1215       if (offset < 2)
1216         return FALSE;
1217
1218       /* Check movl|addl foo@tpoff(%rip), %reg.   */
1219       type = bfd_get_8 (abfd, contents + offset - 2);
1220       return ((type == 0x8b || type == 0x03)
1221               && (val & 0xc7) == 0x05);
1222
1223     case R_386_TLS_GOTIE:
1224     case R_386_TLS_IE_32:
1225       /* Check transition from {IE_32,GOTIE} access model:
1226                 subl foo@{tpoff,gontoff}(%reg1), %reg2
1227                 movl foo@{tpoff,gontoff}(%reg1), %reg2
1228                 addl foo@{tpoff,gontoff}(%reg1), %reg2
1229        */
1230
1231       if (offset < 2 || (offset + 4) > sec->size)
1232         return FALSE;
1233
1234       val = bfd_get_8 (abfd, contents + offset - 1);
1235       if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1236         return FALSE;
1237
1238       type = bfd_get_8 (abfd, contents + offset - 2);
1239       return type == 0x8b || type == 0x2b || type == 0x03;
1240
1241     case R_386_TLS_GOTDESC:
1242       /* Check transition from GDesc access model:
1243                 leal x@tlsdesc(%ebx), %eax
1244
1245          Make sure it's a leal adding ebx to a 32-bit offset
1246          into any register, although it's probably almost always
1247          going to be eax.  */
1248
1249       if (offset < 2 || (offset + 4) > sec->size)
1250         return FALSE;
1251
1252       if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1253         return FALSE;
1254
1255       val = bfd_get_8 (abfd, contents + offset - 1);
1256       return (val & 0xc7) == 0x83;
1257
1258     case R_386_TLS_DESC_CALL:
1259       /* Check transition from GDesc access model:
1260                 call *x@tlsdesc(%rax)
1261        */
1262       if (offset + 2 <= sec->size)
1263         {
1264           /* Make sure that it's a call *x@tlsdesc(%rax).  */
1265           static const unsigned char call[] = { 0xff, 0x10 };
1266           return memcmp (contents + offset, call, 2) == 0;
1267         }
1268
1269       return FALSE;
1270
1271     default:
1272       abort ();
1273     }
1274 }
1275
1276 /* Return TRUE if the TLS access transition is OK or no transition
1277    will be performed.  Update R_TYPE if there is a transition.  */
1278
1279 static bfd_boolean
1280 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1281                          asection *sec, bfd_byte *contents,
1282                          Elf_Internal_Shdr *symtab_hdr,
1283                          struct elf_link_hash_entry **sym_hashes,
1284                          unsigned int *r_type, int tls_type,
1285                          const Elf_Internal_Rela *rel,
1286                          const Elf_Internal_Rela *relend,
1287                          struct elf_link_hash_entry *h,
1288                          unsigned long r_symndx)
1289 {
1290   unsigned int from_type = *r_type;
1291   unsigned int to_type = from_type;
1292   bfd_boolean check = TRUE;
1293
1294   /* Skip TLS transition for functions.  */
1295   if (h != NULL
1296       && (h->type == STT_FUNC
1297           || h->type == STT_GNU_IFUNC))
1298     return TRUE;
1299
1300   switch (from_type)
1301     {
1302     case R_386_TLS_GD:
1303     case R_386_TLS_GOTDESC:
1304     case R_386_TLS_DESC_CALL:
1305     case R_386_TLS_IE_32:
1306     case R_386_TLS_IE:
1307     case R_386_TLS_GOTIE:
1308       if (info->executable)
1309         {
1310           if (h == NULL)
1311             to_type = R_386_TLS_LE_32;
1312           else if (from_type != R_386_TLS_IE
1313                    && from_type != R_386_TLS_GOTIE)
1314             to_type = R_386_TLS_IE_32;
1315         }
1316
1317       /* When we are called from elf_i386_relocate_section, CONTENTS
1318          isn't NULL and there may be additional transitions based on
1319          TLS_TYPE.  */
1320       if (contents != NULL)
1321         {
1322           unsigned int new_to_type = to_type;
1323
1324           if (info->executable
1325               && h != NULL
1326               && h->dynindx == -1
1327               && (tls_type & GOT_TLS_IE))
1328             new_to_type = R_386_TLS_LE_32;
1329
1330           if (to_type == R_386_TLS_GD
1331               || to_type == R_386_TLS_GOTDESC
1332               || to_type == R_386_TLS_DESC_CALL)
1333             {
1334               if (tls_type == GOT_TLS_IE_POS)
1335                 new_to_type = R_386_TLS_GOTIE;
1336               else if (tls_type & GOT_TLS_IE)
1337                 new_to_type = R_386_TLS_IE_32;
1338             }
1339
1340           /* We checked the transition before when we were called from
1341              elf_i386_check_relocs.  We only want to check the new
1342              transition which hasn't been checked before.  */
1343           check = new_to_type != to_type && from_type == to_type;
1344           to_type = new_to_type;
1345         }
1346
1347       break;
1348
1349     case R_386_TLS_LDM:
1350       if (info->executable)
1351         to_type = R_386_TLS_LE_32;
1352       break;
1353
1354     default:
1355       return TRUE;
1356     }
1357
1358   /* Return TRUE if there is no transition.  */
1359   if (from_type == to_type)
1360     return TRUE;
1361
1362   /* Check if the transition can be performed.  */
1363   if (check
1364       && ! elf_i386_check_tls_transition (abfd, sec, contents,
1365                                           symtab_hdr, sym_hashes,
1366                                           from_type, rel, relend))
1367     {
1368       reloc_howto_type *from, *to;
1369       const char *name;
1370
1371       from = elf_i386_rtype_to_howto (abfd, from_type);
1372       to = elf_i386_rtype_to_howto (abfd, to_type);
1373
1374       if (h)
1375         name = h->root.root.string;
1376       else
1377         {
1378           struct elf_i386_link_hash_table *htab;
1379
1380           htab = elf_i386_hash_table (info);
1381           if (htab == NULL)
1382             name = "*unknown*";
1383           else
1384             {
1385               Elf_Internal_Sym *isym;
1386
1387               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1388                                             abfd, r_symndx);
1389               name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1390             }
1391         }
1392
1393       (*_bfd_error_handler)
1394         (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1395            "in section `%A' failed"),
1396          abfd, sec, from->name, to->name, name,
1397          (unsigned long) rel->r_offset);
1398       bfd_set_error (bfd_error_bad_value);
1399       return FALSE;
1400     }
1401
1402   *r_type = to_type;
1403   return TRUE;
1404 }
1405
1406 /* Look through the relocs for a section during the first phase, and
1407    calculate needed space in the global offset table, procedure linkage
1408    table, and dynamic reloc sections.  */
1409
1410 static bfd_boolean
1411 elf_i386_check_relocs (bfd *abfd,
1412                        struct bfd_link_info *info,
1413                        asection *sec,
1414                        const Elf_Internal_Rela *relocs)
1415 {
1416   struct elf_i386_link_hash_table *htab;
1417   Elf_Internal_Shdr *symtab_hdr;
1418   struct elf_link_hash_entry **sym_hashes;
1419   const Elf_Internal_Rela *rel;
1420   const Elf_Internal_Rela *rel_end;
1421   asection *sreloc;
1422
1423   if (info->relocatable)
1424     return TRUE;
1425
1426   BFD_ASSERT (is_i386_elf (abfd));
1427
1428   htab = elf_i386_hash_table (info);
1429   if (htab == NULL)
1430     return FALSE;
1431
1432   symtab_hdr = &elf_symtab_hdr (abfd);
1433   sym_hashes = elf_sym_hashes (abfd);
1434
1435   sreloc = NULL;
1436
1437   rel_end = relocs + sec->reloc_count;
1438   for (rel = relocs; rel < rel_end; rel++)
1439     {
1440       unsigned int r_type;
1441       unsigned long r_symndx;
1442       struct elf_link_hash_entry *h;
1443       Elf_Internal_Sym *isym;
1444       const char *name;
1445       bfd_boolean size_reloc;
1446
1447       r_symndx = ELF32_R_SYM (rel->r_info);
1448       r_type = ELF32_R_TYPE (rel->r_info);
1449
1450       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1451         {
1452           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1453                                  abfd,
1454                                  r_symndx);
1455           return FALSE;
1456         }
1457
1458       if (r_symndx < symtab_hdr->sh_info)
1459         {
1460           /* A local symbol.  */
1461           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1462                                         abfd, r_symndx);
1463           if (isym == NULL)
1464             return FALSE;
1465
1466           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1467           if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1468             {
1469               h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1470               if (h == NULL)
1471                 return FALSE;
1472
1473               /* Fake a STT_GNU_IFUNC symbol.  */
1474               h->type = STT_GNU_IFUNC;
1475               h->def_regular = 1;
1476               h->ref_regular = 1;
1477               h->forced_local = 1;
1478               h->root.type = bfd_link_hash_defined;
1479             }
1480           else
1481             h = NULL;
1482         }
1483       else
1484         {
1485           isym = NULL;
1486           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1487           while (h->root.type == bfd_link_hash_indirect
1488                  || h->root.type == bfd_link_hash_warning)
1489             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1490         }
1491
1492       if (h != NULL)
1493         {
1494           /* Create the ifunc sections for static executables.  If we
1495              never see an indirect function symbol nor we are building
1496              a static executable, those sections will be empty and
1497              won't appear in output.  */
1498           switch (r_type)
1499             {
1500             default:
1501               break;
1502
1503             case R_386_32:
1504             case R_386_PC32:
1505             case R_386_PLT32:
1506             case R_386_GOT32:
1507             case R_386_GOTOFF:
1508               if (htab->elf.dynobj == NULL)
1509                 htab->elf.dynobj = abfd;
1510               if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1511                 return FALSE;
1512               break;
1513             }
1514
1515           /* It is referenced by a non-shared object. */
1516           h->ref_regular = 1;
1517         }
1518
1519       if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1520                                      symtab_hdr, sym_hashes,
1521                                      &r_type, GOT_UNKNOWN,
1522                                      rel, rel_end, h, r_symndx))
1523         return FALSE;
1524
1525       switch (r_type)
1526         {
1527         case R_386_TLS_LDM:
1528           htab->tls_ldm_got.refcount += 1;
1529           goto create_got;
1530
1531         case R_386_PLT32:
1532           /* This symbol requires a procedure linkage table entry.  We
1533              actually build the entry in adjust_dynamic_symbol,
1534              because this might be a case of linking PIC code which is
1535              never referenced by a dynamic object, in which case we
1536              don't need to generate a procedure linkage table entry
1537              after all.  */
1538
1539           /* If this is a local symbol, we resolve it directly without
1540              creating a procedure linkage table entry.  */
1541           if (h == NULL)
1542             continue;
1543
1544           h->needs_plt = 1;
1545           h->plt.refcount += 1;
1546           break;
1547
1548         case R_386_SIZE32:
1549           size_reloc = TRUE;
1550           goto do_size;
1551
1552         case R_386_TLS_IE_32:
1553         case R_386_TLS_IE:
1554         case R_386_TLS_GOTIE:
1555           if (!info->executable)
1556             info->flags |= DF_STATIC_TLS;
1557           /* Fall through */
1558
1559         case R_386_GOT32:
1560         case R_386_TLS_GD:
1561         case R_386_TLS_GOTDESC:
1562         case R_386_TLS_DESC_CALL:
1563           /* This symbol requires a global offset table entry.  */
1564           {
1565             int tls_type, old_tls_type;
1566
1567             switch (r_type)
1568               {
1569               default:
1570               case R_386_GOT32: tls_type = GOT_NORMAL; break;
1571               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1572               case R_386_TLS_GOTDESC:
1573               case R_386_TLS_DESC_CALL:
1574                 tls_type = GOT_TLS_GDESC; break;
1575               case R_386_TLS_IE_32:
1576                 if (ELF32_R_TYPE (rel->r_info) == r_type)
1577                   tls_type = GOT_TLS_IE_NEG;
1578                 else
1579                   /* If this is a GD->IE transition, we may use either of
1580                      R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  */
1581                   tls_type = GOT_TLS_IE;
1582                 break;
1583               case R_386_TLS_IE:
1584               case R_386_TLS_GOTIE:
1585                 tls_type = GOT_TLS_IE_POS; break;
1586               }
1587
1588             if (h != NULL)
1589               {
1590                 h->got.refcount += 1;
1591                 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1592               }
1593             else
1594               {
1595                 bfd_signed_vma *local_got_refcounts;
1596
1597                 /* This is a global offset table entry for a local symbol.  */
1598                 local_got_refcounts = elf_local_got_refcounts (abfd);
1599                 if (local_got_refcounts == NULL)
1600                   {
1601                     bfd_size_type size;
1602
1603                     size = symtab_hdr->sh_info;
1604                     size *= (sizeof (bfd_signed_vma)
1605                              + sizeof (bfd_vma) + sizeof(char));
1606                     local_got_refcounts = (bfd_signed_vma *)
1607                         bfd_zalloc (abfd, size);
1608                     if (local_got_refcounts == NULL)
1609                       return FALSE;
1610                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1611                     elf_i386_local_tlsdesc_gotent (abfd)
1612                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1613                     elf_i386_local_got_tls_type (abfd)
1614                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1615                   }
1616                 local_got_refcounts[r_symndx] += 1;
1617                 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1618               }
1619
1620             if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1621               tls_type |= old_tls_type;
1622             /* If a TLS symbol is accessed using IE at least once,
1623                there is no point to use dynamic model for it.  */
1624             else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1625                      && (! GOT_TLS_GD_ANY_P (old_tls_type)
1626                          || (tls_type & GOT_TLS_IE) == 0))
1627               {
1628                 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1629                   tls_type = old_tls_type;
1630                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1631                          && GOT_TLS_GD_ANY_P (tls_type))
1632                   tls_type |= old_tls_type;
1633                 else
1634                   {
1635                     if (h)
1636                       name = h->root.root.string;
1637                     else
1638                       name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1639                                              NULL);
1640                     (*_bfd_error_handler)
1641                       (_("%B: `%s' accessed both as normal and "
1642                          "thread local symbol"),
1643                        abfd, name);
1644                     bfd_set_error (bfd_error_bad_value);
1645                     return FALSE;
1646                   }
1647               }
1648
1649             if (old_tls_type != tls_type)
1650               {
1651                 if (h != NULL)
1652                   elf_i386_hash_entry (h)->tls_type = tls_type;
1653                 else
1654                   elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1655               }
1656           }
1657           /* Fall through */
1658
1659         case R_386_GOTOFF:
1660         case R_386_GOTPC:
1661         create_got:
1662           if (htab->elf.sgot == NULL)
1663             {
1664               if (htab->elf.dynobj == NULL)
1665                 htab->elf.dynobj = abfd;
1666               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1667                 return FALSE;
1668             }
1669           if (r_type != R_386_TLS_IE)
1670             break;
1671           /* Fall through */
1672
1673         case R_386_TLS_LE_32:
1674         case R_386_TLS_LE:
1675           if (info->executable)
1676             break;
1677           info->flags |= DF_STATIC_TLS;
1678           /* Fall through */
1679
1680         case R_386_32:
1681         case R_386_PC32:
1682           if (h != NULL && info->executable)
1683             {
1684               /* If this reloc is in a read-only section, we might
1685                  need a copy reloc.  We can't check reliably at this
1686                  stage whether the section is read-only, as input
1687                  sections have not yet been mapped to output sections.
1688                  Tentatively set the flag for now, and correct in
1689                  adjust_dynamic_symbol.  */
1690               h->non_got_ref = 1;
1691
1692               /* We may need a .plt entry if the function this reloc
1693                  refers to is in a shared lib.  */
1694               h->plt.refcount += 1;
1695               if (r_type != R_386_PC32)
1696                 h->pointer_equality_needed = 1;
1697             }
1698
1699           size_reloc = FALSE;
1700 do_size:
1701           /* If we are creating a shared library, and this is a reloc
1702              against a global symbol, or a non PC relative reloc
1703              against a local symbol, then we need to copy the reloc
1704              into the shared library.  However, if we are linking with
1705              -Bsymbolic, we do not need to copy a reloc against a
1706              global symbol which is defined in an object we are
1707              including in the link (i.e., DEF_REGULAR is set).  At
1708              this point we have not seen all the input files, so it is
1709              possible that DEF_REGULAR is not set now but will be set
1710              later (it is never cleared).  In case of a weak definition,
1711              DEF_REGULAR may be cleared later by a strong definition in
1712              a shared library.  We account for that possibility below by
1713              storing information in the relocs_copied field of the hash
1714              table entry.  A similar situation occurs when creating
1715              shared libraries and symbol visibility changes render the
1716              symbol local.
1717
1718              If on the other hand, we are creating an executable, we
1719              may need to keep relocations for symbols satisfied by a
1720              dynamic library if we manage to avoid copy relocs for the
1721              symbol.  */
1722           if ((info->shared
1723                && (sec->flags & SEC_ALLOC) != 0
1724                && (r_type != R_386_PC32
1725                    || (h != NULL
1726                        && (! SYMBOLIC_BIND (info, h)
1727                            || h->root.type == bfd_link_hash_defweak
1728                            || !h->def_regular))))
1729               || (ELIMINATE_COPY_RELOCS
1730                   && !info->shared
1731                   && (sec->flags & SEC_ALLOC) != 0
1732                   && h != NULL
1733                   && (h->root.type == bfd_link_hash_defweak
1734                       || !h->def_regular)))
1735             {
1736               struct elf_dyn_relocs *p;
1737               struct elf_dyn_relocs **head;
1738
1739               /* We must copy these reloc types into the output file.
1740                  Create a reloc section in dynobj and make room for
1741                  this reloc.  */
1742               if (sreloc == NULL)
1743                 {
1744                   if (htab->elf.dynobj == NULL)
1745                     htab->elf.dynobj = abfd;
1746
1747                   sreloc = _bfd_elf_make_dynamic_reloc_section
1748                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1749
1750                   if (sreloc == NULL)
1751                     return FALSE;
1752                 }
1753
1754               /* If this is a global symbol, we count the number of
1755                  relocations we need for this symbol.  */
1756               if (h != NULL)
1757                 {
1758                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1759                 }
1760               else
1761                 {
1762                   /* Track dynamic relocs needed for local syms too.
1763                      We really need local syms available to do this
1764                      easily.  Oh well.  */
1765                   void **vpp;
1766                   asection *s;
1767
1768                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1769                                                 abfd, r_symndx);
1770                   if (isym == NULL)
1771                     return FALSE;
1772
1773                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1774                   if (s == NULL)
1775                     s = sec;
1776
1777                   vpp = &elf_section_data (s)->local_dynrel;
1778                   head = (struct elf_dyn_relocs **)vpp;
1779                 }
1780
1781               p = *head;
1782               if (p == NULL || p->sec != sec)
1783                 {
1784                   bfd_size_type amt = sizeof *p;
1785                   p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1786                                                            amt);
1787                   if (p == NULL)
1788                     return FALSE;
1789                   p->next = *head;
1790                   *head = p;
1791                   p->sec = sec;
1792                   p->count = 0;
1793                   p->pc_count = 0;
1794                 }
1795
1796               p->count += 1;
1797               /* Count size relocation as PC-relative relocation.  */
1798               if (r_type == R_386_PC32 || size_reloc)
1799                 p->pc_count += 1;
1800             }
1801           break;
1802
1803           /* This relocation describes the C++ object vtable hierarchy.
1804              Reconstruct it for later use during GC.  */
1805         case R_386_GNU_VTINHERIT:
1806           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1807             return FALSE;
1808           break;
1809
1810           /* This relocation describes which C++ vtable entries are actually
1811              used.  Record for later use during GC.  */
1812         case R_386_GNU_VTENTRY:
1813           BFD_ASSERT (h != NULL);
1814           if (h != NULL
1815               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1816             return FALSE;
1817           break;
1818
1819         default:
1820           break;
1821         }
1822     }
1823
1824   return TRUE;
1825 }
1826
1827 /* Return the section that should be marked against GC for a given
1828    relocation.  */
1829
1830 static asection *
1831 elf_i386_gc_mark_hook (asection *sec,
1832                        struct bfd_link_info *info,
1833                        Elf_Internal_Rela *rel,
1834                        struct elf_link_hash_entry *h,
1835                        Elf_Internal_Sym *sym)
1836 {
1837   if (h != NULL)
1838     switch (ELF32_R_TYPE (rel->r_info))
1839       {
1840       case R_386_GNU_VTINHERIT:
1841       case R_386_GNU_VTENTRY:
1842         return NULL;
1843       }
1844
1845   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1846 }
1847
1848 /* Update the got entry reference counts for the section being removed.  */
1849
1850 static bfd_boolean
1851 elf_i386_gc_sweep_hook (bfd *abfd,
1852                         struct bfd_link_info *info,
1853                         asection *sec,
1854                         const Elf_Internal_Rela *relocs)
1855 {
1856   struct elf_i386_link_hash_table *htab;
1857   Elf_Internal_Shdr *symtab_hdr;
1858   struct elf_link_hash_entry **sym_hashes;
1859   bfd_signed_vma *local_got_refcounts;
1860   const Elf_Internal_Rela *rel, *relend;
1861
1862   if (info->relocatable)
1863     return TRUE;
1864
1865   htab = elf_i386_hash_table (info);
1866   if (htab == NULL)
1867     return FALSE;
1868
1869   elf_section_data (sec)->local_dynrel = NULL;
1870
1871   symtab_hdr = &elf_symtab_hdr (abfd);
1872   sym_hashes = elf_sym_hashes (abfd);
1873   local_got_refcounts = elf_local_got_refcounts (abfd);
1874
1875   relend = relocs + sec->reloc_count;
1876   for (rel = relocs; rel < relend; rel++)
1877     {
1878       unsigned long r_symndx;
1879       unsigned int r_type;
1880       struct elf_link_hash_entry *h = NULL;
1881
1882       r_symndx = ELF32_R_SYM (rel->r_info);
1883       if (r_symndx >= symtab_hdr->sh_info)
1884         {
1885           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1886           while (h->root.type == bfd_link_hash_indirect
1887                  || h->root.type == bfd_link_hash_warning)
1888             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1889         }
1890       else
1891         {
1892           /* A local symbol.  */
1893           Elf_Internal_Sym *isym;
1894
1895           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1896                                         abfd, r_symndx);
1897
1898           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1899           if (isym != NULL
1900               && ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1901             {
1902               h = elf_i386_get_local_sym_hash (htab, abfd, rel, FALSE);
1903               if (h == NULL)
1904                 abort ();
1905             }
1906         }
1907
1908       if (h)
1909         {
1910           struct elf_i386_link_hash_entry *eh;
1911           struct elf_dyn_relocs **pp;
1912           struct elf_dyn_relocs *p;
1913
1914           eh = (struct elf_i386_link_hash_entry *) h;
1915           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1916             if (p->sec == sec)
1917               {
1918                 /* Everything must go for SEC.  */
1919                 *pp = p->next;
1920                 break;
1921               }
1922         }
1923
1924       r_type = ELF32_R_TYPE (rel->r_info);
1925       if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1926                                      symtab_hdr, sym_hashes,
1927                                      &r_type, GOT_UNKNOWN,
1928                                      rel, relend, h, r_symndx))
1929         return FALSE;
1930
1931       switch (r_type)
1932         {
1933         case R_386_TLS_LDM:
1934           if (htab->tls_ldm_got.refcount > 0)
1935             htab->tls_ldm_got.refcount -= 1;
1936           break;
1937
1938         case R_386_TLS_GD:
1939         case R_386_TLS_GOTDESC:
1940         case R_386_TLS_DESC_CALL:
1941         case R_386_TLS_IE_32:
1942         case R_386_TLS_IE:
1943         case R_386_TLS_GOTIE:
1944         case R_386_GOT32:
1945           if (h != NULL)
1946             {
1947               if (h->got.refcount > 0)
1948                 h->got.refcount -= 1;
1949               if (h->type == STT_GNU_IFUNC)
1950                 {
1951                   if (h->plt.refcount > 0)
1952                     h->plt.refcount -= 1;
1953                 }
1954             }
1955           else if (local_got_refcounts != NULL)
1956             {
1957               if (local_got_refcounts[r_symndx] > 0)
1958                 local_got_refcounts[r_symndx] -= 1;
1959             }
1960           break;
1961
1962         case R_386_32:
1963         case R_386_PC32:
1964         case R_386_SIZE32:
1965           if (info->shared
1966               && (h == NULL || h->type != STT_GNU_IFUNC))
1967             break;
1968           /* Fall through */
1969
1970         case R_386_PLT32:
1971           if (h != NULL)
1972             {
1973               if (h->plt.refcount > 0)
1974                 h->plt.refcount -= 1;
1975             }
1976           break;
1977
1978         case R_386_GOTOFF:
1979           if (h != NULL && h->type == STT_GNU_IFUNC)
1980             {
1981               if (h->got.refcount > 0)
1982                 h->got.refcount -= 1;
1983               if (h->plt.refcount > 0)
1984                 h->plt.refcount -= 1;
1985             }
1986           break;
1987
1988         default:
1989           break;
1990         }
1991     }
1992
1993   return TRUE;
1994 }
1995
1996 /* Adjust a symbol defined by a dynamic object and referenced by a
1997    regular object.  The current definition is in some section of the
1998    dynamic object, but we're not including those sections.  We have to
1999    change the definition to something the rest of the link can
2000    understand.  */
2001
2002 static bfd_boolean
2003 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2004                                 struct elf_link_hash_entry *h)
2005 {
2006   struct elf_i386_link_hash_table *htab;
2007   asection *s;
2008   struct elf_i386_link_hash_entry *eh;
2009   struct elf_dyn_relocs *p;
2010
2011   /* STT_GNU_IFUNC symbol must go through PLT. */
2012   if (h->type == STT_GNU_IFUNC)
2013     {
2014       /* All local STT_GNU_IFUNC references must be treate as local
2015          calls via local PLT.  */
2016       if (h->ref_regular
2017           && SYMBOL_CALLS_LOCAL (info, h))
2018         {
2019           bfd_size_type pc_count = 0, count = 0;
2020           struct elf_dyn_relocs **pp;
2021
2022           eh = (struct elf_i386_link_hash_entry *) h;
2023           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2024             {
2025               pc_count += p->pc_count;
2026               p->count -= p->pc_count;
2027               p->pc_count = 0;
2028               count += p->count;
2029               if (p->count == 0)
2030                 *pp = p->next;
2031               else
2032                 pp = &p->next;
2033             }
2034
2035           if (pc_count || count)
2036             {
2037               h->needs_plt = 1;
2038               h->non_got_ref = 1;
2039               if (h->plt.refcount <= 0)
2040                 h->plt.refcount = 1;
2041               else
2042                 h->plt.refcount += 1;
2043             }
2044         }
2045
2046       if (h->plt.refcount <= 0)
2047         {
2048           h->plt.offset = (bfd_vma) -1;
2049           h->needs_plt = 0;
2050         }
2051       return TRUE;
2052     }
2053
2054   /* If this is a function, put it in the procedure linkage table.  We
2055      will fill in the contents of the procedure linkage table later,
2056      when we know the address of the .got section.  */
2057   if (h->type == STT_FUNC
2058       || h->needs_plt)
2059     {
2060       if (h->plt.refcount <= 0
2061           || SYMBOL_CALLS_LOCAL (info, h)
2062           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2063               && h->root.type == bfd_link_hash_undefweak))
2064         {
2065           /* This case can occur if we saw a PLT32 reloc in an input
2066              file, but the symbol was never referred to by a dynamic
2067              object, or if all references were garbage collected.  In
2068              such a case, we don't actually need to build a procedure
2069              linkage table, and we can just do a PC32 reloc instead.  */
2070           h->plt.offset = (bfd_vma) -1;
2071           h->needs_plt = 0;
2072         }
2073
2074       return TRUE;
2075     }
2076   else
2077     /* It's possible that we incorrectly decided a .plt reloc was
2078        needed for an R_386_PC32 reloc to a non-function sym in
2079        check_relocs.  We can't decide accurately between function and
2080        non-function syms in check-relocs;  Objects loaded later in
2081        the link may change h->type.  So fix it now.  */
2082     h->plt.offset = (bfd_vma) -1;
2083
2084   /* If this is a weak symbol, and there is a real definition, the
2085      processor independent code will have arranged for us to see the
2086      real definition first, and we can just use the same value.  */
2087   if (h->u.weakdef != NULL)
2088     {
2089       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2090                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2091       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2092       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2093       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2094         h->non_got_ref = h->u.weakdef->non_got_ref;
2095       return TRUE;
2096     }
2097
2098   /* This is a reference to a symbol defined by a dynamic object which
2099      is not a function.  */
2100
2101   /* If we are creating a shared library, we must presume that the
2102      only references to the symbol are via the global offset table.
2103      For such cases we need not do anything here; the relocations will
2104      be handled correctly by relocate_section.  */
2105   if (info->shared)
2106     return TRUE;
2107
2108   /* If there are no references to this symbol that do not use the
2109      GOT, we don't need to generate a copy reloc.  */
2110   if (!h->non_got_ref)
2111     return TRUE;
2112
2113   /* If -z nocopyreloc was given, we won't generate them either.  */
2114   if (info->nocopyreloc)
2115     {
2116       h->non_got_ref = 0;
2117       return TRUE;
2118     }
2119
2120   htab = elf_i386_hash_table (info);
2121   if (htab == NULL)
2122     return FALSE;
2123
2124   /* If there aren't any dynamic relocs in read-only sections, then
2125      we can keep the dynamic relocs and avoid the copy reloc.  This
2126      doesn't work on VxWorks, where we can not have dynamic relocations
2127      (other than copy and jump slot relocations) in an executable.  */
2128   if (ELIMINATE_COPY_RELOCS
2129       && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2130     {
2131       eh = (struct elf_i386_link_hash_entry *) h;
2132       for (p = eh->dyn_relocs; p != NULL; p = p->next)
2133         {
2134           s = p->sec->output_section;
2135           if (s != NULL && (s->flags & SEC_READONLY) != 0)
2136             break;
2137         }
2138
2139       if (p == NULL)
2140         {
2141           h->non_got_ref = 0;
2142           return TRUE;
2143         }
2144     }
2145
2146   /* We must allocate the symbol in our .dynbss section, which will
2147      become part of the .bss section of the executable.  There will be
2148      an entry for this symbol in the .dynsym section.  The dynamic
2149      object will contain position independent code, so all references
2150      from the dynamic object to this symbol will go through the global
2151      offset table.  The dynamic linker will use the .dynsym entry to
2152      determine the address it must put in the global offset table, so
2153      both the dynamic object and the regular object will refer to the
2154      same memory location for the variable.  */
2155
2156   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2157      copy the initial value out of the dynamic object and into the
2158      runtime process image.  */
2159   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2160     {
2161       htab->srelbss->size += sizeof (Elf32_External_Rel);
2162       h->needs_copy = 1;
2163     }
2164
2165   s = htab->sdynbss;
2166
2167   return _bfd_elf_adjust_dynamic_copy (h, s);
2168 }
2169
2170 /* Allocate space in .plt, .got and associated reloc sections for
2171    dynamic relocs.  */
2172
2173 static bfd_boolean
2174 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2175 {
2176   struct bfd_link_info *info;
2177   struct elf_i386_link_hash_table *htab;
2178   struct elf_i386_link_hash_entry *eh;
2179   struct elf_dyn_relocs *p;
2180   unsigned plt_entry_size;
2181
2182   if (h->root.type == bfd_link_hash_indirect)
2183     return TRUE;
2184
2185   eh = (struct elf_i386_link_hash_entry *) h;
2186
2187   info = (struct bfd_link_info *) inf;
2188   htab = elf_i386_hash_table (info);
2189   if (htab == NULL)
2190     return FALSE;
2191
2192   plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2193
2194   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2195      here if it is defined and referenced in a non-shared object.  */
2196   if (h->type == STT_GNU_IFUNC
2197       && h->def_regular)
2198     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2199                                                plt_entry_size, 4);
2200   else if (htab->elf.dynamic_sections_created
2201            && h->plt.refcount > 0)
2202     {
2203       /* Make sure this symbol is output as a dynamic symbol.
2204          Undefined weak syms won't yet be marked as dynamic.  */
2205       if (h->dynindx == -1
2206           && !h->forced_local)
2207         {
2208           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2209             return FALSE;
2210         }
2211
2212       if (info->shared
2213           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2214         {
2215           asection *s = htab->elf.splt;
2216
2217           /* If this is the first .plt entry, make room for the special
2218              first entry.  */
2219           if (s->size == 0)
2220             s->size += plt_entry_size;
2221
2222           h->plt.offset = s->size;
2223
2224           /* If this symbol is not defined in a regular file, and we are
2225              not generating a shared library, then set the symbol to this
2226              location in the .plt.  This is required to make function
2227              pointers compare as equal between the normal executable and
2228              the shared library.  */
2229           if (! info->shared
2230               && !h->def_regular)
2231             {
2232               h->root.u.def.section = s;
2233               h->root.u.def.value = h->plt.offset;
2234             }
2235
2236           /* Make room for this entry.  */
2237           s->size += plt_entry_size;
2238
2239           /* We also need to make an entry in the .got.plt section, which
2240              will be placed in the .got section by the linker script.  */
2241           htab->elf.sgotplt->size += 4;
2242
2243           /* We also need to make an entry in the .rel.plt section.  */
2244           htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2245           htab->elf.srelplt->reloc_count++;
2246
2247           if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2248               && !info->shared)
2249             {
2250               /* VxWorks has a second set of relocations for each PLT entry
2251                  in executables.  They go in a separate relocation section,
2252                  which is processed by the kernel loader.  */
2253
2254               /* There are two relocations for the initial PLT entry: an
2255                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2256                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
2257
2258               if (h->plt.offset == plt_entry_size)
2259                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2260
2261               /* There are two extra relocations for each subsequent PLT entry:
2262                  an R_386_32 relocation for the GOT entry, and an R_386_32
2263                  relocation for the PLT entry.  */
2264
2265               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2266             }
2267         }
2268       else
2269         {
2270           h->plt.offset = (bfd_vma) -1;
2271           h->needs_plt = 0;
2272         }
2273     }
2274   else
2275     {
2276       h->plt.offset = (bfd_vma) -1;
2277       h->needs_plt = 0;
2278     }
2279
2280   eh->tlsdesc_got = (bfd_vma) -1;
2281
2282   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2283      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
2284   if (h->got.refcount > 0
2285       && info->executable
2286       && h->dynindx == -1
2287       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2288     h->got.offset = (bfd_vma) -1;
2289   else if (h->got.refcount > 0)
2290     {
2291       asection *s;
2292       bfd_boolean dyn;
2293       int tls_type = elf_i386_hash_entry(h)->tls_type;
2294
2295       /* Make sure this symbol is output as a dynamic symbol.
2296          Undefined weak syms won't yet be marked as dynamic.  */
2297       if (h->dynindx == -1
2298           && !h->forced_local)
2299         {
2300           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2301             return FALSE;
2302         }
2303
2304       s = htab->elf.sgot;
2305       if (GOT_TLS_GDESC_P (tls_type))
2306         {
2307           eh->tlsdesc_got = htab->elf.sgotplt->size
2308             - elf_i386_compute_jump_table_size (htab);
2309           htab->elf.sgotplt->size += 8;
2310           h->got.offset = (bfd_vma) -2;
2311         }
2312       if (! GOT_TLS_GDESC_P (tls_type)
2313           || GOT_TLS_GD_P (tls_type))
2314         {
2315           h->got.offset = s->size;
2316           s->size += 4;
2317           /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
2318           if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2319             s->size += 4;
2320         }
2321       dyn = htab->elf.dynamic_sections_created;
2322       /* R_386_TLS_IE_32 needs one dynamic relocation,
2323          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2324          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2325          need two), R_386_TLS_GD needs one if local symbol and two if
2326          global.  */
2327       if (tls_type == GOT_TLS_IE_BOTH)
2328         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2329       else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2330                || (tls_type & GOT_TLS_IE))
2331         htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2332       else if (GOT_TLS_GD_P (tls_type))
2333         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2334       else if (! GOT_TLS_GDESC_P (tls_type)
2335                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2336                    || h->root.type != bfd_link_hash_undefweak)
2337                && (info->shared
2338                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2339         htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2340       if (GOT_TLS_GDESC_P (tls_type))
2341         htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2342     }
2343   else
2344     h->got.offset = (bfd_vma) -1;
2345
2346   if (eh->dyn_relocs == NULL)
2347     return TRUE;
2348
2349   /* In the shared -Bsymbolic case, discard space allocated for
2350      dynamic pc-relative relocs against symbols which turn out to be
2351      defined in regular objects.  For the normal shared case, discard
2352      space for pc-relative relocs that have become local due to symbol
2353      visibility changes.  */
2354
2355   if (info->shared)
2356     {
2357       /* The only reloc that uses pc_count is R_386_PC32, which will
2358          appear on a call or on something like ".long foo - .".  We
2359          want calls to protected symbols to resolve directly to the
2360          function rather than going via the plt.  If people want
2361          function pointer comparisons to work as expected then they
2362          should avoid writing assembly like ".long foo - .".  */
2363       if (SYMBOL_CALLS_LOCAL (info, h))
2364         {
2365           struct elf_dyn_relocs **pp;
2366
2367           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2368             {
2369               p->count -= p->pc_count;
2370               p->pc_count = 0;
2371               if (p->count == 0)
2372                 *pp = p->next;
2373               else
2374                 pp = &p->next;
2375             }
2376         }
2377
2378       if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2379         {
2380           struct elf_dyn_relocs **pp;
2381           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2382             {
2383               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2384                 *pp = p->next;
2385               else
2386                 pp = &p->next;
2387             }
2388         }
2389
2390       /* Also discard relocs on undefined weak syms with non-default
2391          visibility.  */
2392       if (eh->dyn_relocs != NULL
2393           && h->root.type == bfd_link_hash_undefweak)
2394         {
2395           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2396             eh->dyn_relocs = NULL;
2397
2398           /* Make sure undefined weak symbols are output as a dynamic
2399              symbol in PIEs.  */
2400           else if (h->dynindx == -1
2401                    && !h->forced_local)
2402             {
2403               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2404                 return FALSE;
2405             }
2406         }
2407     }
2408   else if (ELIMINATE_COPY_RELOCS)
2409     {
2410       /* For the non-shared case, discard space for relocs against
2411          symbols which turn out to need copy relocs or are not
2412          dynamic.  */
2413
2414       if (!h->non_got_ref
2415           && ((h->def_dynamic
2416                && !h->def_regular)
2417               || (htab->elf.dynamic_sections_created
2418                   && (h->root.type == bfd_link_hash_undefweak
2419                       || h->root.type == bfd_link_hash_undefined))))
2420         {
2421           /* Make sure this symbol is output as a dynamic symbol.
2422              Undefined weak syms won't yet be marked as dynamic.  */
2423           if (h->dynindx == -1
2424               && !h->forced_local)
2425             {
2426               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2427                 return FALSE;
2428             }
2429
2430           /* If that succeeded, we know we'll be keeping all the
2431              relocs.  */
2432           if (h->dynindx != -1)
2433             goto keep;
2434         }
2435
2436       eh->dyn_relocs = NULL;
2437
2438     keep: ;
2439     }
2440
2441   /* Finally, allocate space.  */
2442   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2443     {
2444       asection *sreloc;
2445
2446       sreloc = elf_section_data (p->sec)->sreloc;
2447
2448       BFD_ASSERT (sreloc != NULL);
2449       sreloc->size += p->count * sizeof (Elf32_External_Rel);
2450     }
2451
2452   return TRUE;
2453 }
2454
2455 /* Allocate space in .plt, .got and associated reloc sections for
2456    local dynamic relocs.  */
2457
2458 static bfd_boolean
2459 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2460 {
2461   struct elf_link_hash_entry *h
2462     = (struct elf_link_hash_entry *) *slot;
2463
2464   if (h->type != STT_GNU_IFUNC
2465       || !h->def_regular
2466       || !h->ref_regular
2467       || !h->forced_local
2468       || h->root.type != bfd_link_hash_defined)
2469     abort ();
2470
2471   return elf_i386_allocate_dynrelocs (h, inf);
2472 }
2473
2474 /* Find any dynamic relocs that apply to read-only sections.  */
2475
2476 static bfd_boolean
2477 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2478 {
2479   struct elf_i386_link_hash_entry *eh;
2480   struct elf_dyn_relocs *p;
2481
2482   /* Skip local IFUNC symbols. */
2483   if (h->forced_local && h->type == STT_GNU_IFUNC)
2484     return TRUE;
2485
2486   eh = (struct elf_i386_link_hash_entry *) h;
2487   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2488     {
2489       asection *s = p->sec->output_section;
2490
2491       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2492         {
2493           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2494
2495           info->flags |= DF_TEXTREL;
2496
2497           if (info->warn_shared_textrel && info->shared)
2498             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2499                                     p->sec->owner, h->root.root.string,
2500                                     p->sec);
2501
2502           /* Not an error, just cut short the traversal.  */
2503           return FALSE;
2504         }
2505     }
2506   return TRUE;
2507 }
2508
2509 /* Convert
2510    mov foo@GOT(%reg), %reg
2511    to
2512    lea foo@GOTOFF(%reg), %reg
2513    with the local symbol, foo.  */
2514
2515 static bfd_boolean
2516 elf_i386_convert_mov_to_lea (bfd *abfd, asection *sec,
2517                              struct bfd_link_info *link_info)
2518 {
2519   Elf_Internal_Shdr *symtab_hdr;
2520   Elf_Internal_Rela *internal_relocs;
2521   Elf_Internal_Rela *irel, *irelend;
2522   bfd_byte *contents;
2523   struct elf_i386_link_hash_table *htab;
2524   bfd_boolean changed_contents;
2525   bfd_boolean changed_relocs;
2526   bfd_signed_vma *local_got_refcounts;
2527
2528   /* Don't even try to convert non-ELF outputs.  */
2529   if (!is_elf_hash_table (link_info->hash))
2530     return FALSE;
2531
2532   /* Nothing to do if there are no codes, no relocations or no output.  */
2533   if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2534       || sec->reloc_count == 0
2535       || discarded_section (sec))
2536     return TRUE;
2537
2538   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2539
2540   /* Load the relocations for this section.  */
2541   internal_relocs = (_bfd_elf_link_read_relocs
2542                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2543                       link_info->keep_memory));
2544   if (internal_relocs == NULL)
2545     return FALSE;
2546
2547   htab = elf_i386_hash_table (link_info);
2548   changed_contents = FALSE;
2549   changed_relocs = FALSE;
2550   local_got_refcounts = elf_local_got_refcounts (abfd);
2551
2552   /* Get the section contents.  */
2553   if (elf_section_data (sec)->this_hdr.contents != NULL)
2554     contents = elf_section_data (sec)->this_hdr.contents;
2555   else
2556     {
2557       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2558         goto error_return;
2559     }
2560
2561   irelend = internal_relocs + sec->reloc_count;
2562   for (irel = internal_relocs; irel < irelend; irel++)
2563     {
2564       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2565       unsigned int r_symndx = ELF32_R_SYM (irel->r_info);
2566       unsigned int indx;
2567       struct elf_link_hash_entry *h;
2568
2569       if (r_type != R_386_GOT32)
2570         continue;
2571
2572       /* Get the symbol referred to by the reloc.  */
2573       if (r_symndx < symtab_hdr->sh_info)
2574         {
2575           Elf_Internal_Sym *isym;
2576
2577           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2578                                         abfd, r_symndx);
2579
2580           /* STT_GNU_IFUNC must keep R_386_GOT32 relocation.  */
2581           if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2582               && bfd_get_8 (input_bfd,
2583                             contents + irel->r_offset - 2) == 0x8b)
2584             {
2585               bfd_put_8 (output_bfd, 0x8d,
2586                          contents + irel->r_offset - 2);
2587               irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2588               if (local_got_refcounts != NULL
2589                   && local_got_refcounts[r_symndx] > 0)
2590                 local_got_refcounts[r_symndx] -= 1;
2591               changed_contents = TRUE;
2592               changed_relocs = TRUE;
2593             }
2594           continue;
2595         }
2596
2597       indx = r_symndx - symtab_hdr->sh_info;
2598       h = elf_sym_hashes (abfd)[indx];
2599       BFD_ASSERT (h != NULL);
2600
2601       while (h->root.type == bfd_link_hash_indirect
2602              || h->root.type == bfd_link_hash_warning)
2603         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2604
2605       /* STT_GNU_IFUNC must keep R_386_GOT32 relocation.  We also avoid
2606          optimizing _DYNAMIC since ld.so may use its link-time address.  */
2607       if (h->def_regular
2608           && h->type != STT_GNU_IFUNC
2609           && h != htab->elf.hdynamic
2610           && SYMBOL_REFERENCES_LOCAL (link_info, h)
2611           && bfd_get_8 (input_bfd,
2612                         contents + irel->r_offset - 2) == 0x8b)
2613         {
2614           bfd_put_8 (output_bfd, 0x8d,
2615                      contents + irel->r_offset - 2);
2616           irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2617           if (h->got.refcount > 0)
2618             h->got.refcount -= 1;
2619           changed_contents = TRUE;
2620           changed_relocs = TRUE;
2621         }
2622     }
2623
2624   if (contents != NULL
2625       && elf_section_data (sec)->this_hdr.contents != contents)
2626     {
2627       if (!changed_contents && !link_info->keep_memory)
2628         free (contents);
2629       else
2630         {
2631           /* Cache the section contents for elf_link_input_bfd.  */
2632           elf_section_data (sec)->this_hdr.contents = contents;
2633         }
2634     }
2635
2636   if (elf_section_data (sec)->relocs != internal_relocs)
2637     {
2638       if (!changed_relocs)
2639         free (internal_relocs);
2640       else
2641         elf_section_data (sec)->relocs = internal_relocs;
2642     }
2643
2644   return TRUE;
2645
2646  error_return:
2647   if (contents != NULL
2648       && elf_section_data (sec)->this_hdr.contents != contents)
2649     free (contents);
2650   if (internal_relocs != NULL
2651       && elf_section_data (sec)->relocs != internal_relocs)
2652     free (internal_relocs);
2653   return FALSE;
2654 }
2655
2656 /* Set the sizes of the dynamic sections.  */
2657
2658 static bfd_boolean
2659 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2660 {
2661   struct elf_i386_link_hash_table *htab;
2662   bfd *dynobj;
2663   asection *s;
2664   bfd_boolean relocs;
2665   bfd *ibfd;
2666
2667   htab = elf_i386_hash_table (info);
2668   if (htab == NULL)
2669     return FALSE;
2670   dynobj = htab->elf.dynobj;
2671   if (dynobj == NULL)
2672     abort ();
2673
2674   if (htab->elf.dynamic_sections_created)
2675     {
2676       /* Set the contents of the .interp section to the interpreter.  */
2677       if (info->executable)
2678         {
2679           s = bfd_get_linker_section (dynobj, ".interp");
2680           if (s == NULL)
2681             abort ();
2682           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2683           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2684         }
2685     }
2686
2687   /* Set up .got offsets for local syms, and space for local dynamic
2688      relocs.  */
2689   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2690     {
2691       bfd_signed_vma *local_got;
2692       bfd_signed_vma *end_local_got;
2693       char *local_tls_type;
2694       bfd_vma *local_tlsdesc_gotent;
2695       bfd_size_type locsymcount;
2696       Elf_Internal_Shdr *symtab_hdr;
2697       asection *srel;
2698
2699       if (! is_i386_elf (ibfd))
2700         continue;
2701
2702       for (s = ibfd->sections; s != NULL; s = s->next)
2703         {
2704           struct elf_dyn_relocs *p;
2705
2706           if (!elf_i386_convert_mov_to_lea (ibfd, s, info))
2707             return FALSE;
2708
2709           for (p = ((struct elf_dyn_relocs *)
2710                      elf_section_data (s)->local_dynrel);
2711                p != NULL;
2712                p = p->next)
2713             {
2714               if (!bfd_is_abs_section (p->sec)
2715                   && bfd_is_abs_section (p->sec->output_section))
2716                 {
2717                   /* Input section has been discarded, either because
2718                      it is a copy of a linkonce section or due to
2719                      linker script /DISCARD/, so we'll be discarding
2720                      the relocs too.  */
2721                 }
2722               else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2723                        && strcmp (p->sec->output_section->name,
2724                                   ".tls_vars") == 0)
2725                 {
2726                   /* Relocations in vxworks .tls_vars sections are
2727                      handled specially by the loader.  */
2728                 }
2729               else if (p->count != 0)
2730                 {
2731                   srel = elf_section_data (p->sec)->sreloc;
2732                   srel->size += p->count * sizeof (Elf32_External_Rel);
2733                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2734                       && (info->flags & DF_TEXTREL) == 0)
2735                     {
2736                       info->flags |= DF_TEXTREL;
2737                       if (info->warn_shared_textrel && info->shared)
2738                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2739                                                 p->sec->owner, p->sec);
2740                     }
2741                 }
2742             }
2743         }
2744
2745       local_got = elf_local_got_refcounts (ibfd);
2746       if (!local_got)
2747         continue;
2748
2749       symtab_hdr = &elf_symtab_hdr (ibfd);
2750       locsymcount = symtab_hdr->sh_info;
2751       end_local_got = local_got + locsymcount;
2752       local_tls_type = elf_i386_local_got_tls_type (ibfd);
2753       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
2754       s = htab->elf.sgot;
2755       srel = htab->elf.srelgot;
2756       for (; local_got < end_local_got;
2757            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2758         {
2759           *local_tlsdesc_gotent = (bfd_vma) -1;
2760           if (*local_got > 0)
2761             {
2762               if (GOT_TLS_GDESC_P (*local_tls_type))
2763                 {
2764                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2765                     - elf_i386_compute_jump_table_size (htab);
2766                   htab->elf.sgotplt->size += 8;
2767                   *local_got = (bfd_vma) -2;
2768                 }
2769               if (! GOT_TLS_GDESC_P (*local_tls_type)
2770                   || GOT_TLS_GD_P (*local_tls_type))
2771                 {
2772                   *local_got = s->size;
2773                   s->size += 4;
2774                   if (GOT_TLS_GD_P (*local_tls_type)
2775                       || *local_tls_type == GOT_TLS_IE_BOTH)
2776                     s->size += 4;
2777                 }
2778               if (info->shared
2779                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2780                   || (*local_tls_type & GOT_TLS_IE))
2781                 {
2782                   if (*local_tls_type == GOT_TLS_IE_BOTH)
2783                     srel->size += 2 * sizeof (Elf32_External_Rel);
2784                   else if (GOT_TLS_GD_P (*local_tls_type)
2785                            || ! GOT_TLS_GDESC_P (*local_tls_type))
2786                     srel->size += sizeof (Elf32_External_Rel);
2787                   if (GOT_TLS_GDESC_P (*local_tls_type))
2788                     htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2789                 }
2790             }
2791           else
2792             *local_got = (bfd_vma) -1;
2793         }
2794     }
2795
2796   if (htab->tls_ldm_got.refcount > 0)
2797     {
2798       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2799          relocs.  */
2800       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2801       htab->elf.sgot->size += 8;
2802       htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2803     }
2804   else
2805     htab->tls_ldm_got.offset = -1;
2806
2807   /* Allocate global sym .plt and .got entries, and space for global
2808      sym dynamic relocs.  */
2809   elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
2810
2811   /* Allocate .plt and .got entries, and space for local symbols.  */
2812   htab_traverse (htab->loc_hash_table,
2813                  elf_i386_allocate_local_dynrelocs,
2814                  info);
2815
2816   /* For every jump slot reserved in the sgotplt, reloc_count is
2817      incremented.  However, when we reserve space for TLS descriptors,
2818      it's not incremented, so in order to compute the space reserved
2819      for them, it suffices to multiply the reloc count by the jump
2820      slot size.
2821
2822      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2823      so that R_386_IRELATIVE entries come last.  */
2824   if (htab->elf.srelplt)
2825     {
2826       htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2827       htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2828       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2829     }
2830   else if (htab->elf.irelplt)
2831     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2832
2833
2834   if (htab->elf.sgotplt)
2835     {
2836       /* Don't allocate .got.plt section if there are no GOT nor PLT
2837          entries and there is no reference to _GLOBAL_OFFSET_TABLE_.  */
2838       if ((htab->elf.hgot == NULL
2839            || !htab->elf.hgot->ref_regular_nonweak)
2840           && (htab->elf.sgotplt->size
2841               == get_elf_backend_data (output_bfd)->got_header_size)
2842           && (htab->elf.splt == NULL
2843               || htab->elf.splt->size == 0)
2844           && (htab->elf.sgot == NULL
2845               || htab->elf.sgot->size == 0)
2846           && (htab->elf.iplt == NULL
2847               || htab->elf.iplt->size == 0)
2848           && (htab->elf.igotplt == NULL
2849               || htab->elf.igotplt->size == 0))
2850         htab->elf.sgotplt->size = 0;
2851     }
2852
2853
2854   if (htab->plt_eh_frame != NULL
2855       && htab->elf.splt != NULL
2856       && htab->elf.splt->size != 0
2857       && !bfd_is_abs_section (htab->elf.splt->output_section)
2858       && _bfd_elf_eh_frame_present (info))
2859     htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
2860
2861   /* We now have determined the sizes of the various dynamic sections.
2862      Allocate memory for them.  */
2863   relocs = FALSE;
2864   for (s = dynobj->sections; s != NULL; s = s->next)
2865     {
2866       bfd_boolean strip_section = TRUE;
2867
2868       if ((s->flags & SEC_LINKER_CREATED) == 0)
2869         continue;
2870
2871       if (s == htab->elf.splt
2872           || s == htab->elf.sgot)
2873         {
2874           /* Strip this section if we don't need it; see the
2875              comment below.  */
2876           /* We'd like to strip these sections if they aren't needed, but if
2877              we've exported dynamic symbols from them we must leave them.
2878              It's too late to tell BFD to get rid of the symbols.  */
2879
2880           if (htab->elf.hplt != NULL)
2881             strip_section = FALSE;
2882         }
2883       else if (s == htab->elf.sgotplt
2884                || s == htab->elf.iplt
2885                || s == htab->elf.igotplt
2886                || s == htab->plt_eh_frame
2887                || s == htab->sdynbss)
2888         {
2889           /* Strip these too.  */
2890         }
2891       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2892         {
2893           if (s->size != 0
2894               && s != htab->elf.srelplt
2895               && s != htab->srelplt2)
2896             relocs = TRUE;
2897
2898           /* We use the reloc_count field as a counter if we need
2899              to copy relocs into the output file.  */
2900           s->reloc_count = 0;
2901         }
2902       else
2903         {
2904           /* It's not one of our sections, so don't allocate space.  */
2905           continue;
2906         }
2907
2908       if (s->size == 0)
2909         {
2910           /* If we don't need this section, strip it from the
2911              output file.  This is mostly to handle .rel.bss and
2912              .rel.plt.  We must create both sections in
2913              create_dynamic_sections, because they must be created
2914              before the linker maps input sections to output
2915              sections.  The linker does that before
2916              adjust_dynamic_symbol is called, and it is that
2917              function which decides whether anything needs to go
2918              into these sections.  */
2919           if (strip_section)
2920             s->flags |= SEC_EXCLUDE;
2921           continue;
2922         }
2923
2924       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2925         continue;
2926
2927       /* Allocate memory for the section contents.  We use bfd_zalloc
2928          here in case unused entries are not reclaimed before the
2929          section's contents are written out.  This should not happen,
2930          but this way if it does, we get a R_386_NONE reloc instead
2931          of garbage.  */
2932       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2933       if (s->contents == NULL)
2934         return FALSE;
2935     }
2936
2937   if (htab->plt_eh_frame != NULL
2938       && htab->plt_eh_frame->contents != NULL)
2939     {
2940       memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
2941               sizeof (elf_i386_eh_frame_plt));
2942       bfd_put_32 (dynobj, htab->elf.splt->size,
2943                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2944     }
2945
2946   if (htab->elf.dynamic_sections_created)
2947     {
2948       /* Add some entries to the .dynamic section.  We fill in the
2949          values later, in elf_i386_finish_dynamic_sections, but we
2950          must add the entries now so that we get the correct size for
2951          the .dynamic section.  The DT_DEBUG entry is filled in by the
2952          dynamic linker and used by the debugger.  */
2953 #define add_dynamic_entry(TAG, VAL) \
2954   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2955
2956       if (info->executable)
2957         {
2958           if (!add_dynamic_entry (DT_DEBUG, 0))
2959             return FALSE;
2960         }
2961
2962       if (htab->elf.splt->size != 0)
2963         {
2964           if (!add_dynamic_entry (DT_PLTGOT, 0)
2965               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2966               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2967               || !add_dynamic_entry (DT_JMPREL, 0))
2968             return FALSE;
2969         }
2970
2971       if (relocs)
2972         {
2973           if (!add_dynamic_entry (DT_REL, 0)
2974               || !add_dynamic_entry (DT_RELSZ, 0)
2975               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2976             return FALSE;
2977
2978           /* If any dynamic relocs apply to a read-only section,
2979              then we need a DT_TEXTREL entry.  */
2980           if ((info->flags & DF_TEXTREL) == 0)
2981             elf_link_hash_traverse (&htab->elf,
2982                                     elf_i386_readonly_dynrelocs, info);
2983
2984           if ((info->flags & DF_TEXTREL) != 0)
2985             {
2986               if (!add_dynamic_entry (DT_TEXTREL, 0))
2987                 return FALSE;
2988             }
2989         }
2990       if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2991           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2992         return FALSE;
2993     }
2994 #undef add_dynamic_entry
2995
2996   return TRUE;
2997 }
2998
2999 static bfd_boolean
3000 elf_i386_always_size_sections (bfd *output_bfd,
3001                                struct bfd_link_info *info)
3002 {
3003   asection *tls_sec = elf_hash_table (info)->tls_sec;
3004
3005   if (tls_sec)
3006     {
3007       struct elf_link_hash_entry *tlsbase;
3008
3009       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3010                                       "_TLS_MODULE_BASE_",
3011                                       FALSE, FALSE, FALSE);
3012
3013       if (tlsbase && tlsbase->type == STT_TLS)
3014         {
3015           struct elf_i386_link_hash_table *htab;
3016           struct bfd_link_hash_entry *bh = NULL;
3017           const struct elf_backend_data *bed
3018             = get_elf_backend_data (output_bfd);
3019
3020           htab = elf_i386_hash_table (info);
3021           if (htab == NULL)
3022             return FALSE;
3023
3024           if (!(_bfd_generic_link_add_one_symbol
3025                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3026                  tls_sec, 0, NULL, FALSE,
3027                  bed->collect, &bh)))
3028             return FALSE;
3029
3030           htab->tls_module_base = bh;
3031
3032           tlsbase = (struct elf_link_hash_entry *)bh;
3033           tlsbase->def_regular = 1;
3034           tlsbase->other = STV_HIDDEN;
3035           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3036         }
3037     }
3038
3039   return TRUE;
3040 }
3041
3042 /* Set the correct type for an x86 ELF section.  We do this by the
3043    section name, which is a hack, but ought to work.  */
3044
3045 static bfd_boolean
3046 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3047                         Elf_Internal_Shdr *hdr,
3048                         asection *sec)
3049 {
3050   const char *name;
3051
3052   name = bfd_get_section_name (abfd, sec);
3053
3054   /* This is an ugly, but unfortunately necessary hack that is
3055      needed when producing EFI binaries on x86. It tells
3056      elf.c:elf_fake_sections() not to consider ".reloc" as a section
3057      containing ELF relocation info.  We need this hack in order to
3058      be able to generate ELF binaries that can be translated into
3059      EFI applications (which are essentially COFF objects).  Those
3060      files contain a COFF ".reloc" section inside an ELFNN object,
3061      which would normally cause BFD to segfault because it would
3062      attempt to interpret this section as containing relocation
3063      entries for section "oc".  With this hack enabled, ".reloc"
3064      will be treated as a normal data section, which will avoid the
3065      segfault.  However, you won't be able to create an ELFNN binary
3066      with a section named "oc" that needs relocations, but that's
3067      the kind of ugly side-effects you get when detecting section
3068      types based on their names...  In practice, this limitation is
3069      unlikely to bite.  */
3070   if (strcmp (name, ".reloc") == 0)
3071     hdr->sh_type = SHT_PROGBITS;
3072
3073   return TRUE;
3074 }
3075
3076 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3077    executables.  Rather than setting it to the beginning of the TLS
3078    section, we have to set it to the end.    This function may be called
3079    multiple times, it is idempotent.  */
3080
3081 static void
3082 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3083 {
3084   struct elf_i386_link_hash_table *htab;
3085   struct bfd_link_hash_entry *base;
3086
3087   if (!info->executable)
3088     return;
3089
3090   htab = elf_i386_hash_table (info);
3091   if (htab == NULL)
3092     return;
3093
3094   base = htab->tls_module_base;
3095   if (base == NULL)
3096     return;
3097
3098   base->u.def.value = htab->elf.tls_size;
3099 }
3100
3101 /* Return the base VMA address which should be subtracted from real addresses
3102    when resolving @dtpoff relocation.
3103    This is PT_TLS segment p_vaddr.  */
3104
3105 static bfd_vma
3106 elf_i386_dtpoff_base (struct bfd_link_info *info)
3107 {
3108   /* If tls_sec is NULL, we should have signalled an error already.  */
3109   if (elf_hash_table (info)->tls_sec == NULL)
3110     return 0;
3111   return elf_hash_table (info)->tls_sec->vma;
3112 }
3113
3114 /* Return the relocation value for @tpoff relocation
3115    if STT_TLS virtual address is ADDRESS.  */
3116
3117 static bfd_vma
3118 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3119 {
3120   struct elf_link_hash_table *htab = elf_hash_table (info);
3121   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3122   bfd_vma static_tls_size;
3123
3124   /* If tls_sec is NULL, we should have signalled an error already.  */
3125   if (htab->tls_sec == NULL)
3126     return 0;
3127
3128   /* Consider special static TLS alignment requirements.  */
3129   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3130   return static_tls_size + htab->tls_sec->vma - address;
3131 }
3132
3133 /* Relocate an i386 ELF section.  */
3134
3135 static bfd_boolean
3136 elf_i386_relocate_section (bfd *output_bfd,
3137                            struct bfd_link_info *info,
3138                            bfd *input_bfd,
3139                            asection *input_section,
3140                            bfd_byte *contents,
3141                            Elf_Internal_Rela *relocs,
3142                            Elf_Internal_Sym *local_syms,
3143                            asection **local_sections)
3144 {
3145   struct elf_i386_link_hash_table *htab;
3146   Elf_Internal_Shdr *symtab_hdr;
3147   struct elf_link_hash_entry **sym_hashes;
3148   bfd_vma *local_got_offsets;
3149   bfd_vma *local_tlsdesc_gotents;
3150   Elf_Internal_Rela *rel;
3151   Elf_Internal_Rela *relend;
3152   bfd_boolean is_vxworks_tls;
3153   unsigned plt_entry_size;
3154
3155   BFD_ASSERT (is_i386_elf (input_bfd));
3156
3157   htab = elf_i386_hash_table (info);
3158   if (htab == NULL)
3159     return FALSE;
3160   symtab_hdr = &elf_symtab_hdr (input_bfd);
3161   sym_hashes = elf_sym_hashes (input_bfd);
3162   local_got_offsets = elf_local_got_offsets (input_bfd);
3163   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3164   /* We have to handle relocations in vxworks .tls_vars sections
3165      specially, because the dynamic loader is 'weird'.  */
3166   is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3167                     && info->shared
3168                     && !strcmp (input_section->output_section->name,
3169                                 ".tls_vars"));
3170
3171   elf_i386_set_tls_module_base (info);
3172
3173   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3174
3175   rel = relocs;
3176   relend = relocs + input_section->reloc_count;
3177   for (; rel < relend; rel++)
3178     {
3179       unsigned int r_type;
3180       reloc_howto_type *howto;
3181       unsigned long r_symndx;
3182       struct elf_link_hash_entry *h;
3183       Elf_Internal_Sym *sym;
3184       asection *sec;
3185       bfd_vma off, offplt;
3186       bfd_vma relocation;
3187       bfd_boolean unresolved_reloc;
3188       bfd_reloc_status_type r;
3189       unsigned int indx;
3190       int tls_type;
3191       bfd_vma st_size;
3192
3193       r_type = ELF32_R_TYPE (rel->r_info);
3194       if (r_type == R_386_GNU_VTINHERIT
3195           || r_type == R_386_GNU_VTENTRY)
3196         continue;
3197
3198       if ((indx = r_type) >= R_386_standard
3199           && ((indx = r_type - R_386_ext_offset) - R_386_standard
3200               >= R_386_ext - R_386_standard)
3201           && ((indx = r_type - R_386_tls_offset) - R_386_ext
3202               >= R_386_irelative - R_386_ext))
3203         {
3204           (*_bfd_error_handler)
3205             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3206              input_bfd, input_section, r_type);
3207           bfd_set_error (bfd_error_bad_value);
3208           return FALSE;
3209         }
3210       howto = elf_howto_table + indx;
3211
3212       r_symndx = ELF32_R_SYM (rel->r_info);
3213       h = NULL;
3214       sym = NULL;
3215       sec = NULL;
3216       unresolved_reloc = FALSE;
3217       if (r_symndx < symtab_hdr->sh_info)
3218         {
3219           sym = local_syms + r_symndx;
3220           sec = local_sections[r_symndx];
3221           relocation = (sec->output_section->vma
3222                         + sec->output_offset
3223                         + sym->st_value);
3224           st_size = sym->st_size;
3225
3226           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3227               && ((sec->flags & SEC_MERGE) != 0
3228                   || (info->relocatable
3229                       && sec->output_offset != 0)))
3230             {
3231               bfd_vma addend;
3232               bfd_byte *where = contents + rel->r_offset;
3233
3234               switch (howto->size)
3235                 {
3236                 case 0:
3237                   addend = bfd_get_8 (input_bfd, where);
3238                   if (howto->pc_relative)
3239                     {
3240                       addend = (addend ^ 0x80) - 0x80;
3241                       addend += 1;
3242                     }
3243                   break;
3244                 case 1:
3245                   addend = bfd_get_16 (input_bfd, where);
3246                   if (howto->pc_relative)
3247                     {
3248                       addend = (addend ^ 0x8000) - 0x8000;
3249                       addend += 2;
3250                     }
3251                   break;
3252                 case 2:
3253                   addend = bfd_get_32 (input_bfd, where);
3254                   if (howto->pc_relative)
3255                     {
3256                       addend = (addend ^ 0x80000000) - 0x80000000;
3257                       addend += 4;
3258                     }
3259                   break;
3260                 default:
3261                   abort ();
3262                 }
3263
3264               if (info->relocatable)
3265                 addend += sec->output_offset;
3266               else
3267                 {
3268                   asection *msec = sec;
3269                   addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3270                                                    addend);
3271                   addend -= relocation;
3272                   addend += msec->output_section->vma + msec->output_offset;
3273                 }
3274
3275               switch (howto->size)
3276                 {
3277                 case 0:
3278                   /* FIXME: overflow checks.  */
3279                   if (howto->pc_relative)
3280                     addend -= 1;
3281                   bfd_put_8 (input_bfd, addend, where);
3282                   break;
3283                 case 1:
3284                   if (howto->pc_relative)
3285                     addend -= 2;
3286                   bfd_put_16 (input_bfd, addend, where);
3287                   break;
3288                 case 2:
3289                   if (howto->pc_relative)
3290                     addend -= 4;
3291                   bfd_put_32 (input_bfd, addend, where);
3292                   break;
3293                 }
3294             }
3295           else if (!info->relocatable
3296                    && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3297             {
3298               /* Relocate against local STT_GNU_IFUNC symbol.  */
3299               h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3300                                                FALSE);
3301               if (h == NULL)
3302                 abort ();
3303
3304               /* Set STT_GNU_IFUNC symbol value.  */
3305               h->root.u.def.value = sym->st_value;
3306               h->root.u.def.section = sec;
3307             }
3308         }
3309       else
3310         {
3311           bfd_boolean warned ATTRIBUTE_UNUSED;
3312
3313           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3314                                    r_symndx, symtab_hdr, sym_hashes,
3315                                    h, sec, relocation,
3316                                    unresolved_reloc, warned);
3317           st_size = h->size;
3318         }
3319
3320       if (sec != NULL && discarded_section (sec))
3321         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3322                                          rel, 1, relend, howto, 0, contents);
3323
3324       if (info->relocatable)
3325         continue;
3326
3327       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3328          it here if it is defined in a non-shared object.  */
3329       if (h != NULL
3330           && h->type == STT_GNU_IFUNC
3331           && h->def_regular)
3332         {
3333           asection *plt, *gotplt, *base_got;
3334           bfd_vma plt_index;
3335           const char *name;
3336
3337           if ((input_section->flags & SEC_ALLOC) == 0
3338               || h->plt.offset == (bfd_vma) -1)
3339             abort ();
3340
3341           /* STT_GNU_IFUNC symbol must go through PLT.  */
3342           if (htab->elf.splt != NULL)
3343             {
3344               plt = htab->elf.splt;
3345               gotplt = htab->elf.sgotplt;
3346             }
3347           else
3348             {
3349               plt = htab->elf.iplt;
3350               gotplt = htab->elf.igotplt;
3351             }
3352
3353           relocation = (plt->output_section->vma
3354                         + plt->output_offset + h->plt.offset);
3355
3356           switch (r_type)
3357             {
3358             default:
3359               if (h->root.root.string)
3360                 name = h->root.root.string;
3361               else
3362                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3363                                          NULL);
3364               (*_bfd_error_handler)
3365                 (_("%B: relocation %s against STT_GNU_IFUNC "
3366                    "symbol `%s' isn't handled by %s"), input_bfd,
3367                  elf_howto_table[r_type].name,
3368                  name, __FUNCTION__);
3369               bfd_set_error (bfd_error_bad_value);
3370               return FALSE;
3371
3372             case R_386_32:
3373               /* Generate dynamic relcoation only when there is a
3374                  non-GOT reference in a shared object.  */
3375               if (info->shared && h->non_got_ref)
3376                 {
3377                   Elf_Internal_Rela outrel;
3378                   asection *sreloc;
3379                   bfd_vma offset;
3380
3381                   /* Need a dynamic relocation to get the real function
3382                      adddress.  */
3383                   offset = _bfd_elf_section_offset (output_bfd,
3384                                                     info,
3385                                                     input_section,
3386                                                     rel->r_offset);
3387                   if (offset == (bfd_vma) -1
3388                       || offset == (bfd_vma) -2)
3389                     abort ();
3390
3391                   outrel.r_offset = (input_section->output_section->vma
3392                                      + input_section->output_offset
3393                                      + offset);
3394
3395                   if (h->dynindx == -1
3396                       || h->forced_local
3397                       || info->executable)
3398                     {
3399                       /* This symbol is resolved locally.  */
3400                       outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3401                       bfd_put_32 (output_bfd,
3402                                   (h->root.u.def.value
3403                                    + h->root.u.def.section->output_section->vma
3404                                    + h->root.u.def.section->output_offset),
3405                                   contents + offset);
3406                     }
3407                   else
3408                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3409
3410                   sreloc = htab->elf.irelifunc;
3411                   elf_append_rel (output_bfd, sreloc, &outrel);
3412
3413                   /* If this reloc is against an external symbol, we
3414                      do not want to fiddle with the addend.  Otherwise,
3415                      we need to include the symbol value so that it
3416                      becomes an addend for the dynamic reloc.  For an
3417                      internal symbol, we have updated addend.  */
3418                   continue;
3419                 }
3420               /* FALLTHROUGH */
3421             case R_386_PC32:
3422             case R_386_PLT32:
3423               goto do_relocation;
3424
3425             case R_386_GOT32:
3426               base_got = htab->elf.sgot;
3427               off = h->got.offset;
3428
3429               if (base_got == NULL)
3430                 abort ();
3431
3432               if (off == (bfd_vma) -1)
3433                 {
3434                   /* We can't use h->got.offset here to save state, or
3435                      even just remember the offset, as finish_dynamic_symbol
3436                      would use that as offset into .got.  */
3437
3438                   if (htab->elf.splt != NULL)
3439                     {
3440                       plt_index = h->plt.offset / plt_entry_size - 1;
3441                       off = (plt_index + 3) * 4;
3442                       base_got = htab->elf.sgotplt;
3443                     }
3444                   else
3445                     {
3446                       plt_index = h->plt.offset / plt_entry_size;
3447                       off = plt_index * 4;
3448                       base_got = htab->elf.igotplt;
3449                     }
3450
3451                   if (h->dynindx == -1
3452                       || h->forced_local
3453                       || info->symbolic)
3454                     {
3455                       /* This references the local defitionion.  We must
3456                          initialize this entry in the global offset table.
3457                          Since the offset must always be a multiple of 8,
3458                          we use the least significant bit to record
3459                          whether we have initialized it already.
3460
3461                          When doing a dynamic link, we create a .rela.got
3462                          relocation entry to initialize the value.  This
3463                          is done in the finish_dynamic_symbol routine.   */
3464                       if ((off & 1) != 0)
3465                         off &= ~1;
3466                       else
3467                         {
3468                           bfd_put_32 (output_bfd, relocation,
3469                                       base_got->contents + off);
3470                           h->got.offset |= 1;
3471                         }
3472                     }
3473
3474                   relocation = off;
3475
3476                   /* Adjust for static executables.  */
3477                   if (htab->elf.splt == NULL)
3478                     relocation += gotplt->output_offset;
3479                 }
3480               else
3481                 {
3482                   relocation = (base_got->output_section->vma
3483                                 + base_got->output_offset + off
3484                                 - gotplt->output_section->vma
3485                                 - gotplt->output_offset);
3486                   /* Adjust for static executables.  */
3487                   if (htab->elf.splt == NULL)
3488                     relocation += gotplt->output_offset;
3489                 }
3490
3491               goto do_relocation;
3492
3493             case R_386_GOTOFF:
3494               relocation -= (gotplt->output_section->vma
3495                              + gotplt->output_offset);
3496               goto do_relocation;
3497             }
3498         }
3499
3500       switch (r_type)
3501         {
3502         case R_386_GOT32:
3503           /* Relocation is to the entry for this symbol in the global
3504              offset table.  */
3505           if (htab->elf.sgot == NULL)
3506             abort ();
3507
3508           if (h != NULL)
3509             {
3510               bfd_boolean dyn;
3511
3512               off = h->got.offset;
3513               dyn = htab->elf.dynamic_sections_created;
3514               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3515                   || (info->shared
3516                       && SYMBOL_REFERENCES_LOCAL (info, h))
3517                   || (ELF_ST_VISIBILITY (h->other)
3518                       && h->root.type == bfd_link_hash_undefweak))
3519                 {
3520                   /* This is actually a static link, or it is a
3521                      -Bsymbolic link and the symbol is defined
3522                      locally, or the symbol was forced to be local
3523                      because of a version file.  We must initialize
3524                      this entry in the global offset table.  Since the
3525                      offset must always be a multiple of 4, we use the
3526                      least significant bit to record whether we have
3527                      initialized it already.
3528
3529                      When doing a dynamic link, we create a .rel.got
3530                      relocation entry to initialize the value.  This
3531                      is done in the finish_dynamic_symbol routine.  */
3532                   if ((off & 1) != 0)
3533                     off &= ~1;
3534                   else
3535                     {
3536                       bfd_put_32 (output_bfd, relocation,
3537                                   htab->elf.sgot->contents + off);
3538                       h->got.offset |= 1;
3539                     }
3540                 }
3541               else
3542                 unresolved_reloc = FALSE;
3543             }
3544           else
3545             {
3546               if (local_got_offsets == NULL)
3547                 abort ();
3548
3549               off = local_got_offsets[r_symndx];
3550
3551               /* The offset must always be a multiple of 4.  We use
3552                  the least significant bit to record whether we have
3553                  already generated the necessary reloc.  */
3554               if ((off & 1) != 0)
3555                 off &= ~1;
3556               else
3557                 {
3558                   bfd_put_32 (output_bfd, relocation,
3559                               htab->elf.sgot->contents + off);
3560
3561                   if (info->shared)
3562                     {
3563                       asection *s;
3564                       Elf_Internal_Rela outrel;
3565
3566                       s = htab->elf.srelgot;
3567                       if (s == NULL)
3568                         abort ();
3569
3570                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3571                                          + htab->elf.sgot->output_offset
3572                                          + off);
3573                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3574                       elf_append_rel (output_bfd, s, &outrel);
3575                     }
3576
3577                   local_got_offsets[r_symndx] |= 1;
3578                 }
3579             }
3580
3581           if (off >= (bfd_vma) -2)
3582             abort ();
3583
3584           relocation = htab->elf.sgot->output_section->vma
3585                        + htab->elf.sgot->output_offset + off
3586                        - htab->elf.sgotplt->output_section->vma
3587                        - htab->elf.sgotplt->output_offset;
3588           break;
3589
3590         case R_386_GOTOFF:
3591           /* Relocation is relative to the start of the global offset
3592              table.  */
3593
3594           /* Check to make sure it isn't a protected function symbol
3595              for shared library since it may not be local when used
3596              as function address.  We also need to make sure that a
3597              symbol is defined locally.  */
3598           if (info->shared && h)
3599             {
3600               if (!h->def_regular)
3601                 {
3602                   const char *v;
3603
3604                   switch (ELF_ST_VISIBILITY (h->other))
3605                     {
3606                     case STV_HIDDEN:
3607                       v = _("hidden symbol");
3608                       break;
3609                     case STV_INTERNAL:
3610                       v = _("internal symbol");
3611                       break;
3612                     case STV_PROTECTED:
3613                       v = _("protected symbol");
3614                       break;
3615                     default:
3616                       v = _("symbol");
3617                       break;
3618                     }
3619
3620                   (*_bfd_error_handler)
3621                     (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3622                      input_bfd, v, h->root.root.string);
3623                   bfd_set_error (bfd_error_bad_value);
3624                   return FALSE;
3625                 }
3626               else if (!info->executable
3627                        && !SYMBOLIC_BIND (info, h)
3628                        && h->type == STT_FUNC
3629                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3630                 {
3631                   (*_bfd_error_handler)
3632                     (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3633                      input_bfd, h->root.root.string);
3634                   bfd_set_error (bfd_error_bad_value);
3635                   return FALSE;
3636                 }
3637             }
3638
3639           /* Note that sgot is not involved in this
3640              calculation.  We always want the start of .got.plt.  If we
3641              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3642              permitted by the ABI, we might have to change this
3643              calculation.  */
3644           relocation -= htab->elf.sgotplt->output_section->vma
3645                         + htab->elf.sgotplt->output_offset;
3646           break;
3647
3648         case R_386_GOTPC:
3649           /* Use global offset table as symbol value.  */
3650           relocation = htab->elf.sgotplt->output_section->vma
3651                        + htab->elf.sgotplt->output_offset;
3652           unresolved_reloc = FALSE;
3653           break;
3654
3655         case R_386_PLT32:
3656           /* Relocation is to the entry for this symbol in the
3657              procedure linkage table.  */
3658
3659           /* Resolve a PLT32 reloc against a local symbol directly,
3660              without using the procedure linkage table.  */
3661           if (h == NULL)
3662             break;
3663
3664           if (h->plt.offset == (bfd_vma) -1
3665               || htab->elf.splt == NULL)
3666             {
3667               /* We didn't make a PLT entry for this symbol.  This
3668                  happens when statically linking PIC code, or when
3669                  using -Bsymbolic.  */
3670               break;
3671             }
3672
3673           relocation = (htab->elf.splt->output_section->vma
3674                         + htab->elf.splt->output_offset
3675                         + h->plt.offset);
3676           unresolved_reloc = FALSE;
3677           break;
3678
3679         case R_386_SIZE32:
3680           /* Set to symbol size.  */
3681           relocation = st_size;
3682           /* Fall through.  */
3683
3684         case R_386_32:
3685         case R_386_PC32:
3686           if ((input_section->flags & SEC_ALLOC) == 0
3687               || is_vxworks_tls)
3688             break;
3689
3690           if ((info->shared
3691                && (h == NULL
3692                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3693                    || h->root.type != bfd_link_hash_undefweak)
3694                && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
3695                    || !SYMBOL_CALLS_LOCAL (info, h)))
3696               || (ELIMINATE_COPY_RELOCS
3697                   && !info->shared
3698                   && h != NULL
3699                   && h->dynindx != -1
3700                   && !h->non_got_ref
3701                   && ((h->def_dynamic
3702                        && !h->def_regular)
3703                       || h->root.type == bfd_link_hash_undefweak
3704                       || h->root.type == bfd_link_hash_undefined)))
3705             {
3706               Elf_Internal_Rela outrel;
3707               bfd_boolean skip, relocate;
3708               asection *sreloc;
3709
3710               /* When generating a shared object, these relocations
3711                  are copied into the output file to be resolved at run
3712                  time.  */
3713
3714               skip = FALSE;
3715               relocate = FALSE;
3716
3717               outrel.r_offset =
3718                 _bfd_elf_section_offset (output_bfd, info, input_section,
3719                                          rel->r_offset);
3720               if (outrel.r_offset == (bfd_vma) -1)
3721                 skip = TRUE;
3722               else if (outrel.r_offset == (bfd_vma) -2)
3723                 skip = TRUE, relocate = TRUE;
3724               outrel.r_offset += (input_section->output_section->vma
3725                                   + input_section->output_offset);
3726
3727               if (skip)
3728                 memset (&outrel, 0, sizeof outrel);
3729               else if (h != NULL
3730                        && h->dynindx != -1
3731                        && (r_type == R_386_PC32
3732                            || !info->shared
3733                            || !SYMBOLIC_BIND (info, h)
3734                            || !h->def_regular))
3735                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3736               else
3737                 {
3738                   /* This symbol is local, or marked to become local.  */
3739                   relocate = TRUE;
3740                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3741                 }
3742
3743               sreloc = elf_section_data (input_section)->sreloc;
3744
3745               if (sreloc == NULL || sreloc->contents == NULL)
3746                 {
3747                   r = bfd_reloc_notsupported;
3748                   goto check_relocation_error;
3749                 }
3750
3751               elf_append_rel (output_bfd, sreloc, &outrel);
3752
3753               /* If this reloc is against an external symbol, we do
3754                  not want to fiddle with the addend.  Otherwise, we
3755                  need to include the symbol value so that it becomes
3756                  an addend for the dynamic reloc.  */
3757               if (! relocate)
3758                 continue;
3759             }
3760           break;
3761
3762         case R_386_TLS_IE:
3763           if (!info->executable)
3764             {
3765               Elf_Internal_Rela outrel;
3766               asection *sreloc;
3767
3768               outrel.r_offset = rel->r_offset
3769                                 + input_section->output_section->vma
3770                                 + input_section->output_offset;
3771               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3772               sreloc = elf_section_data (input_section)->sreloc;
3773               if (sreloc == NULL)
3774                 abort ();
3775               elf_append_rel (output_bfd, sreloc, &outrel);
3776             }
3777           /* Fall through */
3778
3779         case R_386_TLS_GD:
3780         case R_386_TLS_GOTDESC:
3781         case R_386_TLS_DESC_CALL:
3782         case R_386_TLS_IE_32:
3783         case R_386_TLS_GOTIE:
3784           tls_type = GOT_UNKNOWN;
3785           if (h == NULL && local_got_offsets)
3786             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3787           else if (h != NULL)
3788             tls_type = elf_i386_hash_entry(h)->tls_type;
3789           if (tls_type == GOT_TLS_IE)
3790             tls_type = GOT_TLS_IE_NEG;
3791
3792           if (! elf_i386_tls_transition (info, input_bfd,
3793                                          input_section, contents,
3794                                          symtab_hdr, sym_hashes,
3795                                          &r_type, tls_type, rel,
3796                                          relend, h, r_symndx))
3797             return FALSE;
3798
3799           if (r_type == R_386_TLS_LE_32)
3800             {
3801               BFD_ASSERT (! unresolved_reloc);
3802               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3803                 {
3804                   unsigned int type;
3805                   bfd_vma roff;
3806
3807                   /* GD->LE transition.  */
3808                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3809                   if (type == 0x04)
3810                     {
3811                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3812                          Change it into:
3813                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3814                          (6 byte form of subl).  */
3815                       memcpy (contents + rel->r_offset - 3,
3816                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3817                       roff = rel->r_offset + 5;
3818                     }
3819                   else
3820                     {
3821                       /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3822                          Change it into:
3823                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3824                          (6 byte form of subl).  */
3825                       memcpy (contents + rel->r_offset - 2,
3826                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3827                       roff = rel->r_offset + 6;
3828                     }
3829                   bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3830                               contents + roff);
3831                   /* Skip R_386_PC32/R_386_PLT32.  */
3832                   rel++;
3833                   continue;
3834                 }
3835               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3836                 {
3837                   /* GDesc -> LE transition.
3838                      It's originally something like:
3839                      leal x@tlsdesc(%ebx), %eax
3840
3841                      leal x@ntpoff, %eax
3842
3843                      Registers other than %eax may be set up here.  */
3844
3845                   unsigned int val;
3846                   bfd_vma roff;
3847
3848                   roff = rel->r_offset;
3849                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3850
3851                   /* Now modify the instruction as appropriate.  */
3852                   /* aoliva FIXME: remove the above and xor the byte
3853                      below with 0x86.  */
3854                   bfd_put_8 (output_bfd, val ^ 0x86,
3855                              contents + roff - 1);
3856                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3857                               contents + roff);
3858                   continue;
3859                 }
3860               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3861                 {
3862                   /* GDesc -> LE transition.
3863                      It's originally:
3864                      call *(%eax)
3865                      Turn it into:
3866                      xchg %ax,%ax  */
3867
3868                   bfd_vma roff;
3869
3870                   roff = rel->r_offset;
3871                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3872                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3873                   continue;
3874                 }
3875               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
3876                 {
3877                   unsigned int val;
3878
3879                   /* IE->LE transition:
3880                      Originally it can be one of:
3881                      movl foo, %eax
3882                      movl foo, %reg
3883                      addl foo, %reg
3884                      We change it into:
3885                      movl $foo, %eax
3886                      movl $foo, %reg
3887                      addl $foo, %reg.  */
3888                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3889                   if (val == 0xa1)
3890                     {
3891                       /* movl foo, %eax.  */
3892                       bfd_put_8 (output_bfd, 0xb8,
3893                                  contents + rel->r_offset - 1);
3894                     }
3895                   else
3896                     {
3897                       unsigned int type;
3898
3899                       type = bfd_get_8 (input_bfd,
3900                                         contents + rel->r_offset - 2);
3901                       switch (type)
3902                         {
3903                         case 0x8b:
3904                           /* movl */
3905                           bfd_put_8 (output_bfd, 0xc7,
3906                                      contents + rel->r_offset - 2);
3907                           bfd_put_8 (output_bfd,
3908                                      0xc0 | ((val >> 3) & 7),
3909                                      contents + rel->r_offset - 1);
3910                           break;
3911                         case 0x03:
3912                           /* addl */
3913                           bfd_put_8 (output_bfd, 0x81,
3914                                      contents + rel->r_offset - 2);
3915                           bfd_put_8 (output_bfd,
3916                                      0xc0 | ((val >> 3) & 7),
3917                                      contents + rel->r_offset - 1);
3918                           break;
3919                         default:
3920                           BFD_FAIL ();
3921                           break;
3922                         }
3923                     }
3924                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3925                               contents + rel->r_offset);
3926                   continue;
3927                 }
3928               else
3929                 {
3930                   unsigned int val, type;
3931
3932                   /* {IE_32,GOTIE}->LE transition:
3933                      Originally it can be one of:
3934                      subl foo(%reg1), %reg2
3935                      movl foo(%reg1), %reg2
3936                      addl foo(%reg1), %reg2
3937                      We change it into:
3938                      subl $foo, %reg2
3939                      movl $foo, %reg2 (6 byte form)
3940                      addl $foo, %reg2.  */
3941                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3942                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3943                   if (type == 0x8b)
3944                     {
3945                       /* movl */
3946                       bfd_put_8 (output_bfd, 0xc7,
3947                                  contents + rel->r_offset - 2);
3948                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3949                                  contents + rel->r_offset - 1);
3950                     }
3951                   else if (type == 0x2b)
3952                     {
3953                       /* subl */
3954                       bfd_put_8 (output_bfd, 0x81,
3955                                  contents + rel->r_offset - 2);
3956                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3957                                  contents + rel->r_offset - 1);
3958                     }
3959                   else if (type == 0x03)
3960                     {
3961                       /* addl */
3962                       bfd_put_8 (output_bfd, 0x81,
3963                                  contents + rel->r_offset - 2);
3964                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3965                                  contents + rel->r_offset - 1);
3966                     }
3967                   else
3968                     BFD_FAIL ();
3969                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
3970                     bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3971                                 contents + rel->r_offset);
3972                   else
3973                     bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3974                                 contents + rel->r_offset);
3975                   continue;
3976                 }
3977             }
3978
3979           if (htab->elf.sgot == NULL)
3980             abort ();
3981
3982           if (h != NULL)
3983             {
3984               off = h->got.offset;
3985               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3986             }
3987           else
3988             {
3989               if (local_got_offsets == NULL)
3990                 abort ();
3991
3992               off = local_got_offsets[r_symndx];
3993               offplt = local_tlsdesc_gotents[r_symndx];
3994             }
3995
3996           if ((off & 1) != 0)
3997             off &= ~1;
3998           else
3999             {
4000               Elf_Internal_Rela outrel;
4001               int dr_type;
4002               asection *sreloc;
4003
4004               if (htab->elf.srelgot == NULL)
4005                 abort ();
4006
4007               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4008
4009               if (GOT_TLS_GDESC_P (tls_type))
4010                 {
4011                   bfd_byte *loc;
4012                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4013                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4014                               <= htab->elf.sgotplt->size);
4015                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4016                                      + htab->elf.sgotplt->output_offset
4017                                      + offplt
4018                                      + htab->sgotplt_jump_table_size);
4019                   sreloc = htab->elf.srelplt;
4020                   loc = sreloc->contents;
4021                   loc += (htab->next_tls_desc_index++
4022                           * sizeof (Elf32_External_Rel));
4023                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4024                               <= sreloc->contents + sreloc->size);
4025                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4026                   if (indx == 0)
4027                     {
4028                       BFD_ASSERT (! unresolved_reloc);
4029                       bfd_put_32 (output_bfd,
4030                                   relocation - elf_i386_dtpoff_base (info),
4031                                   htab->elf.sgotplt->contents + offplt
4032                                   + htab->sgotplt_jump_table_size + 4);
4033                     }
4034                   else
4035                     {
4036                       bfd_put_32 (output_bfd, 0,
4037                                   htab->elf.sgotplt->contents + offplt
4038                                   + htab->sgotplt_jump_table_size + 4);
4039                     }
4040                 }
4041
4042               sreloc = htab->elf.srelgot;
4043
4044               outrel.r_offset = (htab->elf.sgot->output_section->vma
4045                                  + htab->elf.sgot->output_offset + off);
4046
4047               if (GOT_TLS_GD_P (tls_type))
4048                 dr_type = R_386_TLS_DTPMOD32;
4049               else if (GOT_TLS_GDESC_P (tls_type))
4050                 goto dr_done;
4051               else if (tls_type == GOT_TLS_IE_POS)
4052                 dr_type = R_386_TLS_TPOFF;
4053               else
4054                 dr_type = R_386_TLS_TPOFF32;
4055
4056               if (dr_type == R_386_TLS_TPOFF && indx == 0)
4057                 bfd_put_32 (output_bfd,
4058                             relocation - elf_i386_dtpoff_base (info),
4059                             htab->elf.sgot->contents + off);
4060               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4061                 bfd_put_32 (output_bfd,
4062                             elf_i386_dtpoff_base (info) - relocation,
4063                             htab->elf.sgot->contents + off);
4064               else if (dr_type != R_386_TLS_DESC)
4065                 bfd_put_32 (output_bfd, 0,
4066                             htab->elf.sgot->contents + off);
4067               outrel.r_info = ELF32_R_INFO (indx, dr_type);
4068
4069               elf_append_rel (output_bfd, sreloc, &outrel);
4070
4071               if (GOT_TLS_GD_P (tls_type))
4072                 {
4073                   if (indx == 0)
4074                     {
4075                       BFD_ASSERT (! unresolved_reloc);
4076                       bfd_put_32 (output_bfd,
4077                                   relocation - elf_i386_dtpoff_base (info),
4078                                   htab->elf.sgot->contents + off + 4);
4079                     }
4080                   else
4081                     {
4082                       bfd_put_32 (output_bfd, 0,
4083                                   htab->elf.sgot->contents + off + 4);
4084                       outrel.r_info = ELF32_R_INFO (indx,
4085                                                     R_386_TLS_DTPOFF32);
4086                       outrel.r_offset += 4;
4087                       elf_append_rel (output_bfd, sreloc, &outrel);
4088                     }
4089                 }
4090               else if (tls_type == GOT_TLS_IE_BOTH)
4091                 {
4092                   bfd_put_32 (output_bfd,
4093                               (indx == 0
4094                                ? relocation - elf_i386_dtpoff_base (info)
4095                                : 0),
4096                               htab->elf.sgot->contents + off + 4);
4097                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4098                   outrel.r_offset += 4;
4099                   elf_append_rel (output_bfd, sreloc, &outrel);
4100                 }
4101
4102             dr_done:
4103               if (h != NULL)
4104                 h->got.offset |= 1;
4105               else
4106                 local_got_offsets[r_symndx] |= 1;
4107             }
4108
4109           if (off >= (bfd_vma) -2
4110               && ! GOT_TLS_GDESC_P (tls_type))
4111             abort ();
4112           if (r_type == R_386_TLS_GOTDESC
4113               || r_type == R_386_TLS_DESC_CALL)
4114             {
4115               relocation = htab->sgotplt_jump_table_size + offplt;
4116               unresolved_reloc = FALSE;
4117             }
4118           else if (r_type == ELF32_R_TYPE (rel->r_info))
4119             {
4120               bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4121                               + htab->elf.sgotplt->output_offset;
4122               relocation = htab->elf.sgot->output_section->vma
4123                 + htab->elf.sgot->output_offset + off - g_o_t;
4124               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4125                   && tls_type == GOT_TLS_IE_BOTH)
4126                 relocation += 4;
4127               if (r_type == R_386_TLS_IE)
4128                 relocation += g_o_t;
4129               unresolved_reloc = FALSE;
4130             }
4131           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4132             {
4133               unsigned int val, type;
4134               bfd_vma roff;
4135
4136               /* GD->IE transition.  */
4137               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4138               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4139               if (type == 0x04)
4140                 {
4141                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4142                      Change it into:
4143                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4144                   val >>= 3;
4145                   roff = rel->r_offset - 3;
4146                 }
4147               else
4148                 {
4149                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4150                      Change it into:
4151                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4152                   roff = rel->r_offset - 2;
4153                 }
4154               memcpy (contents + roff,
4155                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4156               contents[roff + 7] = 0x80 | (val & 7);
4157               /* If foo is used only with foo@gotntpoff(%reg) and
4158                  foo@indntpoff, but not with foo@gottpoff(%reg), change
4159                  subl $foo@gottpoff(%reg), %eax
4160                  into:
4161                  addl $foo@gotntpoff(%reg), %eax.  */
4162               if (tls_type == GOT_TLS_IE_POS)
4163                 contents[roff + 6] = 0x03;
4164               bfd_put_32 (output_bfd,
4165                           htab->elf.sgot->output_section->vma
4166                           + htab->elf.sgot->output_offset + off
4167                           - htab->elf.sgotplt->output_section->vma
4168                           - htab->elf.sgotplt->output_offset,
4169                           contents + roff + 8);
4170               /* Skip R_386_PLT32.  */
4171               rel++;
4172               continue;
4173             }
4174           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4175             {
4176               /* GDesc -> IE transition.
4177                  It's originally something like:
4178                  leal x@tlsdesc(%ebx), %eax
4179
4180                  Change it to:
4181                  movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4182                  or:
4183                  movl x@gottpoff(%ebx), %eax # before negl %eax
4184
4185                  Registers other than %eax may be set up here.  */
4186
4187               bfd_vma roff;
4188
4189               /* First, make sure it's a leal adding ebx to a 32-bit
4190                  offset into any register, although it's probably
4191                  almost always going to be eax.  */
4192               roff = rel->r_offset;
4193
4194               /* Now modify the instruction as appropriate.  */
4195               /* To turn a leal into a movl in the form we use it, it
4196                  suffices to change the first byte from 0x8d to 0x8b.
4197                  aoliva FIXME: should we decide to keep the leal, all
4198                  we have to do is remove the statement below, and
4199                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
4200               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4201
4202               if (tls_type == GOT_TLS_IE_BOTH)
4203                 off += 4;
4204
4205               bfd_put_32 (output_bfd,
4206                           htab->elf.sgot->output_section->vma
4207                           + htab->elf.sgot->output_offset + off
4208                           - htab->elf.sgotplt->output_section->vma
4209                           - htab->elf.sgotplt->output_offset,
4210                           contents + roff);
4211               continue;
4212             }
4213           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4214             {
4215               /* GDesc -> IE transition.
4216                  It's originally:
4217                  call *(%eax)
4218
4219                  Change it to:
4220                  xchg %ax,%ax
4221                  or
4222                  negl %eax
4223                  depending on how we transformed the TLS_GOTDESC above.
4224               */
4225
4226               bfd_vma roff;
4227
4228               roff = rel->r_offset;
4229
4230               /* Now modify the instruction as appropriate.  */
4231               if (tls_type != GOT_TLS_IE_NEG)
4232                 {
4233                   /* xchg %ax,%ax */
4234                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4235                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4236                 }
4237               else
4238                 {
4239                   /* negl %eax */
4240                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
4241                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4242                 }
4243
4244               continue;
4245             }
4246           else
4247             BFD_ASSERT (FALSE);
4248           break;
4249
4250         case R_386_TLS_LDM:
4251           if (! elf_i386_tls_transition (info, input_bfd,
4252                                          input_section, contents,
4253                                          symtab_hdr, sym_hashes,
4254                                          &r_type, GOT_UNKNOWN, rel,
4255                                          relend, h, r_symndx))
4256             return FALSE;
4257
4258           if (r_type != R_386_TLS_LDM)
4259             {
4260               /* LD->LE transition:
4261                  leal foo(%reg), %eax; call ___tls_get_addr.
4262                  We change it into:
4263                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
4264               BFD_ASSERT (r_type == R_386_TLS_LE_32);
4265               memcpy (contents + rel->r_offset - 2,
4266                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4267               /* Skip R_386_PC32/R_386_PLT32.  */
4268               rel++;
4269               continue;
4270             }
4271
4272           if (htab->elf.sgot == NULL)
4273             abort ();
4274
4275           off = htab->tls_ldm_got.offset;
4276           if (off & 1)
4277             off &= ~1;
4278           else
4279             {
4280               Elf_Internal_Rela outrel;
4281
4282               if (htab->elf.srelgot == NULL)
4283                 abort ();
4284
4285               outrel.r_offset = (htab->elf.sgot->output_section->vma
4286                                  + htab->elf.sgot->output_offset + off);
4287
4288               bfd_put_32 (output_bfd, 0,
4289                           htab->elf.sgot->contents + off);
4290               bfd_put_32 (output_bfd, 0,
4291                           htab->elf.sgot->contents + off + 4);
4292               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4293               elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
4294               htab->tls_ldm_got.offset |= 1;
4295             }
4296           relocation = htab->elf.sgot->output_section->vma
4297                        + htab->elf.sgot->output_offset + off
4298                        - htab->elf.sgotplt->output_section->vma
4299                        - htab->elf.sgotplt->output_offset;
4300           unresolved_reloc = FALSE;
4301           break;
4302
4303         case R_386_TLS_LDO_32:
4304           if (!info->executable || (input_section->flags & SEC_CODE) == 0)
4305             relocation -= elf_i386_dtpoff_base (info);
4306           else
4307             /* When converting LDO to LE, we must negate.  */
4308             relocation = -elf_i386_tpoff (info, relocation);
4309           break;
4310
4311         case R_386_TLS_LE_32:
4312         case R_386_TLS_LE:
4313           if (!info->executable)
4314             {
4315               Elf_Internal_Rela outrel;
4316               asection *sreloc;
4317
4318               outrel.r_offset = rel->r_offset
4319                                 + input_section->output_section->vma
4320                                 + input_section->output_offset;
4321               if (h != NULL && h->dynindx != -1)
4322                 indx = h->dynindx;
4323               else
4324                 indx = 0;
4325               if (r_type == R_386_TLS_LE_32)
4326                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4327               else
4328                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4329               sreloc = elf_section_data (input_section)->sreloc;
4330               if (sreloc == NULL)
4331                 abort ();
4332               elf_append_rel (output_bfd, sreloc, &outrel);
4333               if (indx)
4334                 continue;
4335               else if (r_type == R_386_TLS_LE_32)
4336                 relocation = elf_i386_dtpoff_base (info) - relocation;
4337               else
4338                 relocation -= elf_i386_dtpoff_base (info);
4339             }
4340           else if (r_type == R_386_TLS_LE_32)
4341             relocation = elf_i386_tpoff (info, relocation);
4342           else
4343             relocation = -elf_i386_tpoff (info, relocation);
4344           break;
4345
4346         default:
4347           break;
4348         }
4349
4350       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4351          because such sections are not SEC_ALLOC and thus ld.so will
4352          not process them.  */
4353       if (unresolved_reloc
4354           && !((input_section->flags & SEC_DEBUGGING) != 0
4355                && h->def_dynamic)
4356           && _bfd_elf_section_offset (output_bfd, info, input_section,
4357                                       rel->r_offset) != (bfd_vma) -1)
4358         {
4359           (*_bfd_error_handler)
4360             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4361              input_bfd,
4362              input_section,
4363              (long) rel->r_offset,
4364              howto->name,
4365              h->root.root.string);
4366           return FALSE;
4367         }
4368
4369 do_relocation:
4370       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4371                                     contents, rel->r_offset,
4372                                     relocation, 0);
4373
4374 check_relocation_error:
4375       if (r != bfd_reloc_ok)
4376         {
4377           const char *name;
4378
4379           if (h != NULL)
4380             name = h->root.root.string;
4381           else
4382             {
4383               name = bfd_elf_string_from_elf_section (input_bfd,
4384                                                       symtab_hdr->sh_link,
4385                                                       sym->st_name);
4386               if (name == NULL)
4387                 return FALSE;
4388               if (*name == '\0')
4389                 name = bfd_section_name (input_bfd, sec);
4390             }
4391
4392           if (r == bfd_reloc_overflow)
4393             {
4394               if (! ((*info->callbacks->reloc_overflow)
4395                      (info, (h ? &h->root : NULL), name, howto->name,
4396                       (bfd_vma) 0, input_bfd, input_section,
4397                       rel->r_offset)))
4398                 return FALSE;
4399             }
4400           else
4401             {
4402               (*_bfd_error_handler)
4403                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4404                  input_bfd, input_section,
4405                  (long) rel->r_offset, name, (int) r);
4406               return FALSE;
4407             }
4408         }
4409     }
4410
4411   return TRUE;
4412 }
4413
4414 /* Finish up dynamic symbol handling.  We set the contents of various
4415    dynamic sections here.  */
4416
4417 static bfd_boolean
4418 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4419                                 struct bfd_link_info *info,
4420                                 struct elf_link_hash_entry *h,
4421                                 Elf_Internal_Sym *sym)
4422 {
4423   struct elf_i386_link_hash_table *htab;
4424   unsigned plt_entry_size;
4425   const struct elf_i386_backend_data *abed;
4426
4427   htab = elf_i386_hash_table (info);
4428   if (htab == NULL)
4429     return FALSE;
4430
4431   abed = get_elf_i386_backend_data (output_bfd);
4432   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
4433
4434   if (h->plt.offset != (bfd_vma) -1)
4435     {
4436       bfd_vma plt_index;
4437       bfd_vma got_offset;
4438       Elf_Internal_Rela rel;
4439       bfd_byte *loc;
4440       asection *plt, *gotplt, *relplt;
4441
4442       /* When building a static executable, use .iplt, .igot.plt and
4443          .rel.iplt sections for STT_GNU_IFUNC symbols.  */
4444       if (htab->elf.splt != NULL)
4445         {
4446           plt = htab->elf.splt;
4447           gotplt = htab->elf.sgotplt;
4448           relplt = htab->elf.srelplt;
4449         }
4450       else
4451         {
4452           plt = htab->elf.iplt;
4453           gotplt = htab->elf.igotplt;
4454           relplt = htab->elf.irelplt;
4455         }
4456
4457       /* This symbol has an entry in the procedure linkage table.  Set
4458          it up.  */
4459
4460       if ((h->dynindx == -1
4461            && !((h->forced_local || info->executable)
4462                 && h->def_regular
4463                 && h->type == STT_GNU_IFUNC))
4464           || plt == NULL
4465           || gotplt == NULL
4466           || relplt == NULL)
4467         abort ();
4468
4469       /* Get the index in the procedure linkage table which
4470          corresponds to this symbol.  This is the index of this symbol
4471          in all the symbols for which we are making plt entries.  The
4472          first entry in the procedure linkage table is reserved.
4473
4474          Get the offset into the .got table of the entry that
4475          corresponds to this function.  Each .got entry is 4 bytes.
4476          The first three are reserved.
4477
4478          For static executables, we don't reserve anything.  */
4479
4480       if (plt == htab->elf.splt)
4481         {
4482           got_offset = h->plt.offset / plt_entry_size - 1;
4483           got_offset = (got_offset + 3) * 4;
4484         }
4485       else
4486         {
4487           got_offset = h->plt.offset / plt_entry_size;
4488           got_offset = got_offset * 4;
4489         }
4490
4491       /* Fill in the entry in the procedure linkage table.  */
4492       if (! info->shared)
4493         {
4494           memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
4495                   abed->plt->plt_entry_size);
4496           bfd_put_32 (output_bfd,
4497                       (gotplt->output_section->vma
4498                        + gotplt->output_offset
4499                        + got_offset),
4500                       plt->contents + h->plt.offset
4501                       + abed->plt->plt_got_offset);
4502
4503           if (abed->is_vxworks)
4504             {
4505               int s, k, reloc_index;
4506
4507               /* Create the R_386_32 relocation referencing the GOT
4508                  for this PLT entry.  */
4509
4510               /* S: Current slot number (zero-based).  */
4511               s = ((h->plt.offset - abed->plt->plt_entry_size)
4512                    / abed->plt->plt_entry_size);
4513               /* K: Number of relocations for PLTResolve. */
4514               if (info->shared)
4515                 k = PLTRESOLVE_RELOCS_SHLIB;
4516               else
4517                 k = PLTRESOLVE_RELOCS;
4518               /* Skip the PLTresolve relocations, and the relocations for
4519                  the other PLT slots. */
4520               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4521               loc = (htab->srelplt2->contents + reloc_index
4522                      * sizeof (Elf32_External_Rel));
4523
4524               rel.r_offset = (htab->elf.splt->output_section->vma
4525                               + htab->elf.splt->output_offset
4526                               + h->plt.offset + 2),
4527               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4528               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4529
4530               /* Create the R_386_32 relocation referencing the beginning of
4531                  the PLT for this GOT entry.  */
4532               rel.r_offset = (htab->elf.sgotplt->output_section->vma
4533                               + htab->elf.sgotplt->output_offset
4534                               + got_offset);
4535               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4536               bfd_elf32_swap_reloc_out (output_bfd, &rel,
4537                                         loc + sizeof (Elf32_External_Rel));
4538             }
4539         }
4540       else
4541         {
4542           memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
4543                   abed->plt->plt_entry_size);
4544           bfd_put_32 (output_bfd, got_offset,
4545                       plt->contents + h->plt.offset
4546                       + abed->plt->plt_got_offset);
4547         }
4548
4549       /* Fill in the entry in the global offset table.  */
4550       bfd_put_32 (output_bfd,
4551                   (plt->output_section->vma
4552                    + plt->output_offset
4553                    + h->plt.offset
4554                    + abed->plt->plt_lazy_offset),
4555                   gotplt->contents + got_offset);
4556
4557       /* Fill in the entry in the .rel.plt section.  */
4558       rel.r_offset = (gotplt->output_section->vma
4559                       + gotplt->output_offset
4560                       + got_offset);
4561       if (h->dynindx == -1
4562           || ((info->executable
4563                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4564               && h->def_regular
4565                && h->type == STT_GNU_IFUNC))
4566         {
4567           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4568              R_386_IRELATIVE instead of R_386_JUMP_SLOT.  Store addend
4569              in the .got.plt section.  */
4570           bfd_put_32 (output_bfd,
4571                       (h->root.u.def.value
4572                        + h->root.u.def.section->output_section->vma
4573                        + h->root.u.def.section->output_offset),
4574                       gotplt->contents + got_offset);
4575           rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4576           /* R_386_IRELATIVE comes last.  */
4577           plt_index = htab->next_irelative_index--;
4578         }
4579       else
4580         {
4581           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
4582           plt_index = htab->next_jump_slot_index++;
4583         }
4584       loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
4585       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4586
4587       /* Don't fill PLT entry for static executables.  */
4588       if (plt == htab->elf.splt)
4589         {
4590           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
4591                       plt->contents + h->plt.offset
4592                       + abed->plt->plt_reloc_offset);
4593           bfd_put_32 (output_bfd, - (h->plt.offset
4594                                      + abed->plt->plt_plt_offset + 4),
4595                       plt->contents + h->plt.offset
4596                       + abed->plt->plt_plt_offset);
4597         }
4598
4599       if (!h->def_regular)
4600         {
4601           /* Mark the symbol as undefined, rather than as defined in
4602              the .plt section.  Leave the value if there were any
4603              relocations where pointer equality matters (this is a clue
4604              for the dynamic linker, to make function pointer
4605              comparisons work between an application and shared
4606              library), otherwise set it to zero.  If a function is only
4607              called from a binary, there is no need to slow down
4608              shared libraries because of that.  */
4609           sym->st_shndx = SHN_UNDEF;
4610           if (!h->pointer_equality_needed)
4611             sym->st_value = 0;
4612         }
4613     }
4614
4615   if (h->got.offset != (bfd_vma) -1
4616       && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
4617       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
4618     {
4619       Elf_Internal_Rela rel;
4620
4621       /* This symbol has an entry in the global offset table.  Set it
4622          up.  */
4623
4624       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4625         abort ();
4626
4627       rel.r_offset = (htab->elf.sgot->output_section->vma
4628                       + htab->elf.sgot->output_offset
4629                       + (h->got.offset & ~(bfd_vma) 1));
4630
4631       /* If this is a static link, or it is a -Bsymbolic link and the
4632          symbol is defined locally or was forced to be local because
4633          of a version file, we just want to emit a RELATIVE reloc.
4634          The entry in the global offset table will already have been
4635          initialized in the relocate_section function.  */
4636       if (h->def_regular
4637           && h->type == STT_GNU_IFUNC)
4638         {
4639           if (info->shared)
4640             {
4641               /* Generate R_386_GLOB_DAT.  */
4642               goto do_glob_dat;
4643             }
4644           else
4645             {
4646               asection *plt;
4647
4648               if (!h->pointer_equality_needed)
4649                 abort ();
4650
4651               /* For non-shared object, we can't use .got.plt, which
4652                  contains the real function addres if we need pointer
4653                  equality.  We load the GOT entry with the PLT entry.  */
4654               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4655               bfd_put_32 (output_bfd,
4656                           (plt->output_section->vma
4657                            + plt->output_offset + h->plt.offset),
4658                           htab->elf.sgot->contents + h->got.offset);
4659               return TRUE;
4660             }
4661         }
4662       else if (info->shared
4663                && SYMBOL_REFERENCES_LOCAL (info, h))
4664         {
4665           BFD_ASSERT((h->got.offset & 1) != 0);
4666           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4667         }
4668       else
4669         {
4670           BFD_ASSERT((h->got.offset & 1) == 0);
4671 do_glob_dat:
4672           bfd_put_32 (output_bfd, (bfd_vma) 0,
4673                       htab->elf.sgot->contents + h->got.offset);
4674           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
4675         }
4676
4677       elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
4678     }
4679
4680   if (h->needs_copy)
4681     {
4682       Elf_Internal_Rela rel;
4683
4684       /* This symbol needs a copy reloc.  Set it up.  */
4685
4686       if (h->dynindx == -1
4687           || (h->root.type != bfd_link_hash_defined
4688               && h->root.type != bfd_link_hash_defweak)
4689           || htab->srelbss == NULL)
4690         abort ();
4691
4692       rel.r_offset = (h->root.u.def.value
4693                       + h->root.u.def.section->output_section->vma
4694                       + h->root.u.def.section->output_offset);
4695       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
4696       elf_append_rel (output_bfd, htab->srelbss, &rel);
4697     }
4698
4699   return TRUE;
4700 }
4701
4702 /* Finish up local dynamic symbol handling.  We set the contents of
4703    various dynamic sections here.  */
4704
4705 static bfd_boolean
4706 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
4707 {
4708   struct elf_link_hash_entry *h
4709     = (struct elf_link_hash_entry *) *slot;
4710   struct bfd_link_info *info
4711     = (struct bfd_link_info *) inf;
4712
4713   return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
4714                                          h, NULL);
4715 }
4716
4717 /* Used to decide how to sort relocs in an optimal manner for the
4718    dynamic linker, before writing them out.  */
4719
4720 static enum elf_reloc_type_class
4721 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
4722 {
4723   switch (ELF32_R_TYPE (rela->r_info))
4724     {
4725     case R_386_RELATIVE:
4726       return reloc_class_relative;
4727     case R_386_JUMP_SLOT:
4728       return reloc_class_plt;
4729     case R_386_COPY:
4730       return reloc_class_copy;
4731     default:
4732       return reloc_class_normal;
4733     }
4734 }
4735
4736 /* Finish up the dynamic sections.  */
4737
4738 static bfd_boolean
4739 elf_i386_finish_dynamic_sections (bfd *output_bfd,
4740                                   struct bfd_link_info *info)
4741 {
4742   struct elf_i386_link_hash_table *htab;
4743   bfd *dynobj;
4744   asection *sdyn;
4745   const struct elf_i386_backend_data *abed;
4746
4747   htab = elf_i386_hash_table (info);
4748   if (htab == NULL)
4749     return FALSE;
4750
4751   dynobj = htab->elf.dynobj;
4752   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4753   abed = get_elf_i386_backend_data (output_bfd);
4754
4755   if (htab->elf.dynamic_sections_created)
4756     {
4757       Elf32_External_Dyn *dyncon, *dynconend;
4758
4759       if (sdyn == NULL || htab->elf.sgot == NULL)
4760         abort ();
4761
4762       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4763       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4764       for (; dyncon < dynconend; dyncon++)
4765         {
4766           Elf_Internal_Dyn dyn;
4767           asection *s;
4768
4769           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4770
4771           switch (dyn.d_tag)
4772             {
4773             default:
4774               if (abed->is_vxworks
4775                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4776                 break;
4777               continue;
4778
4779             case DT_PLTGOT:
4780               s = htab->elf.sgotplt;
4781               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4782               break;
4783
4784             case DT_JMPREL:
4785               s = htab->elf.srelplt;
4786               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4787               break;
4788
4789             case DT_PLTRELSZ:
4790               s = htab->elf.srelplt;
4791               dyn.d_un.d_val = s->size;
4792               break;
4793
4794             case DT_RELSZ:
4795               /* My reading of the SVR4 ABI indicates that the
4796                  procedure linkage table relocs (DT_JMPREL) should be
4797                  included in the overall relocs (DT_REL).  This is
4798                  what Solaris does.  However, UnixWare can not handle
4799                  that case.  Therefore, we override the DT_RELSZ entry
4800                  here to make it not include the JMPREL relocs.  */
4801               s = htab->elf.srelplt;
4802               if (s == NULL)
4803                 continue;
4804               dyn.d_un.d_val -= s->size;
4805               break;
4806
4807             case DT_REL:
4808               /* We may not be using the standard ELF linker script.
4809                  If .rel.plt is the first .rel section, we adjust
4810                  DT_REL to not include it.  */
4811               s = htab->elf.srelplt;
4812               if (s == NULL)
4813                 continue;
4814               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4815                 continue;
4816               dyn.d_un.d_ptr += s->size;
4817               break;
4818             }
4819
4820           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4821         }
4822
4823       /* Fill in the first entry in the procedure linkage table.  */
4824       if (htab->elf.splt && htab->elf.splt->size > 0)
4825         {
4826           if (info->shared)
4827             {
4828               memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
4829                       abed->plt->plt0_entry_size);
4830               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4831                       abed->plt0_pad_byte,
4832                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4833             }
4834           else
4835             {
4836               memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
4837                       abed->plt->plt0_entry_size);
4838               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4839                       abed->plt0_pad_byte,
4840                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4841               bfd_put_32 (output_bfd,
4842                           (htab->elf.sgotplt->output_section->vma
4843                            + htab->elf.sgotplt->output_offset
4844                            + 4),
4845                           htab->elf.splt->contents
4846                           + abed->plt->plt0_got1_offset);
4847               bfd_put_32 (output_bfd,
4848                           (htab->elf.sgotplt->output_section->vma
4849                            + htab->elf.sgotplt->output_offset
4850                            + 8),
4851                           htab->elf.splt->contents
4852                           + abed->plt->plt0_got2_offset);
4853
4854               if (abed->is_vxworks)
4855                 {
4856                   Elf_Internal_Rela rel;
4857
4858                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4859                      On IA32 we use REL relocations so the addend goes in
4860                      the PLT directly.  */
4861                   rel.r_offset = (htab->elf.splt->output_section->vma
4862                                   + htab->elf.splt->output_offset
4863                                   + abed->plt->plt0_got1_offset);
4864                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4865                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4866                                             htab->srelplt2->contents);
4867                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
4868                   rel.r_offset = (htab->elf.splt->output_section->vma
4869                                   + htab->elf.splt->output_offset
4870                                   + abed->plt->plt0_got2_offset);
4871                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4872                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4873                                             htab->srelplt2->contents +
4874                                             sizeof (Elf32_External_Rel));
4875                 }
4876             }
4877
4878           /* UnixWare sets the entsize of .plt to 4, although that doesn't
4879              really seem like the right value.  */
4880           elf_section_data (htab->elf.splt->output_section)
4881             ->this_hdr.sh_entsize = 4;
4882
4883           /* Correct the .rel.plt.unloaded relocations.  */
4884           if (abed->is_vxworks && !info->shared)
4885             {
4886               int num_plts = (htab->elf.splt->size
4887                               / abed->plt->plt_entry_size) - 1;
4888               unsigned char *p;
4889
4890               p = htab->srelplt2->contents;
4891               if (info->shared)
4892                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4893               else
4894                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4895
4896               for (; num_plts; num_plts--)
4897                 {
4898                   Elf_Internal_Rela rel;
4899                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4900                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4901                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4902                   p += sizeof (Elf32_External_Rel);
4903
4904                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4905                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4906                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4907                   p += sizeof (Elf32_External_Rel);
4908                 }
4909             }
4910         }
4911     }
4912
4913   if (htab->elf.sgotplt)
4914     {
4915       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4916         {
4917           (*_bfd_error_handler)
4918             (_("discarded output section: `%A'"), htab->elf.sgotplt);
4919           return FALSE;
4920         }
4921
4922       /* Fill in the first three entries in the global offset table.  */
4923       if (htab->elf.sgotplt->size > 0)
4924         {
4925           bfd_put_32 (output_bfd,
4926                       (sdyn == NULL ? 0
4927                        : sdyn->output_section->vma + sdyn->output_offset),
4928                       htab->elf.sgotplt->contents);
4929           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
4930           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
4931         }
4932
4933       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
4934     }
4935
4936   /* Adjust .eh_frame for .plt section.  */
4937   if (htab->plt_eh_frame != NULL
4938       && htab->plt_eh_frame->contents != NULL)
4939     {
4940       if (htab->elf.splt != NULL
4941           && htab->elf.splt->size != 0
4942           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4943           && htab->elf.splt->output_section != NULL
4944           && htab->plt_eh_frame->output_section != NULL)
4945         {
4946           bfd_vma plt_start = htab->elf.splt->output_section->vma;
4947           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4948                                    + htab->plt_eh_frame->output_offset
4949                                    + PLT_FDE_START_OFFSET;
4950           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4951                              htab->plt_eh_frame->contents
4952                              + PLT_FDE_START_OFFSET);
4953         }
4954       if (htab->plt_eh_frame->sec_info_type
4955           == SEC_INFO_TYPE_EH_FRAME)
4956         {
4957           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4958                                                  htab->plt_eh_frame,
4959                                                  htab->plt_eh_frame->contents))
4960             return FALSE;
4961         }
4962     }
4963
4964   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4965     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
4966
4967   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4968   htab_traverse (htab->loc_hash_table,
4969                  elf_i386_finish_local_dynamic_symbol,
4970                  info);
4971
4972   return TRUE;
4973 }
4974
4975 /* Return address for Ith PLT stub in section PLT, for relocation REL
4976    or (bfd_vma) -1 if it should not be included.  */
4977
4978 static bfd_vma
4979 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
4980                       const arelent *rel ATTRIBUTE_UNUSED)
4981 {
4982   return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4983 }
4984
4985 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
4986
4987 static bfd_boolean
4988 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
4989 {
4990   if (h->plt.offset != (bfd_vma) -1
4991       && !h->def_regular
4992       && !h->pointer_equality_needed)
4993     return FALSE;
4994
4995   return _bfd_elf_hash_symbol (h);
4996 }
4997
4998 /* Hook called by the linker routine which adds symbols from an object
4999    file.  */
5000
5001 static bfd_boolean
5002 elf_i386_add_symbol_hook (bfd * abfd,
5003                           struct bfd_link_info * info ATTRIBUTE_UNUSED,
5004                           Elf_Internal_Sym * sym,
5005                           const char ** namep ATTRIBUTE_UNUSED,
5006                           flagword * flagsp ATTRIBUTE_UNUSED,
5007                           asection ** secp ATTRIBUTE_UNUSED,
5008                           bfd_vma * valp ATTRIBUTE_UNUSED)
5009 {
5010   if ((abfd->flags & DYNAMIC) == 0
5011       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5012           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
5013     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5014
5015   return TRUE;
5016 }
5017
5018 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
5019 #define TARGET_LITTLE_NAME              "elf32-i386"
5020 #define ELF_ARCH                        bfd_arch_i386
5021 #define ELF_TARGET_ID                   I386_ELF_DATA
5022 #define ELF_MACHINE_CODE                EM_386
5023 #define ELF_MAXPAGESIZE                 0x1000
5024
5025 #define elf_backend_can_gc_sections     1
5026 #define elf_backend_can_refcount        1
5027 #define elf_backend_want_got_plt        1
5028 #define elf_backend_plt_readonly        1
5029 #define elf_backend_want_plt_sym        0
5030 #define elf_backend_got_header_size     12
5031 #define elf_backend_plt_alignment       4
5032
5033 /* Support RELA for objdump of prelink objects.  */
5034 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
5035 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
5036
5037 #define bfd_elf32_mkobject                    elf_i386_mkobject
5038
5039 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
5040 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
5041 #define bfd_elf32_bfd_link_hash_table_free    elf_i386_link_hash_table_free
5042 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
5043 #define bfd_elf32_bfd_reloc_name_lookup       elf_i386_reloc_name_lookup
5044
5045 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
5046 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
5047 #define elf_backend_check_relocs              elf_i386_check_relocs
5048 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
5049 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
5050 #define elf_backend_fake_sections             elf_i386_fake_sections
5051 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
5052 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
5053 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
5054 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
5055 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
5056 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
5057 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
5058 #define elf_backend_relocate_section          elf_i386_relocate_section
5059 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
5060 #define elf_backend_always_size_sections      elf_i386_always_size_sections
5061 #define elf_backend_omit_section_dynsym \
5062   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5063 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
5064 #define elf_backend_hash_symbol               elf_i386_hash_symbol
5065 #define elf_backend_add_symbol_hook           elf_i386_add_symbol_hook
5066 #undef  elf_backend_post_process_headers
5067 #define elf_backend_post_process_headers        _bfd_elf_set_osabi
5068
5069 #include "elf32-target.h"
5070
5071 /* FreeBSD support.  */
5072
5073 #undef  TARGET_LITTLE_SYM
5074 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
5075 #undef  TARGET_LITTLE_NAME
5076 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
5077 #undef  ELF_OSABI
5078 #define ELF_OSABI                       ELFOSABI_FREEBSD
5079
5080 /* The kernel recognizes executables as valid only if they carry a
5081    "FreeBSD" label in the ELF header.  So we put this label on all
5082    executables and (for simplicity) also all other object files.  */
5083
5084 static void
5085 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5086 {
5087   _bfd_elf_set_osabi (abfd, info);
5088
5089 #ifdef OLD_FREEBSD_ABI_LABEL
5090   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
5091   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5092 #endif
5093 }
5094
5095 #undef  elf_backend_post_process_headers
5096 #define elf_backend_post_process_headers        elf_i386_fbsd_post_process_headers
5097 #undef  elf32_bed
5098 #define elf32_bed                               elf32_i386_fbsd_bed
5099
5100 #undef elf_backend_add_symbol_hook
5101
5102 #include "elf32-target.h"
5103
5104 /* Solaris 2.  */
5105
5106 #undef  TARGET_LITTLE_SYM
5107 #define TARGET_LITTLE_SYM               bfd_elf32_i386_sol2_vec
5108 #undef  TARGET_LITTLE_NAME
5109 #define TARGET_LITTLE_NAME              "elf32-i386-sol2"
5110
5111 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5112    objects won't be recognized.  */
5113 #undef ELF_OSABI
5114
5115 #undef  elf32_bed
5116 #define elf32_bed                       elf32_i386_sol2_bed
5117
5118 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5119    boundary.  */
5120 #undef elf_backend_static_tls_alignment
5121 #define elf_backend_static_tls_alignment 8
5122
5123 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5124
5125    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5126    File, p.63.  */
5127 #undef elf_backend_want_plt_sym
5128 #define elf_backend_want_plt_sym        1
5129
5130 #include "elf32-target.h"
5131
5132 /* Native Client support.  */
5133
5134 #undef  TARGET_LITTLE_SYM
5135 #define TARGET_LITTLE_SYM               bfd_elf32_i386_nacl_vec
5136 #undef  TARGET_LITTLE_NAME
5137 #define TARGET_LITTLE_NAME              "elf32-i386-nacl"
5138 #undef  elf32_bed
5139 #define elf32_bed                       elf32_i386_nacl_bed
5140
5141 #undef  ELF_MAXPAGESIZE
5142 #define ELF_MAXPAGESIZE                 0x10000
5143
5144 /* Restore defaults.  */
5145 #undef  ELF_OSABI
5146 #undef  elf_backend_want_plt_sym
5147 #define elf_backend_want_plt_sym        0
5148 #undef  elf_backend_post_process_headers
5149 #define elf_backend_post_process_headers        _bfd_elf_set_osabi
5150 #undef  elf_backend_static_tls_alignment
5151
5152 /* NaCl uses substantially different PLT entries for the same effects.  */
5153
5154 #undef  elf_backend_plt_alignment
5155 #define elf_backend_plt_alignment       5
5156 #define NACL_PLT_ENTRY_SIZE             64
5157 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5158
5159 static const bfd_byte elf_i386_nacl_plt0_entry[] =
5160   {
5161     0xff, 0x35,                   /* pushl contents of address */
5162     0, 0, 0, 0,                   /* replaced with address of .got + 4.  */
5163     0x8b, 0x0d,                   /* movl contents of address, %ecx */
5164     0, 0, 0, 0,                   /* replaced with address of .got + 8.  */
5165     0x83, 0xe1, NACLMASK,         /* andl $NACLMASK, %ecx */
5166     0xff, 0xe1                    /* jmp *%ecx */
5167   };
5168
5169 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5170   {
5171     0x8b, 0x0d,                         /* movl contents of address, %ecx */
5172     0, 0, 0, 0,                         /* replaced with GOT slot address.  */
5173     0x83, 0xe1, NACLMASK,               /* andl $NACLMASK, %ecx */
5174     0xff, 0xe1,                         /* jmp *%ecx */
5175
5176     /* Pad to the next 32-byte boundary with nop instructions.  */
5177     0x90,
5178     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5179     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5180
5181     /* Lazy GOT entries point here (32-byte aligned).  */
5182     0x68,                              /* pushl immediate */
5183     0, 0, 0, 0,                        /* replaced with reloc offset.  */
5184     0xe9,                              /* jmp relative */
5185     0, 0, 0, 0,                        /* replaced with offset to .plt.  */
5186
5187     /* Pad to the next 32-byte boundary with nop instructions.  */
5188     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5189     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5190     0x90, 0x90
5191   };
5192
5193 static const bfd_byte
5194 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
5195   {
5196     0xff, 0x73, 0x04,           /* pushl 4(%ebx) */
5197     0x8b, 0x4b, 0x08,           /* mov 0x8(%ebx), %ecx */
5198     0x83, 0xe1, 0xe0,           /* and $NACLMASK, %ecx */
5199     0xff, 0xe1,                 /* jmp *%ecx */
5200
5201     /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5202        so pad to that size with nop instructions.  */
5203     0x90, 0x90, 0x90, 0x90, 0x90, 0x90
5204   };
5205
5206 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
5207   {
5208     0x8b, 0x8b,          /* movl offset(%ebx), %ecx */
5209     0, 0, 0, 0,          /* replaced with offset of this symbol in .got.  */
5210     0x83, 0xe1, 0xe0,    /* andl $NACLMASK, %ecx */
5211     0xff, 0xe1,          /* jmp *%ecx */
5212
5213     /* Pad to the next 32-byte boundary with nop instructions.  */
5214     0x90,
5215     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5216     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5217
5218     /* Lazy GOT entries point here (32-byte aligned).  */
5219     0x68,                /* pushl immediate */
5220     0, 0, 0, 0,          /* replaced with offset into relocation table.  */
5221     0xe9,                /* jmp relative */
5222     0, 0, 0, 0,          /* replaced with offset to start of .plt.  */
5223
5224     /* Pad to the next 32-byte boundary with nop instructions.  */
5225     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5226     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5227     0x90, 0x90
5228   };
5229
5230 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
5231   {
5232 #if (PLT_CIE_LENGTH != 20                               \
5233      || PLT_FDE_LENGTH != 36                            \
5234      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5235      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5236 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
5237 #endif
5238     PLT_CIE_LENGTH, 0, 0, 0,            /* CIE length */
5239     0, 0, 0, 0,                         /* CIE ID */
5240     1,                                  /* CIE version */
5241     'z', 'R', 0,                        /* Augmentation string */
5242     1,                                  /* Code alignment factor */
5243     0x7c,                               /* Data alignment factor: -4 */
5244     8,                                  /* Return address column */
5245     1,                                  /* Augmentation size */
5246     DW_EH_PE_pcrel | DW_EH_PE_sdata4,   /* FDE encoding */
5247     DW_CFA_def_cfa, 4, 4,               /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
5248     DW_CFA_offset + 8, 1,               /* DW_CFA_offset: r8 (eip) at cfa-4 */
5249     DW_CFA_nop, DW_CFA_nop,
5250
5251     PLT_FDE_LENGTH, 0, 0, 0,     /* FDE length */
5252     PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
5253     0, 0, 0, 0,                  /* R_386_PC32 .plt goes here */
5254     0, 0, 0, 0,                  /* .plt size goes here */
5255     0,                           /* Augmentation size */
5256     DW_CFA_def_cfa_offset, 8,    /* DW_CFA_def_cfa_offset: 8 */
5257     DW_CFA_advance_loc + 6,      /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5258     DW_CFA_def_cfa_offset, 12,   /* DW_CFA_def_cfa_offset: 12 */
5259     DW_CFA_advance_loc + 58,     /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5260     DW_CFA_def_cfa_expression,   /* DW_CFA_def_cfa_expression */
5261     13,                          /* Block length */
5262     DW_OP_breg4, 4,              /* DW_OP_breg4 (esp): 4 */
5263     DW_OP_breg8, 0,              /* DW_OP_breg8 (eip): 0 */
5264     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5265     DW_OP_lit2, DW_OP_shl, DW_OP_plus,
5266     DW_CFA_nop, DW_CFA_nop
5267   };
5268
5269 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
5270   {
5271     elf_i386_nacl_plt0_entry,           /* plt0_entry */
5272     sizeof (elf_i386_nacl_plt0_entry),  /* plt0_entry_size */
5273     2,                                  /* plt0_got1_offset */
5274     8,                                  /* plt0_got2_offset */
5275     elf_i386_nacl_plt_entry,            /* plt_entry */
5276     NACL_PLT_ENTRY_SIZE,                /* plt_entry_size */
5277     2,                                  /* plt_got_offset */
5278     33,                                 /* plt_reloc_offset */
5279     38,                                 /* plt_plt_offset */
5280     32,                                 /* plt_lazy_offset */
5281     elf_i386_nacl_pic_plt0_entry,       /* pic_plt0_entry */
5282     elf_i386_nacl_pic_plt_entry,        /* pic_plt_entry */
5283     elf_i386_nacl_eh_frame_plt,         /* eh_frame_plt */
5284     sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
5285   };
5286
5287 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
5288   {
5289     &elf_i386_nacl_plt,                      /* plt */
5290     0x90,                               /* plt0_pad_byte: nop insn */
5291     0,                                  /* is_vxworks */
5292   };
5293
5294 #undef  elf_backend_arch_data
5295 #define elf_backend_arch_data   &elf_i386_nacl_arch_bed
5296
5297 #undef  elf_backend_modify_segment_map
5298 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5299 #undef  elf_backend_modify_program_headers
5300 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5301
5302 #include "elf32-target.h"
5303
5304 /* Restore defaults.  */
5305 #undef  elf_backend_modify_segment_map
5306 #undef  elf_backend_modify_program_headers
5307
5308 /* VxWorks support.  */
5309
5310 #undef  TARGET_LITTLE_SYM
5311 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
5312 #undef  TARGET_LITTLE_NAME
5313 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
5314 #undef  ELF_OSABI
5315 #undef  elf_backend_plt_alignment
5316 #define elf_backend_plt_alignment       4
5317
5318 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
5319   {
5320     &elf_i386_plt,                      /* plt */
5321     0x90,                               /* plt0_pad_byte */
5322     1,                                  /* is_vxworks */
5323   };
5324
5325 #undef  elf_backend_arch_data
5326 #define elf_backend_arch_data   &elf_i386_vxworks_arch_bed
5327
5328 #undef elf_backend_relocs_compatible
5329 #undef elf_backend_post_process_headers
5330 #undef elf_backend_add_symbol_hook
5331 #define elf_backend_add_symbol_hook \
5332   elf_vxworks_add_symbol_hook
5333 #undef elf_backend_link_output_symbol_hook
5334 #define elf_backend_link_output_symbol_hook \
5335   elf_vxworks_link_output_symbol_hook
5336 #undef elf_backend_emit_relocs
5337 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
5338 #undef elf_backend_final_write_processing
5339 #define elf_backend_final_write_processing \
5340   elf_vxworks_final_write_processing
5341 #undef elf_backend_static_tls_alignment
5342
5343 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
5344    define it.  */
5345 #undef elf_backend_want_plt_sym
5346 #define elf_backend_want_plt_sym        1
5347
5348 #undef  elf32_bed
5349 #define elf32_bed                               elf32_i386_vxworks_bed
5350
5351 #include "elf32-target.h"