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