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