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       || discarded_section (sec))
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               && bfd_get_8 (input_bfd,
2584                             contents + irel->r_offset - 2) == 0x8b)
2585             {
2586               bfd_put_8 (output_bfd, 0x8d,
2587                          contents + irel->r_offset - 2);
2588               irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2589               if (local_got_refcounts != NULL
2590                   && local_got_refcounts[r_symndx] > 0)
2591                 local_got_refcounts[r_symndx] -= 1;
2592               changed_contents = TRUE;
2593               changed_relocs = TRUE;
2594             }
2595           continue;
2596         }
2597
2598       indx = r_symndx - symtab_hdr->sh_info;
2599       h = elf_sym_hashes (abfd)[indx];
2600       BFD_ASSERT (h != NULL);
2601
2602       while (h->root.type == bfd_link_hash_indirect
2603              || h->root.type == bfd_link_hash_warning)
2604         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2605
2606       /* STT_GNU_IFUNC must keep R_386_GOT32 relocation.  We also avoid
2607          optimizing _DYNAMIC since ld.so may use its link-time address.  */
2608       if (h->def_regular
2609           && h->type != STT_GNU_IFUNC
2610           && h != htab->elf.hdynamic
2611           && SYMBOL_REFERENCES_LOCAL (link_info, h)
2612           && bfd_get_8 (input_bfd,
2613                         contents + irel->r_offset - 2) == 0x8b)
2614         {
2615           bfd_put_8 (output_bfd, 0x8d,
2616                      contents + irel->r_offset - 2);
2617           irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2618           if (h->got.refcount > 0)
2619             h->got.refcount -= 1;
2620           changed_contents = TRUE;
2621           changed_relocs = TRUE;
2622         }
2623     }
2624
2625   if (contents != NULL
2626       && elf_section_data (sec)->this_hdr.contents != contents)
2627     {
2628       if (!changed_contents && !link_info->keep_memory)
2629         free (contents);
2630       else
2631         {
2632           /* Cache the section contents for elf_link_input_bfd.  */
2633           elf_section_data (sec)->this_hdr.contents = contents;
2634         }
2635     }
2636
2637   if (elf_section_data (sec)->relocs != internal_relocs)
2638     {
2639       if (!changed_relocs)
2640         free (internal_relocs);
2641       else
2642         elf_section_data (sec)->relocs = internal_relocs;
2643     }
2644
2645   return TRUE;
2646
2647  error_return:
2648   if (contents != NULL
2649       && elf_section_data (sec)->this_hdr.contents != contents)
2650     free (contents);
2651   if (internal_relocs != NULL
2652       && elf_section_data (sec)->relocs != internal_relocs)
2653     free (internal_relocs);
2654   return FALSE;
2655 }
2656
2657 /* Set the sizes of the dynamic sections.  */
2658
2659 static bfd_boolean
2660 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2661 {
2662   struct elf_i386_link_hash_table *htab;
2663   bfd *dynobj;
2664   asection *s;
2665   bfd_boolean relocs;
2666   bfd *ibfd;
2667
2668   htab = elf_i386_hash_table (info);
2669   if (htab == NULL)
2670     return FALSE;
2671   dynobj = htab->elf.dynobj;
2672   if (dynobj == NULL)
2673     abort ();
2674
2675   if (htab->elf.dynamic_sections_created)
2676     {
2677       /* Set the contents of the .interp section to the interpreter.  */
2678       if (info->executable)
2679         {
2680           s = bfd_get_linker_section (dynobj, ".interp");
2681           if (s == NULL)
2682             abort ();
2683           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2684           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2685         }
2686     }
2687
2688   /* Set up .got offsets for local syms, and space for local dynamic
2689      relocs.  */
2690   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2691     {
2692       bfd_signed_vma *local_got;
2693       bfd_signed_vma *end_local_got;
2694       char *local_tls_type;
2695       bfd_vma *local_tlsdesc_gotent;
2696       bfd_size_type locsymcount;
2697       Elf_Internal_Shdr *symtab_hdr;
2698       asection *srel;
2699
2700       if (! is_i386_elf (ibfd))
2701         continue;
2702
2703       for (s = ibfd->sections; s != NULL; s = s->next)
2704         {
2705           struct elf_dyn_relocs *p;
2706
2707           if (!elf_i386_convert_mov_to_lea (ibfd, s, info))
2708             return FALSE;
2709
2710           for (p = ((struct elf_dyn_relocs *)
2711                      elf_section_data (s)->local_dynrel);
2712                p != NULL;
2713                p = p->next)
2714             {
2715               if (!bfd_is_abs_section (p->sec)
2716                   && bfd_is_abs_section (p->sec->output_section))
2717                 {
2718                   /* Input section has been discarded, either because
2719                      it is a copy of a linkonce section or due to
2720                      linker script /DISCARD/, so we'll be discarding
2721                      the relocs too.  */
2722                 }
2723               else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2724                        && strcmp (p->sec->output_section->name,
2725                                   ".tls_vars") == 0)
2726                 {
2727                   /* Relocations in vxworks .tls_vars sections are
2728                      handled specially by the loader.  */
2729                 }
2730               else if (p->count != 0)
2731                 {
2732                   srel = elf_section_data (p->sec)->sreloc;
2733                   srel->size += p->count * sizeof (Elf32_External_Rel);
2734                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2735                       && (info->flags & DF_TEXTREL) == 0)
2736                     {
2737                       info->flags |= DF_TEXTREL;
2738                       if (info->warn_shared_textrel && info->shared)
2739                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2740                                                 p->sec->owner, p->sec);
2741                     }
2742                 }
2743             }
2744         }
2745
2746       local_got = elf_local_got_refcounts (ibfd);
2747       if (!local_got)
2748         continue;
2749
2750       symtab_hdr = &elf_symtab_hdr (ibfd);
2751       locsymcount = symtab_hdr->sh_info;
2752       end_local_got = local_got + locsymcount;
2753       local_tls_type = elf_i386_local_got_tls_type (ibfd);
2754       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
2755       s = htab->elf.sgot;
2756       srel = htab->elf.srelgot;
2757       for (; local_got < end_local_got;
2758            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2759         {
2760           *local_tlsdesc_gotent = (bfd_vma) -1;
2761           if (*local_got > 0)
2762             {
2763               if (GOT_TLS_GDESC_P (*local_tls_type))
2764                 {
2765                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2766                     - elf_i386_compute_jump_table_size (htab);
2767                   htab->elf.sgotplt->size += 8;
2768                   *local_got = (bfd_vma) -2;
2769                 }
2770               if (! GOT_TLS_GDESC_P (*local_tls_type)
2771                   || GOT_TLS_GD_P (*local_tls_type))
2772                 {
2773                   *local_got = s->size;
2774                   s->size += 4;
2775                   if (GOT_TLS_GD_P (*local_tls_type)
2776                       || *local_tls_type == GOT_TLS_IE_BOTH)
2777                     s->size += 4;
2778                 }
2779               if (info->shared
2780                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2781                   || (*local_tls_type & GOT_TLS_IE))
2782                 {
2783                   if (*local_tls_type == GOT_TLS_IE_BOTH)
2784                     srel->size += 2 * sizeof (Elf32_External_Rel);
2785                   else if (GOT_TLS_GD_P (*local_tls_type)
2786                            || ! GOT_TLS_GDESC_P (*local_tls_type))
2787                     srel->size += sizeof (Elf32_External_Rel);
2788                   if (GOT_TLS_GDESC_P (*local_tls_type))
2789                     htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2790                 }
2791             }
2792           else
2793             *local_got = (bfd_vma) -1;
2794         }
2795     }
2796
2797   if (htab->tls_ldm_got.refcount > 0)
2798     {
2799       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2800          relocs.  */
2801       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2802       htab->elf.sgot->size += 8;
2803       htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2804     }
2805   else
2806     htab->tls_ldm_got.offset = -1;
2807
2808   /* Allocate global sym .plt and .got entries, and space for global
2809      sym dynamic relocs.  */
2810   elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
2811
2812   /* Allocate .plt and .got entries, and space for local symbols.  */
2813   htab_traverse (htab->loc_hash_table,
2814                  elf_i386_allocate_local_dynrelocs,
2815                  info);
2816
2817   /* For every jump slot reserved in the sgotplt, reloc_count is
2818      incremented.  However, when we reserve space for TLS descriptors,
2819      it's not incremented, so in order to compute the space reserved
2820      for them, it suffices to multiply the reloc count by the jump
2821      slot size.
2822
2823      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2824      so that R_386_IRELATIVE entries come last.  */
2825   if (htab->elf.srelplt)
2826     {
2827       htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2828       htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2829       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2830     }
2831   else if (htab->elf.irelplt)
2832     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2833
2834
2835   if (htab->elf.sgotplt)
2836     {
2837       /* Don't allocate .got.plt section if there are no GOT nor PLT
2838          entries and there is no reference to _GLOBAL_OFFSET_TABLE_.  */
2839       if ((htab->elf.hgot == NULL
2840            || !htab->elf.hgot->ref_regular_nonweak)
2841           && (htab->elf.sgotplt->size
2842               == get_elf_backend_data (output_bfd)->got_header_size)
2843           && (htab->elf.splt == NULL
2844               || htab->elf.splt->size == 0)
2845           && (htab->elf.sgot == NULL
2846               || htab->elf.sgot->size == 0)
2847           && (htab->elf.iplt == NULL
2848               || htab->elf.iplt->size == 0)
2849           && (htab->elf.igotplt == NULL
2850               || htab->elf.igotplt->size == 0))
2851         htab->elf.sgotplt->size = 0;
2852     }
2853
2854
2855   if (htab->plt_eh_frame != NULL
2856       && htab->elf.splt != NULL
2857       && htab->elf.splt->size != 0
2858       && !bfd_is_abs_section (htab->elf.splt->output_section)
2859       && _bfd_elf_eh_frame_present (info))
2860     htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
2861
2862   /* We now have determined the sizes of the various dynamic sections.
2863      Allocate memory for them.  */
2864   relocs = FALSE;
2865   for (s = dynobj->sections; s != NULL; s = s->next)
2866     {
2867       bfd_boolean strip_section = TRUE;
2868
2869       if ((s->flags & SEC_LINKER_CREATED) == 0)
2870         continue;
2871
2872       if (s == htab->elf.splt
2873           || s == htab->elf.sgot)
2874         {
2875           /* Strip this section if we don't need it; see the
2876              comment below.  */
2877           /* We'd like to strip these sections if they aren't needed, but if
2878              we've exported dynamic symbols from them we must leave them.
2879              It's too late to tell BFD to get rid of the symbols.  */
2880
2881           if (htab->elf.hplt != NULL)
2882             strip_section = FALSE;
2883         }
2884       else if (s == htab->elf.sgotplt
2885                || s == htab->elf.iplt
2886                || s == htab->elf.igotplt
2887                || s == htab->plt_eh_frame
2888                || s == htab->sdynbss)
2889         {
2890           /* Strip these too.  */
2891         }
2892       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2893         {
2894           if (s->size != 0
2895               && s != htab->elf.srelplt
2896               && s != htab->srelplt2)
2897             relocs = TRUE;
2898
2899           /* We use the reloc_count field as a counter if we need
2900              to copy relocs into the output file.  */
2901           s->reloc_count = 0;
2902         }
2903       else
2904         {
2905           /* It's not one of our sections, so don't allocate space.  */
2906           continue;
2907         }
2908
2909       if (s->size == 0)
2910         {
2911           /* If we don't need this section, strip it from the
2912              output file.  This is mostly to handle .rel.bss and
2913              .rel.plt.  We must create both sections in
2914              create_dynamic_sections, because they must be created
2915              before the linker maps input sections to output
2916              sections.  The linker does that before
2917              adjust_dynamic_symbol is called, and it is that
2918              function which decides whether anything needs to go
2919              into these sections.  */
2920           if (strip_section)
2921             s->flags |= SEC_EXCLUDE;
2922           continue;
2923         }
2924
2925       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2926         continue;
2927
2928       /* Allocate memory for the section contents.  We use bfd_zalloc
2929          here in case unused entries are not reclaimed before the
2930          section's contents are written out.  This should not happen,
2931          but this way if it does, we get a R_386_NONE reloc instead
2932          of garbage.  */
2933       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2934       if (s->contents == NULL)
2935         return FALSE;
2936     }
2937
2938   if (htab->plt_eh_frame != NULL
2939       && htab->plt_eh_frame->contents != NULL)
2940     {
2941       memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
2942               sizeof (elf_i386_eh_frame_plt));
2943       bfd_put_32 (dynobj, htab->elf.splt->size,
2944                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2945     }
2946
2947   if (htab->elf.dynamic_sections_created)
2948     {
2949       /* Add some entries to the .dynamic section.  We fill in the
2950          values later, in elf_i386_finish_dynamic_sections, but we
2951          must add the entries now so that we get the correct size for
2952          the .dynamic section.  The DT_DEBUG entry is filled in by the
2953          dynamic linker and used by the debugger.  */
2954 #define add_dynamic_entry(TAG, VAL) \
2955   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2956
2957       if (info->executable)
2958         {
2959           if (!add_dynamic_entry (DT_DEBUG, 0))
2960             return FALSE;
2961         }
2962
2963       if (htab->elf.splt->size != 0)
2964         {
2965           if (!add_dynamic_entry (DT_PLTGOT, 0)
2966               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2967               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2968               || !add_dynamic_entry (DT_JMPREL, 0))
2969             return FALSE;
2970         }
2971
2972       if (relocs)
2973         {
2974           if (!add_dynamic_entry (DT_REL, 0)
2975               || !add_dynamic_entry (DT_RELSZ, 0)
2976               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2977             return FALSE;
2978
2979           /* If any dynamic relocs apply to a read-only section,
2980              then we need a DT_TEXTREL entry.  */
2981           if ((info->flags & DF_TEXTREL) == 0)
2982             elf_link_hash_traverse (&htab->elf,
2983                                     elf_i386_readonly_dynrelocs, info);
2984
2985           if ((info->flags & DF_TEXTREL) != 0)
2986             {
2987               if (!add_dynamic_entry (DT_TEXTREL, 0))
2988                 return FALSE;
2989             }
2990         }
2991       if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2992           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2993         return FALSE;
2994     }
2995 #undef add_dynamic_entry
2996
2997   return TRUE;
2998 }
2999
3000 static bfd_boolean
3001 elf_i386_always_size_sections (bfd *output_bfd,
3002                                struct bfd_link_info *info)
3003 {
3004   asection *tls_sec = elf_hash_table (info)->tls_sec;
3005
3006   if (tls_sec)
3007     {
3008       struct elf_link_hash_entry *tlsbase;
3009
3010       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3011                                       "_TLS_MODULE_BASE_",
3012                                       FALSE, FALSE, FALSE);
3013
3014       if (tlsbase && tlsbase->type == STT_TLS)
3015         {
3016           struct elf_i386_link_hash_table *htab;
3017           struct bfd_link_hash_entry *bh = NULL;
3018           const struct elf_backend_data *bed
3019             = get_elf_backend_data (output_bfd);
3020
3021           htab = elf_i386_hash_table (info);
3022           if (htab == NULL)
3023             return FALSE;
3024
3025           if (!(_bfd_generic_link_add_one_symbol
3026                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3027                  tls_sec, 0, NULL, FALSE,
3028                  bed->collect, &bh)))
3029             return FALSE;
3030
3031           htab->tls_module_base = bh;
3032
3033           tlsbase = (struct elf_link_hash_entry *)bh;
3034           tlsbase->def_regular = 1;
3035           tlsbase->other = STV_HIDDEN;
3036           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3037         }
3038     }
3039
3040   return TRUE;
3041 }
3042
3043 /* Set the correct type for an x86 ELF section.  We do this by the
3044    section name, which is a hack, but ought to work.  */
3045
3046 static bfd_boolean
3047 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3048                         Elf_Internal_Shdr *hdr,
3049                         asection *sec)
3050 {
3051   const char *name;
3052
3053   name = bfd_get_section_name (abfd, sec);
3054
3055   /* This is an ugly, but unfortunately necessary hack that is
3056      needed when producing EFI binaries on x86. It tells
3057      elf.c:elf_fake_sections() not to consider ".reloc" as a section
3058      containing ELF relocation info.  We need this hack in order to
3059      be able to generate ELF binaries that can be translated into
3060      EFI applications (which are essentially COFF objects).  Those
3061      files contain a COFF ".reloc" section inside an ELFNN object,
3062      which would normally cause BFD to segfault because it would
3063      attempt to interpret this section as containing relocation
3064      entries for section "oc".  With this hack enabled, ".reloc"
3065      will be treated as a normal data section, which will avoid the
3066      segfault.  However, you won't be able to create an ELFNN binary
3067      with a section named "oc" that needs relocations, but that's
3068      the kind of ugly side-effects you get when detecting section
3069      types based on their names...  In practice, this limitation is
3070      unlikely to bite.  */
3071   if (strcmp (name, ".reloc") == 0)
3072     hdr->sh_type = SHT_PROGBITS;
3073
3074   return TRUE;
3075 }
3076
3077 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3078    executables.  Rather than setting it to the beginning of the TLS
3079    section, we have to set it to the end.    This function may be called
3080    multiple times, it is idempotent.  */
3081
3082 static void
3083 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3084 {
3085   struct elf_i386_link_hash_table *htab;
3086   struct bfd_link_hash_entry *base;
3087
3088   if (!info->executable)
3089     return;
3090
3091   htab = elf_i386_hash_table (info);
3092   if (htab == NULL)
3093     return;
3094
3095   base = htab->tls_module_base;
3096   if (base == NULL)
3097     return;
3098
3099   base->u.def.value = htab->elf.tls_size;
3100 }
3101
3102 /* Return the base VMA address which should be subtracted from real addresses
3103    when resolving @dtpoff relocation.
3104    This is PT_TLS segment p_vaddr.  */
3105
3106 static bfd_vma
3107 elf_i386_dtpoff_base (struct bfd_link_info *info)
3108 {
3109   /* If tls_sec is NULL, we should have signalled an error already.  */
3110   if (elf_hash_table (info)->tls_sec == NULL)
3111     return 0;
3112   return elf_hash_table (info)->tls_sec->vma;
3113 }
3114
3115 /* Return the relocation value for @tpoff relocation
3116    if STT_TLS virtual address is ADDRESS.  */
3117
3118 static bfd_vma
3119 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3120 {
3121   struct elf_link_hash_table *htab = elf_hash_table (info);
3122   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3123   bfd_vma static_tls_size;
3124
3125   /* If tls_sec is NULL, we should have signalled an error already.  */
3126   if (htab->tls_sec == NULL)
3127     return 0;
3128
3129   /* Consider special static TLS alignment requirements.  */
3130   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3131   return static_tls_size + htab->tls_sec->vma - address;
3132 }
3133
3134 /* Relocate an i386 ELF section.  */
3135
3136 static bfd_boolean
3137 elf_i386_relocate_section (bfd *output_bfd,
3138                            struct bfd_link_info *info,
3139                            bfd *input_bfd,
3140                            asection *input_section,
3141                            bfd_byte *contents,
3142                            Elf_Internal_Rela *relocs,
3143                            Elf_Internal_Sym *local_syms,
3144                            asection **local_sections)
3145 {
3146   struct elf_i386_link_hash_table *htab;
3147   Elf_Internal_Shdr *symtab_hdr;
3148   struct elf_link_hash_entry **sym_hashes;
3149   bfd_vma *local_got_offsets;
3150   bfd_vma *local_tlsdesc_gotents;
3151   Elf_Internal_Rela *rel;
3152   Elf_Internal_Rela *relend;
3153   bfd_boolean is_vxworks_tls;
3154   unsigned plt_entry_size;
3155
3156   BFD_ASSERT (is_i386_elf (input_bfd));
3157
3158   htab = elf_i386_hash_table (info);
3159   if (htab == NULL)
3160     return FALSE;
3161   symtab_hdr = &elf_symtab_hdr (input_bfd);
3162   sym_hashes = elf_sym_hashes (input_bfd);
3163   local_got_offsets = elf_local_got_offsets (input_bfd);
3164   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3165   /* We have to handle relocations in vxworks .tls_vars sections
3166      specially, because the dynamic loader is 'weird'.  */
3167   is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3168                     && info->shared
3169                     && !strcmp (input_section->output_section->name,
3170                                 ".tls_vars"));
3171
3172   elf_i386_set_tls_module_base (info);
3173
3174   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3175
3176   rel = relocs;
3177   relend = relocs + input_section->reloc_count;
3178   for (; rel < relend; rel++)
3179     {
3180       unsigned int r_type;
3181       reloc_howto_type *howto;
3182       unsigned long r_symndx;
3183       struct elf_link_hash_entry *h;
3184       Elf_Internal_Sym *sym;
3185       asection *sec;
3186       bfd_vma off, offplt;
3187       bfd_vma relocation;
3188       bfd_boolean unresolved_reloc;
3189       bfd_reloc_status_type r;
3190       unsigned int indx;
3191       int tls_type;
3192       bfd_vma st_size;
3193
3194       r_type = ELF32_R_TYPE (rel->r_info);
3195       if (r_type == R_386_GNU_VTINHERIT
3196           || r_type == R_386_GNU_VTENTRY)
3197         continue;
3198
3199       if ((indx = r_type) >= R_386_standard
3200           && ((indx = r_type - R_386_ext_offset) - R_386_standard
3201               >= R_386_ext - R_386_standard)
3202           && ((indx = r_type - R_386_tls_offset) - R_386_ext
3203               >= R_386_irelative - R_386_ext))
3204         {
3205           (*_bfd_error_handler)
3206             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3207              input_bfd, input_section, r_type);
3208           bfd_set_error (bfd_error_bad_value);
3209           return FALSE;
3210         }
3211       howto = elf_howto_table + indx;
3212
3213       r_symndx = ELF32_R_SYM (rel->r_info);
3214       h = NULL;
3215       sym = NULL;
3216       sec = NULL;
3217       unresolved_reloc = FALSE;
3218       if (r_symndx < symtab_hdr->sh_info)
3219         {
3220           sym = local_syms + r_symndx;
3221           sec = local_sections[r_symndx];
3222           relocation = (sec->output_section->vma
3223                         + sec->output_offset
3224                         + sym->st_value);
3225           st_size = sym->st_size;
3226
3227           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3228               && ((sec->flags & SEC_MERGE) != 0
3229                   || (info->relocatable
3230                       && sec->output_offset != 0)))
3231             {
3232               bfd_vma addend;
3233               bfd_byte *where = contents + rel->r_offset;
3234
3235               switch (howto->size)
3236                 {
3237                 case 0:
3238                   addend = bfd_get_8 (input_bfd, where);
3239                   if (howto->pc_relative)
3240                     {
3241                       addend = (addend ^ 0x80) - 0x80;
3242                       addend += 1;
3243                     }
3244                   break;
3245                 case 1:
3246                   addend = bfd_get_16 (input_bfd, where);
3247                   if (howto->pc_relative)
3248                     {
3249                       addend = (addend ^ 0x8000) - 0x8000;
3250                       addend += 2;
3251                     }
3252                   break;
3253                 case 2:
3254                   addend = bfd_get_32 (input_bfd, where);
3255                   if (howto->pc_relative)
3256                     {
3257                       addend = (addend ^ 0x80000000) - 0x80000000;
3258                       addend += 4;
3259                     }
3260                   break;
3261                 default:
3262                   abort ();
3263                 }
3264
3265               if (info->relocatable)
3266                 addend += sec->output_offset;
3267               else
3268                 {
3269                   asection *msec = sec;
3270                   addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3271                                                    addend);
3272                   addend -= relocation;
3273                   addend += msec->output_section->vma + msec->output_offset;
3274                 }
3275
3276               switch (howto->size)
3277                 {
3278                 case 0:
3279                   /* FIXME: overflow checks.  */
3280                   if (howto->pc_relative)
3281                     addend -= 1;
3282                   bfd_put_8 (input_bfd, addend, where);
3283                   break;
3284                 case 1:
3285                   if (howto->pc_relative)
3286                     addend -= 2;
3287                   bfd_put_16 (input_bfd, addend, where);
3288                   break;
3289                 case 2:
3290                   if (howto->pc_relative)
3291                     addend -= 4;
3292                   bfd_put_32 (input_bfd, addend, where);
3293                   break;
3294                 }
3295             }
3296           else if (!info->relocatable
3297                    && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3298             {
3299               /* Relocate against local STT_GNU_IFUNC symbol.  */
3300               h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3301                                                FALSE);
3302               if (h == NULL)
3303                 abort ();
3304
3305               /* Set STT_GNU_IFUNC symbol value.  */
3306               h->root.u.def.value = sym->st_value;
3307               h->root.u.def.section = sec;
3308             }
3309         }
3310       else
3311         {
3312           bfd_boolean warned ATTRIBUTE_UNUSED;
3313           bfd_boolean ignored ATTRIBUTE_UNUSED;
3314
3315           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3316                                    r_symndx, symtab_hdr, sym_hashes,
3317                                    h, sec, relocation,
3318                                    unresolved_reloc, warned, ignored);
3319           st_size = h->size;
3320         }
3321
3322       if (sec != NULL && discarded_section (sec))
3323         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3324                                          rel, 1, relend, howto, 0, contents);
3325
3326       if (info->relocatable)
3327         continue;
3328
3329       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3330          it here if it is defined in a non-shared object.  */
3331       if (h != NULL
3332           && h->type == STT_GNU_IFUNC
3333           && h->def_regular)
3334         {
3335           asection *plt, *gotplt, *base_got;
3336           bfd_vma plt_index;
3337           const char *name;
3338
3339           if ((input_section->flags & SEC_ALLOC) == 0
3340               || h->plt.offset == (bfd_vma) -1)
3341             abort ();
3342
3343           /* STT_GNU_IFUNC symbol must go through PLT.  */
3344           if (htab->elf.splt != NULL)
3345             {
3346               plt = htab->elf.splt;
3347               gotplt = htab->elf.sgotplt;
3348             }
3349           else
3350             {
3351               plt = htab->elf.iplt;
3352               gotplt = htab->elf.igotplt;
3353             }
3354
3355           relocation = (plt->output_section->vma
3356                         + plt->output_offset + h->plt.offset);
3357
3358           switch (r_type)
3359             {
3360             default:
3361               if (h->root.root.string)
3362                 name = h->root.root.string;
3363               else
3364                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3365                                          NULL);
3366               (*_bfd_error_handler)
3367                 (_("%B: relocation %s against STT_GNU_IFUNC "
3368                    "symbol `%s' isn't handled by %s"), input_bfd,
3369                  elf_howto_table[r_type].name,
3370                  name, __FUNCTION__);
3371               bfd_set_error (bfd_error_bad_value);
3372               return FALSE;
3373
3374             case R_386_32:
3375               /* Generate dynamic relcoation only when there is a
3376                  non-GOT reference in a shared object.  */
3377               if (info->shared && h->non_got_ref)
3378                 {
3379                   Elf_Internal_Rela outrel;
3380                   asection *sreloc;
3381                   bfd_vma offset;
3382
3383                   /* Need a dynamic relocation to get the real function
3384                      adddress.  */
3385                   offset = _bfd_elf_section_offset (output_bfd,
3386                                                     info,
3387                                                     input_section,
3388                                                     rel->r_offset);
3389                   if (offset == (bfd_vma) -1
3390                       || offset == (bfd_vma) -2)
3391                     abort ();
3392
3393                   outrel.r_offset = (input_section->output_section->vma
3394                                      + input_section->output_offset
3395                                      + offset);
3396
3397                   if (h->dynindx == -1
3398                       || h->forced_local
3399                       || info->executable)
3400                     {
3401                       /* This symbol is resolved locally.  */
3402                       outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3403                       bfd_put_32 (output_bfd,
3404                                   (h->root.u.def.value
3405                                    + h->root.u.def.section->output_section->vma
3406                                    + h->root.u.def.section->output_offset),
3407                                   contents + offset);
3408                     }
3409                   else
3410                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3411
3412                   sreloc = htab->elf.irelifunc;
3413                   elf_append_rel (output_bfd, sreloc, &outrel);
3414
3415                   /* If this reloc is against an external symbol, we
3416                      do not want to fiddle with the addend.  Otherwise,
3417                      we need to include the symbol value so that it
3418                      becomes an addend for the dynamic reloc.  For an
3419                      internal symbol, we have updated addend.  */
3420                   continue;
3421                 }
3422               /* FALLTHROUGH */
3423             case R_386_PC32:
3424             case R_386_PLT32:
3425               goto do_relocation;
3426
3427             case R_386_GOT32:
3428               base_got = htab->elf.sgot;
3429               off = h->got.offset;
3430
3431               if (base_got == NULL)
3432                 abort ();
3433
3434               if (off == (bfd_vma) -1)
3435                 {
3436                   /* We can't use h->got.offset here to save state, or
3437                      even just remember the offset, as finish_dynamic_symbol
3438                      would use that as offset into .got.  */
3439
3440                   if (htab->elf.splt != NULL)
3441                     {
3442                       plt_index = h->plt.offset / plt_entry_size - 1;
3443                       off = (plt_index + 3) * 4;
3444                       base_got = htab->elf.sgotplt;
3445                     }
3446                   else
3447                     {
3448                       plt_index = h->plt.offset / plt_entry_size;
3449                       off = plt_index * 4;
3450                       base_got = htab->elf.igotplt;
3451                     }
3452
3453                   if (h->dynindx == -1
3454                       || h->forced_local
3455                       || info->symbolic)
3456                     {
3457                       /* This references the local defitionion.  We must
3458                          initialize this entry in the global offset table.
3459                          Since the offset must always be a multiple of 8,
3460                          we use the least significant bit to record
3461                          whether we have initialized it already.
3462
3463                          When doing a dynamic link, we create a .rela.got
3464                          relocation entry to initialize the value.  This
3465                          is done in the finish_dynamic_symbol routine.   */
3466                       if ((off & 1) != 0)
3467                         off &= ~1;
3468                       else
3469                         {
3470                           bfd_put_32 (output_bfd, relocation,
3471                                       base_got->contents + off);
3472                           h->got.offset |= 1;
3473                         }
3474                     }
3475
3476                   relocation = off;
3477
3478                   /* Adjust for static executables.  */
3479                   if (htab->elf.splt == NULL)
3480                     relocation += gotplt->output_offset;
3481                 }
3482               else
3483                 {
3484                   relocation = (base_got->output_section->vma
3485                                 + base_got->output_offset + off
3486                                 - gotplt->output_section->vma
3487                                 - gotplt->output_offset);
3488                   /* Adjust for static executables.  */
3489                   if (htab->elf.splt == NULL)
3490                     relocation += gotplt->output_offset;
3491                 }
3492
3493               goto do_relocation;
3494
3495             case R_386_GOTOFF:
3496               relocation -= (gotplt->output_section->vma
3497                              + gotplt->output_offset);
3498               goto do_relocation;
3499             }
3500         }
3501
3502       switch (r_type)
3503         {
3504         case R_386_GOT32:
3505           /* Relocation is to the entry for this symbol in the global
3506              offset table.  */
3507           if (htab->elf.sgot == NULL)
3508             abort ();
3509
3510           if (h != NULL)
3511             {
3512               bfd_boolean dyn;
3513
3514               off = h->got.offset;
3515               dyn = htab->elf.dynamic_sections_created;
3516               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3517                   || (info->shared
3518                       && SYMBOL_REFERENCES_LOCAL (info, h))
3519                   || (ELF_ST_VISIBILITY (h->other)
3520                       && h->root.type == bfd_link_hash_undefweak))
3521                 {
3522                   /* This is actually a static link, or it is a
3523                      -Bsymbolic link and the symbol is defined
3524                      locally, or the symbol was forced to be local
3525                      because of a version file.  We must initialize
3526                      this entry in the global offset table.  Since the
3527                      offset must always be a multiple of 4, we use the
3528                      least significant bit to record whether we have
3529                      initialized it already.
3530
3531                      When doing a dynamic link, we create a .rel.got
3532                      relocation entry to initialize the value.  This
3533                      is done in the finish_dynamic_symbol routine.  */
3534                   if ((off & 1) != 0)
3535                     off &= ~1;
3536                   else
3537                     {
3538                       bfd_put_32 (output_bfd, relocation,
3539                                   htab->elf.sgot->contents + off);
3540                       h->got.offset |= 1;
3541                     }
3542                 }
3543               else
3544                 unresolved_reloc = FALSE;
3545             }
3546           else
3547             {
3548               if (local_got_offsets == NULL)
3549                 abort ();
3550
3551               off = local_got_offsets[r_symndx];
3552
3553               /* The offset must always be a multiple of 4.  We use
3554                  the least significant bit to record whether we have
3555                  already generated the necessary reloc.  */
3556               if ((off & 1) != 0)
3557                 off &= ~1;
3558               else
3559                 {
3560                   bfd_put_32 (output_bfd, relocation,
3561                               htab->elf.sgot->contents + off);
3562
3563                   if (info->shared)
3564                     {
3565                       asection *s;
3566                       Elf_Internal_Rela outrel;
3567
3568                       s = htab->elf.srelgot;
3569                       if (s == NULL)
3570                         abort ();
3571
3572                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3573                                          + htab->elf.sgot->output_offset
3574                                          + off);
3575                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3576                       elf_append_rel (output_bfd, s, &outrel);
3577                     }
3578
3579                   local_got_offsets[r_symndx] |= 1;
3580                 }
3581             }
3582
3583           if (off >= (bfd_vma) -2)
3584             abort ();
3585
3586           relocation = htab->elf.sgot->output_section->vma
3587                        + htab->elf.sgot->output_offset + off
3588                        - htab->elf.sgotplt->output_section->vma
3589                        - htab->elf.sgotplt->output_offset;
3590           break;
3591
3592         case R_386_GOTOFF:
3593           /* Relocation is relative to the start of the global offset
3594              table.  */
3595
3596           /* Check to make sure it isn't a protected function symbol
3597              for shared library since it may not be local when used
3598              as function address.  We also need to make sure that a
3599              symbol is defined locally.  */
3600           if (info->shared && h)
3601             {
3602               if (!h->def_regular)
3603                 {
3604                   const char *v;
3605
3606                   switch (ELF_ST_VISIBILITY (h->other))
3607                     {
3608                     case STV_HIDDEN:
3609                       v = _("hidden symbol");
3610                       break;
3611                     case STV_INTERNAL:
3612                       v = _("internal symbol");
3613                       break;
3614                     case STV_PROTECTED:
3615                       v = _("protected symbol");
3616                       break;
3617                     default:
3618                       v = _("symbol");
3619                       break;
3620                     }
3621
3622                   (*_bfd_error_handler)
3623                     (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3624                      input_bfd, v, h->root.root.string);
3625                   bfd_set_error (bfd_error_bad_value);
3626                   return FALSE;
3627                 }
3628               else if (!info->executable
3629                        && !SYMBOLIC_BIND (info, h)
3630                        && h->type == STT_FUNC
3631                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3632                 {
3633                   (*_bfd_error_handler)
3634                     (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3635                      input_bfd, h->root.root.string);
3636                   bfd_set_error (bfd_error_bad_value);
3637                   return FALSE;
3638                 }
3639             }
3640
3641           /* Note that sgot is not involved in this
3642              calculation.  We always want the start of .got.plt.  If we
3643              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3644              permitted by the ABI, we might have to change this
3645              calculation.  */
3646           relocation -= htab->elf.sgotplt->output_section->vma
3647                         + htab->elf.sgotplt->output_offset;
3648           break;
3649
3650         case R_386_GOTPC:
3651           /* Use global offset table as symbol value.  */
3652           relocation = htab->elf.sgotplt->output_section->vma
3653                        + htab->elf.sgotplt->output_offset;
3654           unresolved_reloc = FALSE;
3655           break;
3656
3657         case R_386_PLT32:
3658           /* Relocation is to the entry for this symbol in the
3659              procedure linkage table.  */
3660
3661           /* Resolve a PLT32 reloc against a local symbol directly,
3662              without using the procedure linkage table.  */
3663           if (h == NULL)
3664             break;
3665
3666           if (h->plt.offset == (bfd_vma) -1
3667               || htab->elf.splt == NULL)
3668             {
3669               /* We didn't make a PLT entry for this symbol.  This
3670                  happens when statically linking PIC code, or when
3671                  using -Bsymbolic.  */
3672               break;
3673             }
3674
3675           relocation = (htab->elf.splt->output_section->vma
3676                         + htab->elf.splt->output_offset
3677                         + h->plt.offset);
3678           unresolved_reloc = FALSE;
3679           break;
3680
3681         case R_386_SIZE32:
3682           /* Set to symbol size.  */
3683           relocation = st_size;
3684           /* Fall through.  */
3685
3686         case R_386_32:
3687         case R_386_PC32:
3688           if ((input_section->flags & SEC_ALLOC) == 0
3689               || is_vxworks_tls)
3690             break;
3691
3692           if ((info->shared
3693                && (h == NULL
3694                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3695                    || h->root.type != bfd_link_hash_undefweak)
3696                && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
3697                    || !SYMBOL_CALLS_LOCAL (info, h)))
3698               || (ELIMINATE_COPY_RELOCS
3699                   && !info->shared
3700                   && h != NULL
3701                   && h->dynindx != -1
3702                   && !h->non_got_ref
3703                   && ((h->def_dynamic
3704                        && !h->def_regular)
3705                       || h->root.type == bfd_link_hash_undefweak
3706                       || h->root.type == bfd_link_hash_undefined)))
3707             {
3708               Elf_Internal_Rela outrel;
3709               bfd_boolean skip, relocate;
3710               asection *sreloc;
3711
3712               /* When generating a shared object, these relocations
3713                  are copied into the output file to be resolved at run
3714                  time.  */
3715
3716               skip = FALSE;
3717               relocate = FALSE;
3718
3719               outrel.r_offset =
3720                 _bfd_elf_section_offset (output_bfd, info, input_section,
3721                                          rel->r_offset);
3722               if (outrel.r_offset == (bfd_vma) -1)
3723                 skip = TRUE;
3724               else if (outrel.r_offset == (bfd_vma) -2)
3725                 skip = TRUE, relocate = TRUE;
3726               outrel.r_offset += (input_section->output_section->vma
3727                                   + input_section->output_offset);
3728
3729               if (skip)
3730                 memset (&outrel, 0, sizeof outrel);
3731               else if (h != NULL
3732                        && h->dynindx != -1
3733                        && (r_type == R_386_PC32
3734                            || !info->shared
3735                            || !SYMBOLIC_BIND (info, h)
3736                            || !h->def_regular))
3737                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3738               else
3739                 {
3740                   /* This symbol is local, or marked to become local.  */
3741                   relocate = TRUE;
3742                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3743                 }
3744
3745               sreloc = elf_section_data (input_section)->sreloc;
3746
3747               if (sreloc == NULL || sreloc->contents == NULL)
3748                 {
3749                   r = bfd_reloc_notsupported;
3750                   goto check_relocation_error;
3751                 }
3752
3753               elf_append_rel (output_bfd, sreloc, &outrel);
3754
3755               /* If this reloc is against an external symbol, we do
3756                  not want to fiddle with the addend.  Otherwise, we
3757                  need to include the symbol value so that it becomes
3758                  an addend for the dynamic reloc.  */
3759               if (! relocate)
3760                 continue;
3761             }
3762           break;
3763
3764         case R_386_TLS_IE:
3765           if (!info->executable)
3766             {
3767               Elf_Internal_Rela outrel;
3768               asection *sreloc;
3769
3770               outrel.r_offset = rel->r_offset
3771                                 + input_section->output_section->vma
3772                                 + input_section->output_offset;
3773               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3774               sreloc = elf_section_data (input_section)->sreloc;
3775               if (sreloc == NULL)
3776                 abort ();
3777               elf_append_rel (output_bfd, sreloc, &outrel);
3778             }
3779           /* Fall through */
3780
3781         case R_386_TLS_GD:
3782         case R_386_TLS_GOTDESC:
3783         case R_386_TLS_DESC_CALL:
3784         case R_386_TLS_IE_32:
3785         case R_386_TLS_GOTIE:
3786           tls_type = GOT_UNKNOWN;
3787           if (h == NULL && local_got_offsets)
3788             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3789           else if (h != NULL)
3790             tls_type = elf_i386_hash_entry(h)->tls_type;
3791           if (tls_type == GOT_TLS_IE)
3792             tls_type = GOT_TLS_IE_NEG;
3793
3794           if (! elf_i386_tls_transition (info, input_bfd,
3795                                          input_section, contents,
3796                                          symtab_hdr, sym_hashes,
3797                                          &r_type, tls_type, rel,
3798                                          relend, h, r_symndx))
3799             return FALSE;
3800
3801           if (r_type == R_386_TLS_LE_32)
3802             {
3803               BFD_ASSERT (! unresolved_reloc);
3804               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3805                 {
3806                   unsigned int type;
3807                   bfd_vma roff;
3808
3809                   /* GD->LE transition.  */
3810                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3811                   if (type == 0x04)
3812                     {
3813                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3814                          Change it into:
3815                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3816                          (6 byte form of subl).  */
3817                       memcpy (contents + rel->r_offset - 3,
3818                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3819                       roff = rel->r_offset + 5;
3820                     }
3821                   else
3822                     {
3823                       /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3824                          Change it into:
3825                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3826                          (6 byte form of subl).  */
3827                       memcpy (contents + rel->r_offset - 2,
3828                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3829                       roff = rel->r_offset + 6;
3830                     }
3831                   bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3832                               contents + roff);
3833                   /* Skip R_386_PC32/R_386_PLT32.  */
3834                   rel++;
3835                   continue;
3836                 }
3837               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3838                 {
3839                   /* GDesc -> LE transition.
3840                      It's originally something like:
3841                      leal x@tlsdesc(%ebx), %eax
3842
3843                      leal x@ntpoff, %eax
3844
3845                      Registers other than %eax may be set up here.  */
3846
3847                   unsigned int val;
3848                   bfd_vma roff;
3849
3850                   roff = rel->r_offset;
3851                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3852
3853                   /* Now modify the instruction as appropriate.  */
3854                   /* aoliva FIXME: remove the above and xor the byte
3855                      below with 0x86.  */
3856                   bfd_put_8 (output_bfd, val ^ 0x86,
3857                              contents + roff - 1);
3858                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3859                               contents + roff);
3860                   continue;
3861                 }
3862               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3863                 {
3864                   /* GDesc -> LE transition.
3865                      It's originally:
3866                      call *(%eax)
3867                      Turn it into:
3868                      xchg %ax,%ax  */
3869
3870                   bfd_vma roff;
3871
3872                   roff = rel->r_offset;
3873                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3874                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3875                   continue;
3876                 }
3877               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
3878                 {
3879                   unsigned int val;
3880
3881                   /* IE->LE transition:
3882                      Originally it can be one of:
3883                      movl foo, %eax
3884                      movl foo, %reg
3885                      addl foo, %reg
3886                      We change it into:
3887                      movl $foo, %eax
3888                      movl $foo, %reg
3889                      addl $foo, %reg.  */
3890                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3891                   if (val == 0xa1)
3892                     {
3893                       /* movl foo, %eax.  */
3894                       bfd_put_8 (output_bfd, 0xb8,
3895                                  contents + rel->r_offset - 1);
3896                     }
3897                   else
3898                     {
3899                       unsigned int type;
3900
3901                       type = bfd_get_8 (input_bfd,
3902                                         contents + rel->r_offset - 2);
3903                       switch (type)
3904                         {
3905                         case 0x8b:
3906                           /* movl */
3907                           bfd_put_8 (output_bfd, 0xc7,
3908                                      contents + rel->r_offset - 2);
3909                           bfd_put_8 (output_bfd,
3910                                      0xc0 | ((val >> 3) & 7),
3911                                      contents + rel->r_offset - 1);
3912                           break;
3913                         case 0x03:
3914                           /* addl */
3915                           bfd_put_8 (output_bfd, 0x81,
3916                                      contents + rel->r_offset - 2);
3917                           bfd_put_8 (output_bfd,
3918                                      0xc0 | ((val >> 3) & 7),
3919                                      contents + rel->r_offset - 1);
3920                           break;
3921                         default:
3922                           BFD_FAIL ();
3923                           break;
3924                         }
3925                     }
3926                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3927                               contents + rel->r_offset);
3928                   continue;
3929                 }
3930               else
3931                 {
3932                   unsigned int val, type;
3933
3934                   /* {IE_32,GOTIE}->LE transition:
3935                      Originally it can be one of:
3936                      subl foo(%reg1), %reg2
3937                      movl foo(%reg1), %reg2
3938                      addl foo(%reg1), %reg2
3939                      We change it into:
3940                      subl $foo, %reg2
3941                      movl $foo, %reg2 (6 byte form)
3942                      addl $foo, %reg2.  */
3943                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3944                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3945                   if (type == 0x8b)
3946                     {
3947                       /* movl */
3948                       bfd_put_8 (output_bfd, 0xc7,
3949                                  contents + rel->r_offset - 2);
3950                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3951                                  contents + rel->r_offset - 1);
3952                     }
3953                   else if (type == 0x2b)
3954                     {
3955                       /* subl */
3956                       bfd_put_8 (output_bfd, 0x81,
3957                                  contents + rel->r_offset - 2);
3958                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3959                                  contents + rel->r_offset - 1);
3960                     }
3961                   else if (type == 0x03)
3962                     {
3963                       /* addl */
3964                       bfd_put_8 (output_bfd, 0x81,
3965                                  contents + rel->r_offset - 2);
3966                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3967                                  contents + rel->r_offset - 1);
3968                     }
3969                   else
3970                     BFD_FAIL ();
3971                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
3972                     bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3973                                 contents + rel->r_offset);
3974                   else
3975                     bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3976                                 contents + rel->r_offset);
3977                   continue;
3978                 }
3979             }
3980
3981           if (htab->elf.sgot == NULL)
3982             abort ();
3983
3984           if (h != NULL)
3985             {
3986               off = h->got.offset;
3987               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3988             }
3989           else
3990             {
3991               if (local_got_offsets == NULL)
3992                 abort ();
3993
3994               off = local_got_offsets[r_symndx];
3995               offplt = local_tlsdesc_gotents[r_symndx];
3996             }
3997
3998           if ((off & 1) != 0)
3999             off &= ~1;
4000           else
4001             {
4002               Elf_Internal_Rela outrel;
4003               int dr_type;
4004               asection *sreloc;
4005
4006               if (htab->elf.srelgot == NULL)
4007                 abort ();
4008
4009               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4010
4011               if (GOT_TLS_GDESC_P (tls_type))
4012                 {
4013                   bfd_byte *loc;
4014                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4015                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4016                               <= htab->elf.sgotplt->size);
4017                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4018                                      + htab->elf.sgotplt->output_offset
4019                                      + offplt
4020                                      + htab->sgotplt_jump_table_size);
4021                   sreloc = htab->elf.srelplt;
4022                   loc = sreloc->contents;
4023                   loc += (htab->next_tls_desc_index++
4024                           * sizeof (Elf32_External_Rel));
4025                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4026                               <= sreloc->contents + sreloc->size);
4027                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4028                   if (indx == 0)
4029                     {
4030                       BFD_ASSERT (! unresolved_reloc);
4031                       bfd_put_32 (output_bfd,
4032                                   relocation - elf_i386_dtpoff_base (info),
4033                                   htab->elf.sgotplt->contents + offplt
4034                                   + htab->sgotplt_jump_table_size + 4);
4035                     }
4036                   else
4037                     {
4038                       bfd_put_32 (output_bfd, 0,
4039                                   htab->elf.sgotplt->contents + offplt
4040                                   + htab->sgotplt_jump_table_size + 4);
4041                     }
4042                 }
4043
4044               sreloc = htab->elf.srelgot;
4045
4046               outrel.r_offset = (htab->elf.sgot->output_section->vma
4047                                  + htab->elf.sgot->output_offset + off);
4048
4049               if (GOT_TLS_GD_P (tls_type))
4050                 dr_type = R_386_TLS_DTPMOD32;
4051               else if (GOT_TLS_GDESC_P (tls_type))
4052                 goto dr_done;
4053               else if (tls_type == GOT_TLS_IE_POS)
4054                 dr_type = R_386_TLS_TPOFF;
4055               else
4056                 dr_type = R_386_TLS_TPOFF32;
4057
4058               if (dr_type == R_386_TLS_TPOFF && indx == 0)
4059                 bfd_put_32 (output_bfd,
4060                             relocation - elf_i386_dtpoff_base (info),
4061                             htab->elf.sgot->contents + off);
4062               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4063                 bfd_put_32 (output_bfd,
4064                             elf_i386_dtpoff_base (info) - relocation,
4065                             htab->elf.sgot->contents + off);
4066               else if (dr_type != R_386_TLS_DESC)
4067                 bfd_put_32 (output_bfd, 0,
4068                             htab->elf.sgot->contents + off);
4069               outrel.r_info = ELF32_R_INFO (indx, dr_type);
4070
4071               elf_append_rel (output_bfd, sreloc, &outrel);
4072
4073               if (GOT_TLS_GD_P (tls_type))
4074                 {
4075                   if (indx == 0)
4076                     {
4077                       BFD_ASSERT (! unresolved_reloc);
4078                       bfd_put_32 (output_bfd,
4079                                   relocation - elf_i386_dtpoff_base (info),
4080                                   htab->elf.sgot->contents + off + 4);
4081                     }
4082                   else
4083                     {
4084                       bfd_put_32 (output_bfd, 0,
4085                                   htab->elf.sgot->contents + off + 4);
4086                       outrel.r_info = ELF32_R_INFO (indx,
4087                                                     R_386_TLS_DTPOFF32);
4088                       outrel.r_offset += 4;
4089                       elf_append_rel (output_bfd, sreloc, &outrel);
4090                     }
4091                 }
4092               else if (tls_type == GOT_TLS_IE_BOTH)
4093                 {
4094                   bfd_put_32 (output_bfd,
4095                               (indx == 0
4096                                ? relocation - elf_i386_dtpoff_base (info)
4097                                : 0),
4098                               htab->elf.sgot->contents + off + 4);
4099                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4100                   outrel.r_offset += 4;
4101                   elf_append_rel (output_bfd, sreloc, &outrel);
4102                 }
4103
4104             dr_done:
4105               if (h != NULL)
4106                 h->got.offset |= 1;
4107               else
4108                 local_got_offsets[r_symndx] |= 1;
4109             }
4110
4111           if (off >= (bfd_vma) -2
4112               && ! GOT_TLS_GDESC_P (tls_type))
4113             abort ();
4114           if (r_type == R_386_TLS_GOTDESC
4115               || r_type == R_386_TLS_DESC_CALL)
4116             {
4117               relocation = htab->sgotplt_jump_table_size + offplt;
4118               unresolved_reloc = FALSE;
4119             }
4120           else if (r_type == ELF32_R_TYPE (rel->r_info))
4121             {
4122               bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4123                               + htab->elf.sgotplt->output_offset;
4124               relocation = htab->elf.sgot->output_section->vma
4125                 + htab->elf.sgot->output_offset + off - g_o_t;
4126               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4127                   && tls_type == GOT_TLS_IE_BOTH)
4128                 relocation += 4;
4129               if (r_type == R_386_TLS_IE)
4130                 relocation += g_o_t;
4131               unresolved_reloc = FALSE;
4132             }
4133           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4134             {
4135               unsigned int val, type;
4136               bfd_vma roff;
4137
4138               /* GD->IE transition.  */
4139               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4140               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4141               if (type == 0x04)
4142                 {
4143                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4144                      Change it into:
4145                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4146                   val >>= 3;
4147                   roff = rel->r_offset - 3;
4148                 }
4149               else
4150                 {
4151                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4152                      Change it into:
4153                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4154                   roff = rel->r_offset - 2;
4155                 }
4156               memcpy (contents + roff,
4157                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4158               contents[roff + 7] = 0x80 | (val & 7);
4159               /* If foo is used only with foo@gotntpoff(%reg) and
4160                  foo@indntpoff, but not with foo@gottpoff(%reg), change
4161                  subl $foo@gottpoff(%reg), %eax
4162                  into:
4163                  addl $foo@gotntpoff(%reg), %eax.  */
4164               if (tls_type == GOT_TLS_IE_POS)
4165                 contents[roff + 6] = 0x03;
4166               bfd_put_32 (output_bfd,
4167                           htab->elf.sgot->output_section->vma
4168                           + htab->elf.sgot->output_offset + off
4169                           - htab->elf.sgotplt->output_section->vma
4170                           - htab->elf.sgotplt->output_offset,
4171                           contents + roff + 8);
4172               /* Skip R_386_PLT32.  */
4173               rel++;
4174               continue;
4175             }
4176           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4177             {
4178               /* GDesc -> IE transition.
4179                  It's originally something like:
4180                  leal x@tlsdesc(%ebx), %eax
4181
4182                  Change it to:
4183                  movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4184                  or:
4185                  movl x@gottpoff(%ebx), %eax # before negl %eax
4186
4187                  Registers other than %eax may be set up here.  */
4188
4189               bfd_vma roff;
4190
4191               /* First, make sure it's a leal adding ebx to a 32-bit
4192                  offset into any register, although it's probably
4193                  almost always going to be eax.  */
4194               roff = rel->r_offset;
4195
4196               /* Now modify the instruction as appropriate.  */
4197               /* To turn a leal into a movl in the form we use it, it
4198                  suffices to change the first byte from 0x8d to 0x8b.
4199                  aoliva FIXME: should we decide to keep the leal, all
4200                  we have to do is remove the statement below, and
4201                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
4202               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4203
4204               if (tls_type == GOT_TLS_IE_BOTH)
4205                 off += 4;
4206
4207               bfd_put_32 (output_bfd,
4208                           htab->elf.sgot->output_section->vma
4209                           + htab->elf.sgot->output_offset + off
4210                           - htab->elf.sgotplt->output_section->vma
4211                           - htab->elf.sgotplt->output_offset,
4212                           contents + roff);
4213               continue;
4214             }
4215           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4216             {
4217               /* GDesc -> IE transition.
4218                  It's originally:
4219                  call *(%eax)
4220
4221                  Change it to:
4222                  xchg %ax,%ax
4223                  or
4224                  negl %eax
4225                  depending on how we transformed the TLS_GOTDESC above.
4226               */
4227
4228               bfd_vma roff;
4229
4230               roff = rel->r_offset;
4231
4232               /* Now modify the instruction as appropriate.  */
4233               if (tls_type != GOT_TLS_IE_NEG)
4234                 {
4235                   /* xchg %ax,%ax */
4236                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4237                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4238                 }
4239               else
4240                 {
4241                   /* negl %eax */
4242                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
4243                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4244                 }
4245
4246               continue;
4247             }
4248           else
4249             BFD_ASSERT (FALSE);
4250           break;
4251
4252         case R_386_TLS_LDM:
4253           if (! elf_i386_tls_transition (info, input_bfd,
4254                                          input_section, contents,
4255                                          symtab_hdr, sym_hashes,
4256                                          &r_type, GOT_UNKNOWN, rel,
4257                                          relend, h, r_symndx))
4258             return FALSE;
4259
4260           if (r_type != R_386_TLS_LDM)
4261             {
4262               /* LD->LE transition:
4263                  leal foo(%reg), %eax; call ___tls_get_addr.
4264                  We change it into:
4265                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
4266               BFD_ASSERT (r_type == R_386_TLS_LE_32);
4267               memcpy (contents + rel->r_offset - 2,
4268                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4269               /* Skip R_386_PC32/R_386_PLT32.  */
4270               rel++;
4271               continue;
4272             }
4273
4274           if (htab->elf.sgot == NULL)
4275             abort ();
4276
4277           off = htab->tls_ldm_got.offset;
4278           if (off & 1)
4279             off &= ~1;
4280           else
4281             {
4282               Elf_Internal_Rela outrel;
4283
4284               if (htab->elf.srelgot == NULL)
4285                 abort ();
4286
4287               outrel.r_offset = (htab->elf.sgot->output_section->vma
4288                                  + htab->elf.sgot->output_offset + off);
4289
4290               bfd_put_32 (output_bfd, 0,
4291                           htab->elf.sgot->contents + off);
4292               bfd_put_32 (output_bfd, 0,
4293                           htab->elf.sgot->contents + off + 4);
4294               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4295               elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
4296               htab->tls_ldm_got.offset |= 1;
4297             }
4298           relocation = htab->elf.sgot->output_section->vma
4299                        + htab->elf.sgot->output_offset + off
4300                        - htab->elf.sgotplt->output_section->vma
4301                        - htab->elf.sgotplt->output_offset;
4302           unresolved_reloc = FALSE;
4303           break;
4304
4305         case R_386_TLS_LDO_32:
4306           if (!info->executable || (input_section->flags & SEC_CODE) == 0)
4307             relocation -= elf_i386_dtpoff_base (info);
4308           else
4309             /* When converting LDO to LE, we must negate.  */
4310             relocation = -elf_i386_tpoff (info, relocation);
4311           break;
4312
4313         case R_386_TLS_LE_32:
4314         case R_386_TLS_LE:
4315           if (!info->executable)
4316             {
4317               Elf_Internal_Rela outrel;
4318               asection *sreloc;
4319
4320               outrel.r_offset = rel->r_offset
4321                                 + input_section->output_section->vma
4322                                 + input_section->output_offset;
4323               if (h != NULL && h->dynindx != -1)
4324                 indx = h->dynindx;
4325               else
4326                 indx = 0;
4327               if (r_type == R_386_TLS_LE_32)
4328                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4329               else
4330                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4331               sreloc = elf_section_data (input_section)->sreloc;
4332               if (sreloc == NULL)
4333                 abort ();
4334               elf_append_rel (output_bfd, sreloc, &outrel);
4335               if (indx)
4336                 continue;
4337               else if (r_type == R_386_TLS_LE_32)
4338                 relocation = elf_i386_dtpoff_base (info) - relocation;
4339               else
4340                 relocation -= elf_i386_dtpoff_base (info);
4341             }
4342           else if (r_type == R_386_TLS_LE_32)
4343             relocation = elf_i386_tpoff (info, relocation);
4344           else
4345             relocation = -elf_i386_tpoff (info, relocation);
4346           break;
4347
4348         default:
4349           break;
4350         }
4351
4352       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4353          because such sections are not SEC_ALLOC and thus ld.so will
4354          not process them.  */
4355       if (unresolved_reloc
4356           && !((input_section->flags & SEC_DEBUGGING) != 0
4357                && h->def_dynamic)
4358           && _bfd_elf_section_offset (output_bfd, info, input_section,
4359                                       rel->r_offset) != (bfd_vma) -1)
4360         {
4361           (*_bfd_error_handler)
4362             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4363              input_bfd,
4364              input_section,
4365              (long) rel->r_offset,
4366              howto->name,
4367              h->root.root.string);
4368           return FALSE;
4369         }
4370
4371 do_relocation:
4372       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4373                                     contents, rel->r_offset,
4374                                     relocation, 0);
4375
4376 check_relocation_error:
4377       if (r != bfd_reloc_ok)
4378         {
4379           const char *name;
4380
4381           if (h != NULL)
4382             name = h->root.root.string;
4383           else
4384             {
4385               name = bfd_elf_string_from_elf_section (input_bfd,
4386                                                       symtab_hdr->sh_link,
4387                                                       sym->st_name);
4388               if (name == NULL)
4389                 return FALSE;
4390               if (*name == '\0')
4391                 name = bfd_section_name (input_bfd, sec);
4392             }
4393
4394           if (r == bfd_reloc_overflow)
4395             {
4396               if (! ((*info->callbacks->reloc_overflow)
4397                      (info, (h ? &h->root : NULL), name, howto->name,
4398                       (bfd_vma) 0, input_bfd, input_section,
4399                       rel->r_offset)))
4400                 return FALSE;
4401             }
4402           else
4403             {
4404               (*_bfd_error_handler)
4405                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4406                  input_bfd, input_section,
4407                  (long) rel->r_offset, name, (int) r);
4408               return FALSE;
4409             }
4410         }
4411     }
4412
4413   return TRUE;
4414 }
4415
4416 /* Finish up dynamic symbol handling.  We set the contents of various
4417    dynamic sections here.  */
4418
4419 static bfd_boolean
4420 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4421                                 struct bfd_link_info *info,
4422                                 struct elf_link_hash_entry *h,
4423                                 Elf_Internal_Sym *sym)
4424 {
4425   struct elf_i386_link_hash_table *htab;
4426   unsigned plt_entry_size;
4427   const struct elf_i386_backend_data *abed;
4428
4429   htab = elf_i386_hash_table (info);
4430   if (htab == NULL)
4431     return FALSE;
4432
4433   abed = get_elf_i386_backend_data (output_bfd);
4434   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
4435
4436   if (h->plt.offset != (bfd_vma) -1)
4437     {
4438       bfd_vma plt_index;
4439       bfd_vma got_offset;
4440       Elf_Internal_Rela rel;
4441       bfd_byte *loc;
4442       asection *plt, *gotplt, *relplt;
4443
4444       /* When building a static executable, use .iplt, .igot.plt and
4445          .rel.iplt sections for STT_GNU_IFUNC symbols.  */
4446       if (htab->elf.splt != NULL)
4447         {
4448           plt = htab->elf.splt;
4449           gotplt = htab->elf.sgotplt;
4450           relplt = htab->elf.srelplt;
4451         }
4452       else
4453         {
4454           plt = htab->elf.iplt;
4455           gotplt = htab->elf.igotplt;
4456           relplt = htab->elf.irelplt;
4457         }
4458
4459       /* This symbol has an entry in the procedure linkage table.  Set
4460          it up.  */
4461
4462       if ((h->dynindx == -1
4463            && !((h->forced_local || info->executable)
4464                 && h->def_regular
4465                 && h->type == STT_GNU_IFUNC))
4466           || plt == NULL
4467           || gotplt == NULL
4468           || relplt == NULL)
4469         abort ();
4470
4471       /* Get the index in the procedure linkage table which
4472          corresponds to this symbol.  This is the index of this symbol
4473          in all the symbols for which we are making plt entries.  The
4474          first entry in the procedure linkage table is reserved.
4475
4476          Get the offset into the .got table of the entry that
4477          corresponds to this function.  Each .got entry is 4 bytes.
4478          The first three are reserved.
4479
4480          For static executables, we don't reserve anything.  */
4481
4482       if (plt == htab->elf.splt)
4483         {
4484           got_offset = h->plt.offset / plt_entry_size - 1;
4485           got_offset = (got_offset + 3) * 4;
4486         }
4487       else
4488         {
4489           got_offset = h->plt.offset / plt_entry_size;
4490           got_offset = got_offset * 4;
4491         }
4492
4493       /* Fill in the entry in the procedure linkage table.  */
4494       if (! info->shared)
4495         {
4496           memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
4497                   abed->plt->plt_entry_size);
4498           bfd_put_32 (output_bfd,
4499                       (gotplt->output_section->vma
4500                        + gotplt->output_offset
4501                        + got_offset),
4502                       plt->contents + h->plt.offset
4503                       + abed->plt->plt_got_offset);
4504
4505           if (abed->is_vxworks)
4506             {
4507               int s, k, reloc_index;
4508
4509               /* Create the R_386_32 relocation referencing the GOT
4510                  for this PLT entry.  */
4511
4512               /* S: Current slot number (zero-based).  */
4513               s = ((h->plt.offset - abed->plt->plt_entry_size)
4514                    / abed->plt->plt_entry_size);
4515               /* K: Number of relocations for PLTResolve. */
4516               if (info->shared)
4517                 k = PLTRESOLVE_RELOCS_SHLIB;
4518               else
4519                 k = PLTRESOLVE_RELOCS;
4520               /* Skip the PLTresolve relocations, and the relocations for
4521                  the other PLT slots. */
4522               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4523               loc = (htab->srelplt2->contents + reloc_index
4524                      * sizeof (Elf32_External_Rel));
4525
4526               rel.r_offset = (htab->elf.splt->output_section->vma
4527                               + htab->elf.splt->output_offset
4528                               + h->plt.offset + 2),
4529               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4530               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4531
4532               /* Create the R_386_32 relocation referencing the beginning of
4533                  the PLT for this GOT entry.  */
4534               rel.r_offset = (htab->elf.sgotplt->output_section->vma
4535                               + htab->elf.sgotplt->output_offset
4536                               + got_offset);
4537               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4538               bfd_elf32_swap_reloc_out (output_bfd, &rel,
4539                                         loc + sizeof (Elf32_External_Rel));
4540             }
4541         }
4542       else
4543         {
4544           memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
4545                   abed->plt->plt_entry_size);
4546           bfd_put_32 (output_bfd, got_offset,
4547                       plt->contents + h->plt.offset
4548                       + abed->plt->plt_got_offset);
4549         }
4550
4551       /* Fill in the entry in the global offset table.  */
4552       bfd_put_32 (output_bfd,
4553                   (plt->output_section->vma
4554                    + plt->output_offset
4555                    + h->plt.offset
4556                    + abed->plt->plt_lazy_offset),
4557                   gotplt->contents + got_offset);
4558
4559       /* Fill in the entry in the .rel.plt section.  */
4560       rel.r_offset = (gotplt->output_section->vma
4561                       + gotplt->output_offset
4562                       + got_offset);
4563       if (h->dynindx == -1
4564           || ((info->executable
4565                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4566               && h->def_regular
4567                && h->type == STT_GNU_IFUNC))
4568         {
4569           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4570              R_386_IRELATIVE instead of R_386_JUMP_SLOT.  Store addend
4571              in the .got.plt section.  */
4572           bfd_put_32 (output_bfd,
4573                       (h->root.u.def.value
4574                        + h->root.u.def.section->output_section->vma
4575                        + h->root.u.def.section->output_offset),
4576                       gotplt->contents + got_offset);
4577           rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4578           /* R_386_IRELATIVE comes last.  */
4579           plt_index = htab->next_irelative_index--;
4580         }
4581       else
4582         {
4583           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
4584           plt_index = htab->next_jump_slot_index++;
4585         }
4586       loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
4587       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4588
4589       /* Don't fill PLT entry for static executables.  */
4590       if (plt == htab->elf.splt)
4591         {
4592           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
4593                       plt->contents + h->plt.offset
4594                       + abed->plt->plt_reloc_offset);
4595           bfd_put_32 (output_bfd, - (h->plt.offset
4596                                      + abed->plt->plt_plt_offset + 4),
4597                       plt->contents + h->plt.offset
4598                       + abed->plt->plt_plt_offset);
4599         }
4600
4601       if (!h->def_regular)
4602         {
4603           /* Mark the symbol as undefined, rather than as defined in
4604              the .plt section.  Leave the value if there were any
4605              relocations where pointer equality matters (this is a clue
4606              for the dynamic linker, to make function pointer
4607              comparisons work between an application and shared
4608              library), otherwise set it to zero.  If a function is only
4609              called from a binary, there is no need to slow down
4610              shared libraries because of that.  */
4611           sym->st_shndx = SHN_UNDEF;
4612           if (!h->pointer_equality_needed)
4613             sym->st_value = 0;
4614         }
4615     }
4616
4617   if (h->got.offset != (bfd_vma) -1
4618       && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
4619       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
4620     {
4621       Elf_Internal_Rela rel;
4622
4623       /* This symbol has an entry in the global offset table.  Set it
4624          up.  */
4625
4626       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4627         abort ();
4628
4629       rel.r_offset = (htab->elf.sgot->output_section->vma
4630                       + htab->elf.sgot->output_offset
4631                       + (h->got.offset & ~(bfd_vma) 1));
4632
4633       /* If this is a static link, or it is a -Bsymbolic link and the
4634          symbol is defined locally or was forced to be local because
4635          of a version file, we just want to emit a RELATIVE reloc.
4636          The entry in the global offset table will already have been
4637          initialized in the relocate_section function.  */
4638       if (h->def_regular
4639           && h->type == STT_GNU_IFUNC)
4640         {
4641           if (info->shared)
4642             {
4643               /* Generate R_386_GLOB_DAT.  */
4644               goto do_glob_dat;
4645             }
4646           else
4647             {
4648               asection *plt;
4649
4650               if (!h->pointer_equality_needed)
4651                 abort ();
4652
4653               /* For non-shared object, we can't use .got.plt, which
4654                  contains the real function addres if we need pointer
4655                  equality.  We load the GOT entry with the PLT entry.  */
4656               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4657               bfd_put_32 (output_bfd,
4658                           (plt->output_section->vma
4659                            + plt->output_offset + h->plt.offset),
4660                           htab->elf.sgot->contents + h->got.offset);
4661               return TRUE;
4662             }
4663         }
4664       else if (info->shared
4665                && SYMBOL_REFERENCES_LOCAL (info, h))
4666         {
4667           BFD_ASSERT((h->got.offset & 1) != 0);
4668           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4669         }
4670       else
4671         {
4672           BFD_ASSERT((h->got.offset & 1) == 0);
4673 do_glob_dat:
4674           bfd_put_32 (output_bfd, (bfd_vma) 0,
4675                       htab->elf.sgot->contents + h->got.offset);
4676           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
4677         }
4678
4679       elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
4680     }
4681
4682   if (h->needs_copy)
4683     {
4684       Elf_Internal_Rela rel;
4685
4686       /* This symbol needs a copy reloc.  Set it up.  */
4687
4688       if (h->dynindx == -1
4689           || (h->root.type != bfd_link_hash_defined
4690               && h->root.type != bfd_link_hash_defweak)
4691           || htab->srelbss == NULL)
4692         abort ();
4693
4694       rel.r_offset = (h->root.u.def.value
4695                       + h->root.u.def.section->output_section->vma
4696                       + h->root.u.def.section->output_offset);
4697       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
4698       elf_append_rel (output_bfd, htab->srelbss, &rel);
4699     }
4700
4701   return TRUE;
4702 }
4703
4704 /* Finish up local dynamic symbol handling.  We set the contents of
4705    various dynamic sections here.  */
4706
4707 static bfd_boolean
4708 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
4709 {
4710   struct elf_link_hash_entry *h
4711     = (struct elf_link_hash_entry *) *slot;
4712   struct bfd_link_info *info
4713     = (struct bfd_link_info *) inf;
4714
4715   return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
4716                                          h, NULL);
4717 }
4718
4719 /* Used to decide how to sort relocs in an optimal manner for the
4720    dynamic linker, before writing them out.  */
4721
4722 static enum elf_reloc_type_class
4723 elf_i386_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4724                            const asection *rel_sec ATTRIBUTE_UNUSED,
4725                            const Elf_Internal_Rela *rela)
4726 {
4727   switch (ELF32_R_TYPE (rela->r_info))
4728     {
4729     case R_386_RELATIVE:
4730       return reloc_class_relative;
4731     case R_386_JUMP_SLOT:
4732       return reloc_class_plt;
4733     case R_386_COPY:
4734       return reloc_class_copy;
4735     default:
4736       return reloc_class_normal;
4737     }
4738 }
4739
4740 /* Finish up the dynamic sections.  */
4741
4742 static bfd_boolean
4743 elf_i386_finish_dynamic_sections (bfd *output_bfd,
4744                                   struct bfd_link_info *info)
4745 {
4746   struct elf_i386_link_hash_table *htab;
4747   bfd *dynobj;
4748   asection *sdyn;
4749   const struct elf_i386_backend_data *abed;
4750
4751   htab = elf_i386_hash_table (info);
4752   if (htab == NULL)
4753     return FALSE;
4754
4755   dynobj = htab->elf.dynobj;
4756   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4757   abed = get_elf_i386_backend_data (output_bfd);
4758
4759   if (htab->elf.dynamic_sections_created)
4760     {
4761       Elf32_External_Dyn *dyncon, *dynconend;
4762
4763       if (sdyn == NULL || htab->elf.sgot == NULL)
4764         abort ();
4765
4766       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4767       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4768       for (; dyncon < dynconend; dyncon++)
4769         {
4770           Elf_Internal_Dyn dyn;
4771           asection *s;
4772
4773           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4774
4775           switch (dyn.d_tag)
4776             {
4777             default:
4778               if (abed->is_vxworks
4779                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4780                 break;
4781               continue;
4782
4783             case DT_PLTGOT:
4784               s = htab->elf.sgotplt;
4785               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4786               break;
4787
4788             case DT_JMPREL:
4789               s = htab->elf.srelplt;
4790               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4791               break;
4792
4793             case DT_PLTRELSZ:
4794               s = htab->elf.srelplt;
4795               dyn.d_un.d_val = s->size;
4796               break;
4797
4798             case DT_RELSZ:
4799               /* My reading of the SVR4 ABI indicates that the
4800                  procedure linkage table relocs (DT_JMPREL) should be
4801                  included in the overall relocs (DT_REL).  This is
4802                  what Solaris does.  However, UnixWare can not handle
4803                  that case.  Therefore, we override the DT_RELSZ entry
4804                  here to make it not include the JMPREL relocs.  */
4805               s = htab->elf.srelplt;
4806               if (s == NULL)
4807                 continue;
4808               dyn.d_un.d_val -= s->size;
4809               break;
4810
4811             case DT_REL:
4812               /* We may not be using the standard ELF linker script.
4813                  If .rel.plt is the first .rel section, we adjust
4814                  DT_REL to not include it.  */
4815               s = htab->elf.srelplt;
4816               if (s == NULL)
4817                 continue;
4818               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4819                 continue;
4820               dyn.d_un.d_ptr += s->size;
4821               break;
4822             }
4823
4824           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4825         }
4826
4827       /* Fill in the first entry in the procedure linkage table.  */
4828       if (htab->elf.splt && htab->elf.splt->size > 0)
4829         {
4830           if (info->shared)
4831             {
4832               memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
4833                       abed->plt->plt0_entry_size);
4834               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4835                       abed->plt0_pad_byte,
4836                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4837             }
4838           else
4839             {
4840               memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
4841                       abed->plt->plt0_entry_size);
4842               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4843                       abed->plt0_pad_byte,
4844                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4845               bfd_put_32 (output_bfd,
4846                           (htab->elf.sgotplt->output_section->vma
4847                            + htab->elf.sgotplt->output_offset
4848                            + 4),
4849                           htab->elf.splt->contents
4850                           + abed->plt->plt0_got1_offset);
4851               bfd_put_32 (output_bfd,
4852                           (htab->elf.sgotplt->output_section->vma
4853                            + htab->elf.sgotplt->output_offset
4854                            + 8),
4855                           htab->elf.splt->contents
4856                           + abed->plt->plt0_got2_offset);
4857
4858               if (abed->is_vxworks)
4859                 {
4860                   Elf_Internal_Rela rel;
4861
4862                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4863                      On IA32 we use REL relocations so the addend goes in
4864                      the PLT directly.  */
4865                   rel.r_offset = (htab->elf.splt->output_section->vma
4866                                   + htab->elf.splt->output_offset
4867                                   + abed->plt->plt0_got1_offset);
4868                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4869                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4870                                             htab->srelplt2->contents);
4871                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
4872                   rel.r_offset = (htab->elf.splt->output_section->vma
4873                                   + htab->elf.splt->output_offset
4874                                   + abed->plt->plt0_got2_offset);
4875                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4876                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4877                                             htab->srelplt2->contents +
4878                                             sizeof (Elf32_External_Rel));
4879                 }
4880             }
4881
4882           /* UnixWare sets the entsize of .plt to 4, although that doesn't
4883              really seem like the right value.  */
4884           elf_section_data (htab->elf.splt->output_section)
4885             ->this_hdr.sh_entsize = 4;
4886
4887           /* Correct the .rel.plt.unloaded relocations.  */
4888           if (abed->is_vxworks && !info->shared)
4889             {
4890               int num_plts = (htab->elf.splt->size
4891                               / abed->plt->plt_entry_size) - 1;
4892               unsigned char *p;
4893
4894               p = htab->srelplt2->contents;
4895               if (info->shared)
4896                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4897               else
4898                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4899
4900               for (; num_plts; num_plts--)
4901                 {
4902                   Elf_Internal_Rela rel;
4903                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4904                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4905                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4906                   p += sizeof (Elf32_External_Rel);
4907
4908                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4909                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4910                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4911                   p += sizeof (Elf32_External_Rel);
4912                 }
4913             }
4914         }
4915     }
4916
4917   if (htab->elf.sgotplt)
4918     {
4919       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4920         {
4921           (*_bfd_error_handler)
4922             (_("discarded output section: `%A'"), htab->elf.sgotplt);
4923           return FALSE;
4924         }
4925
4926       /* Fill in the first three entries in the global offset table.  */
4927       if (htab->elf.sgotplt->size > 0)
4928         {
4929           bfd_put_32 (output_bfd,
4930                       (sdyn == NULL ? 0
4931                        : sdyn->output_section->vma + sdyn->output_offset),
4932                       htab->elf.sgotplt->contents);
4933           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
4934           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
4935         }
4936
4937       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
4938     }
4939
4940   /* Adjust .eh_frame for .plt section.  */
4941   if (htab->plt_eh_frame != NULL
4942       && htab->plt_eh_frame->contents != NULL)
4943     {
4944       if (htab->elf.splt != NULL
4945           && htab->elf.splt->size != 0
4946           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4947           && htab->elf.splt->output_section != NULL
4948           && htab->plt_eh_frame->output_section != NULL)
4949         {
4950           bfd_vma plt_start = htab->elf.splt->output_section->vma;
4951           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4952                                    + htab->plt_eh_frame->output_offset
4953                                    + PLT_FDE_START_OFFSET;
4954           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4955                              htab->plt_eh_frame->contents
4956                              + PLT_FDE_START_OFFSET);
4957         }
4958       if (htab->plt_eh_frame->sec_info_type
4959           == SEC_INFO_TYPE_EH_FRAME)
4960         {
4961           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4962                                                  htab->plt_eh_frame,
4963                                                  htab->plt_eh_frame->contents))
4964             return FALSE;
4965         }
4966     }
4967
4968   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4969     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
4970
4971   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4972   htab_traverse (htab->loc_hash_table,
4973                  elf_i386_finish_local_dynamic_symbol,
4974                  info);
4975
4976   return TRUE;
4977 }
4978
4979 /* Return address in section PLT for the Ith GOTPLT relocation, for
4980    relocation REL or (bfd_vma) -1 if it should not be included.  */
4981
4982 static bfd_vma
4983 elf_i386_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4984 {
4985   bfd *abfd;
4986   const struct elf_i386_backend_data *bed;
4987   bfd_vma plt_offset;
4988
4989   /* Only match R_386_JUMP_SLOT and R_386_IRELATIVE.  */
4990   if (rel->howto->type != R_386_JUMP_SLOT
4991       && rel->howto->type != R_386_IRELATIVE)
4992     return (bfd_vma) -1;
4993
4994   abfd = plt->owner;
4995   bed = get_elf_i386_backend_data (abfd);
4996   plt_offset = bed->plt->plt_entry_size;
4997   while (plt_offset < plt->size)
4998     {
4999       bfd_vma reloc_offset;
5000       bfd_byte reloc_offset_raw[4];
5001
5002       if (!bfd_get_section_contents (abfd, (asection *) plt,
5003                                      reloc_offset_raw,
5004                                      plt_offset + bed->plt->plt_reloc_offset,
5005                                      sizeof (reloc_offset_raw)))
5006         return (bfd_vma) -1;
5007
5008       reloc_offset = H_GET_32 (abfd, reloc_offset_raw);
5009       if (reloc_offset == i * sizeof (Elf32_External_Rel))
5010         return plt->vma + plt_offset;
5011       plt_offset += bed->plt->plt_entry_size;
5012     }
5013
5014   abort ();
5015 }
5016
5017 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5018
5019 static bfd_boolean
5020 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5021 {
5022   if (h->plt.offset != (bfd_vma) -1
5023       && !h->def_regular
5024       && !h->pointer_equality_needed)
5025     return FALSE;
5026
5027   return _bfd_elf_hash_symbol (h);
5028 }
5029
5030 /* Hook called by the linker routine which adds symbols from an object
5031    file.  */
5032
5033 static bfd_boolean
5034 elf_i386_add_symbol_hook (bfd * abfd,
5035                           struct bfd_link_info * info ATTRIBUTE_UNUSED,
5036                           Elf_Internal_Sym * sym,
5037                           const char ** namep ATTRIBUTE_UNUSED,
5038                           flagword * flagsp ATTRIBUTE_UNUSED,
5039                           asection ** secp ATTRIBUTE_UNUSED,
5040                           bfd_vma * valp ATTRIBUTE_UNUSED)
5041 {
5042   if ((abfd->flags & DYNAMIC) == 0
5043       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5044           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
5045     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5046
5047   return TRUE;
5048 }
5049
5050 #define TARGET_LITTLE_SYM               i386_elf32_vec
5051 #define TARGET_LITTLE_NAME              "elf32-i386"
5052 #define ELF_ARCH                        bfd_arch_i386
5053 #define ELF_TARGET_ID                   I386_ELF_DATA
5054 #define ELF_MACHINE_CODE                EM_386
5055 #define ELF_MAXPAGESIZE                 0x1000
5056
5057 #define elf_backend_can_gc_sections     1
5058 #define elf_backend_can_refcount        1
5059 #define elf_backend_want_got_plt        1
5060 #define elf_backend_plt_readonly        1
5061 #define elf_backend_want_plt_sym        0
5062 #define elf_backend_got_header_size     12
5063 #define elf_backend_plt_alignment       4
5064
5065 /* Support RELA for objdump of prelink objects.  */
5066 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
5067 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
5068
5069 #define bfd_elf32_mkobject                    elf_i386_mkobject
5070
5071 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
5072 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
5073 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
5074 #define bfd_elf32_bfd_reloc_name_lookup       elf_i386_reloc_name_lookup
5075
5076 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
5077 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
5078 #define elf_backend_check_relocs              elf_i386_check_relocs
5079 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
5080 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
5081 #define elf_backend_fake_sections             elf_i386_fake_sections
5082 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
5083 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
5084 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
5085 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
5086 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
5087 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
5088 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
5089 #define elf_backend_relocate_section          elf_i386_relocate_section
5090 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
5091 #define elf_backend_always_size_sections      elf_i386_always_size_sections
5092 #define elf_backend_omit_section_dynsym \
5093   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5094 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
5095 #define elf_backend_hash_symbol               elf_i386_hash_symbol
5096 #define elf_backend_add_symbol_hook           elf_i386_add_symbol_hook
5097
5098 #include "elf32-target.h"
5099
5100 /* FreeBSD support.  */
5101
5102 #undef  TARGET_LITTLE_SYM
5103 #define TARGET_LITTLE_SYM               i386_elf32_fbsd_vec
5104 #undef  TARGET_LITTLE_NAME
5105 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
5106 #undef  ELF_OSABI
5107 #define ELF_OSABI                       ELFOSABI_FREEBSD
5108
5109 /* The kernel recognizes executables as valid only if they carry a
5110    "FreeBSD" label in the ELF header.  So we put this label on all
5111    executables and (for simplicity) also all other object files.  */
5112
5113 static void
5114 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5115 {
5116   _bfd_elf_post_process_headers (abfd, info);
5117
5118 #ifdef OLD_FREEBSD_ABI_LABEL
5119   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
5120   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5121 #endif
5122 }
5123
5124 #undef  elf_backend_post_process_headers
5125 #define elf_backend_post_process_headers        elf_i386_fbsd_post_process_headers
5126 #undef  elf32_bed
5127 #define elf32_bed                               elf32_i386_fbsd_bed
5128
5129 #undef elf_backend_add_symbol_hook
5130
5131 #include "elf32-target.h"
5132
5133 /* Solaris 2.  */
5134
5135 #undef  TARGET_LITTLE_SYM
5136 #define TARGET_LITTLE_SYM               i386_elf32_sol2_vec
5137 #undef  TARGET_LITTLE_NAME
5138 #define TARGET_LITTLE_NAME              "elf32-i386-sol2"
5139
5140 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5141    objects won't be recognized.  */
5142 #undef ELF_OSABI
5143
5144 #undef  elf32_bed
5145 #define elf32_bed                       elf32_i386_sol2_bed
5146
5147 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5148    boundary.  */
5149 #undef elf_backend_static_tls_alignment
5150 #define elf_backend_static_tls_alignment 8
5151
5152 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5153
5154    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5155    File, p.63.  */
5156 #undef elf_backend_want_plt_sym
5157 #define elf_backend_want_plt_sym        1
5158
5159 #include "elf32-target.h"
5160
5161 /* Native Client support.  */
5162
5163 #undef  TARGET_LITTLE_SYM
5164 #define TARGET_LITTLE_SYM               i386_elf32_nacl_vec
5165 #undef  TARGET_LITTLE_NAME
5166 #define TARGET_LITTLE_NAME              "elf32-i386-nacl"
5167 #undef  elf32_bed
5168 #define elf32_bed                       elf32_i386_nacl_bed
5169
5170 #undef  ELF_MAXPAGESIZE
5171 #define ELF_MAXPAGESIZE                 0x10000
5172
5173 /* Restore defaults.  */
5174 #undef  ELF_OSABI
5175 #undef  elf_backend_want_plt_sym
5176 #define elf_backend_want_plt_sym        0
5177 #undef  elf_backend_post_process_headers
5178 #undef  elf_backend_static_tls_alignment
5179
5180 /* NaCl uses substantially different PLT entries for the same effects.  */
5181
5182 #undef  elf_backend_plt_alignment
5183 #define elf_backend_plt_alignment       5
5184 #define NACL_PLT_ENTRY_SIZE             64
5185 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5186
5187 static const bfd_byte elf_i386_nacl_plt0_entry[] =
5188   {
5189     0xff, 0x35,                   /* pushl contents of address */
5190     0, 0, 0, 0,                   /* replaced with address of .got + 4.  */
5191     0x8b, 0x0d,                   /* movl contents of address, %ecx */
5192     0, 0, 0, 0,                   /* replaced with address of .got + 8.  */
5193     0x83, 0xe1, NACLMASK,         /* andl $NACLMASK, %ecx */
5194     0xff, 0xe1                    /* jmp *%ecx */
5195   };
5196
5197 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5198   {
5199     0x8b, 0x0d,                         /* movl contents of address, %ecx */
5200     0, 0, 0, 0,                         /* replaced with GOT slot address.  */
5201     0x83, 0xe1, NACLMASK,               /* andl $NACLMASK, %ecx */
5202     0xff, 0xe1,                         /* jmp *%ecx */
5203
5204     /* Pad to the next 32-byte boundary with nop instructions.  */
5205     0x90,
5206     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5207     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5208
5209     /* Lazy GOT entries point here (32-byte aligned).  */
5210     0x68,                              /* pushl immediate */
5211     0, 0, 0, 0,                        /* replaced with reloc offset.  */
5212     0xe9,                              /* jmp relative */
5213     0, 0, 0, 0,                        /* replaced with offset to .plt.  */
5214
5215     /* Pad to the next 32-byte boundary with nop instructions.  */
5216     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5217     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5218     0x90, 0x90
5219   };
5220
5221 static const bfd_byte
5222 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
5223   {
5224     0xff, 0x73, 0x04,           /* pushl 4(%ebx) */
5225     0x8b, 0x4b, 0x08,           /* mov 0x8(%ebx), %ecx */
5226     0x83, 0xe1, 0xe0,           /* and $NACLMASK, %ecx */
5227     0xff, 0xe1,                 /* jmp *%ecx */
5228
5229     /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5230        so pad to that size with nop instructions.  */
5231     0x90, 0x90, 0x90, 0x90, 0x90, 0x90
5232   };
5233
5234 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
5235   {
5236     0x8b, 0x8b,          /* movl offset(%ebx), %ecx */
5237     0, 0, 0, 0,          /* replaced with offset of this symbol in .got.  */
5238     0x83, 0xe1, 0xe0,    /* andl $NACLMASK, %ecx */
5239     0xff, 0xe1,          /* jmp *%ecx */
5240
5241     /* Pad to the next 32-byte boundary with nop instructions.  */
5242     0x90,
5243     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5244     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5245
5246     /* Lazy GOT entries point here (32-byte aligned).  */
5247     0x68,                /* pushl immediate */
5248     0, 0, 0, 0,          /* replaced with offset into relocation table.  */
5249     0xe9,                /* jmp relative */
5250     0, 0, 0, 0,          /* replaced with offset to start of .plt.  */
5251
5252     /* Pad to the next 32-byte boundary with nop instructions.  */
5253     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5254     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5255     0x90, 0x90
5256   };
5257
5258 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
5259   {
5260 #if (PLT_CIE_LENGTH != 20                               \
5261      || PLT_FDE_LENGTH != 36                            \
5262      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5263      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5264 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
5265 #endif
5266     PLT_CIE_LENGTH, 0, 0, 0,            /* CIE length */
5267     0, 0, 0, 0,                         /* CIE ID */
5268     1,                                  /* CIE version */
5269     'z', 'R', 0,                        /* Augmentation string */
5270     1,                                  /* Code alignment factor */
5271     0x7c,                               /* Data alignment factor: -4 */
5272     8,                                  /* Return address column */
5273     1,                                  /* Augmentation size */
5274     DW_EH_PE_pcrel | DW_EH_PE_sdata4,   /* FDE encoding */
5275     DW_CFA_def_cfa, 4, 4,               /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
5276     DW_CFA_offset + 8, 1,               /* DW_CFA_offset: r8 (eip) at cfa-4 */
5277     DW_CFA_nop, DW_CFA_nop,
5278
5279     PLT_FDE_LENGTH, 0, 0, 0,     /* FDE length */
5280     PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
5281     0, 0, 0, 0,                  /* R_386_PC32 .plt goes here */
5282     0, 0, 0, 0,                  /* .plt size goes here */
5283     0,                           /* Augmentation size */
5284     DW_CFA_def_cfa_offset, 8,    /* DW_CFA_def_cfa_offset: 8 */
5285     DW_CFA_advance_loc + 6,      /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5286     DW_CFA_def_cfa_offset, 12,   /* DW_CFA_def_cfa_offset: 12 */
5287     DW_CFA_advance_loc + 58,     /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5288     DW_CFA_def_cfa_expression,   /* DW_CFA_def_cfa_expression */
5289     13,                          /* Block length */
5290     DW_OP_breg4, 4,              /* DW_OP_breg4 (esp): 4 */
5291     DW_OP_breg8, 0,              /* DW_OP_breg8 (eip): 0 */
5292     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5293     DW_OP_lit2, DW_OP_shl, DW_OP_plus,
5294     DW_CFA_nop, DW_CFA_nop
5295   };
5296
5297 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
5298   {
5299     elf_i386_nacl_plt0_entry,           /* plt0_entry */
5300     sizeof (elf_i386_nacl_plt0_entry),  /* plt0_entry_size */
5301     2,                                  /* plt0_got1_offset */
5302     8,                                  /* plt0_got2_offset */
5303     elf_i386_nacl_plt_entry,            /* plt_entry */
5304     NACL_PLT_ENTRY_SIZE,                /* plt_entry_size */
5305     2,                                  /* plt_got_offset */
5306     33,                                 /* plt_reloc_offset */
5307     38,                                 /* plt_plt_offset */
5308     32,                                 /* plt_lazy_offset */
5309     elf_i386_nacl_pic_plt0_entry,       /* pic_plt0_entry */
5310     elf_i386_nacl_pic_plt_entry,        /* pic_plt_entry */
5311     elf_i386_nacl_eh_frame_plt,         /* eh_frame_plt */
5312     sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
5313   };
5314
5315 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
5316   {
5317     &elf_i386_nacl_plt,                      /* plt */
5318     0x90,                               /* plt0_pad_byte: nop insn */
5319     0,                                  /* is_vxworks */
5320   };
5321
5322 static bfd_boolean
5323 elf32_i386_nacl_elf_object_p (bfd *abfd)
5324 {
5325   /* Set the right machine number for a NaCl i386 ELF32 file.  */
5326   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
5327   return TRUE;
5328 }
5329
5330 #undef  elf_backend_arch_data
5331 #define elf_backend_arch_data   &elf_i386_nacl_arch_bed
5332
5333 #undef  elf_backend_object_p
5334 #define elf_backend_object_p                    elf32_i386_nacl_elf_object_p
5335 #undef  elf_backend_modify_segment_map
5336 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5337 #undef  elf_backend_modify_program_headers
5338 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5339 #undef  elf_backend_final_write_processing
5340 #define elf_backend_final_write_processing      nacl_final_write_processing
5341
5342 #include "elf32-target.h"
5343
5344 /* Restore defaults.  */
5345 #undef  elf_backend_object_p
5346 #undef  elf_backend_modify_segment_map
5347 #undef  elf_backend_modify_program_headers
5348 #undef  elf_backend_final_write_processing
5349
5350 /* VxWorks support.  */
5351
5352 #undef  TARGET_LITTLE_SYM
5353 #define TARGET_LITTLE_SYM               i386_elf32_vxworks_vec
5354 #undef  TARGET_LITTLE_NAME
5355 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
5356 #undef  ELF_OSABI
5357 #undef  elf_backend_plt_alignment
5358 #define elf_backend_plt_alignment       4
5359
5360 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
5361   {
5362     &elf_i386_plt,                      /* plt */
5363     0x90,                               /* plt0_pad_byte */
5364     1,                                  /* is_vxworks */
5365   };
5366
5367 #undef  elf_backend_arch_data
5368 #define elf_backend_arch_data   &elf_i386_vxworks_arch_bed
5369
5370 #undef elf_backend_relocs_compatible
5371 #undef elf_backend_add_symbol_hook
5372 #define elf_backend_add_symbol_hook \
5373   elf_vxworks_add_symbol_hook
5374 #undef elf_backend_link_output_symbol_hook
5375 #define elf_backend_link_output_symbol_hook \
5376   elf_vxworks_link_output_symbol_hook
5377 #undef elf_backend_emit_relocs
5378 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
5379 #undef elf_backend_final_write_processing
5380 #define elf_backend_final_write_processing \
5381   elf_vxworks_final_write_processing
5382 #undef elf_backend_static_tls_alignment
5383
5384 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
5385    define it.  */
5386 #undef elf_backend_want_plt_sym
5387 #define elf_backend_want_plt_sym        1
5388
5389 #undef  elf32_bed
5390 #define elf32_bed                               elf32_i386_vxworks_bed
5391
5392 #include "elf32-target.h"