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