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