bfd/elf32-i386.c

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