bfd/elf32-i386.c

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