bfd/elf32-i386.c

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