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