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