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