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