bfd/elf32-i386.c

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