bfd/elf32-i386.c

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