bfd/elf32-i386.c

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