bfd/elf32-i386.c

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