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