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           if ((*(contents + rel->r_offset - 1) & 0xc7) == 0x5)
4214             {
4215               if (bfd_link_pic (info))
4216                 {
4217                   /* For PIC, disallow R_386_GOT32 without a base
4218                      register since we don't know what the GOT base
4219                      is.  */
4220                   const char *name;
4221
4222                   if (h == NULL)
4223                     name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4224                                              NULL);
4225                   else
4226                     name = h->root.root.string;
4227
4228                   (*_bfd_error_handler)
4229                     (_("%B: direct GOT relocation R_386_GOT32 against `%s' without base register can not be used when making a shared object"),
4230                      input_bfd, name);
4231                   bfd_set_error (bfd_error_bad_value);
4232                   return FALSE;
4233                 }
4234             }
4235           else
4236             {
4237               /* Subtract the .got.plt section address only with a base
4238                  register.  */
4239               relocation -= (htab->elf.sgotplt->output_section->vma
4240                              + htab->elf.sgotplt->output_offset);
4241             }
4242
4243           break;
4244
4245         case R_386_GOTOFF:
4246           /* Relocation is relative to the start of the global offset
4247              table.  */
4248
4249           /* Check to make sure it isn't a protected function or data
4250              symbol for shared library since it may not be local when
4251              used as function address or with copy relocation.  We also
4252              need to make sure that a symbol is referenced locally.  */
4253           if (!bfd_link_executable (info) && h)
4254             {
4255               if (!h->def_regular)
4256                 {
4257                   const char *v;
4258
4259                   switch (ELF_ST_VISIBILITY (h->other))
4260                     {
4261                     case STV_HIDDEN:
4262                       v = _("hidden symbol");
4263                       break;
4264                     case STV_INTERNAL:
4265                       v = _("internal symbol");
4266                       break;
4267                     case STV_PROTECTED:
4268                       v = _("protected symbol");
4269                       break;
4270                     default:
4271                       v = _("symbol");
4272                       break;
4273                     }
4274
4275                   (*_bfd_error_handler)
4276                     (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4277                      input_bfd, v, h->root.root.string);
4278                   bfd_set_error (bfd_error_bad_value);
4279                   return FALSE;
4280                 }
4281               else if (!SYMBOL_REFERENCES_LOCAL (info, h)
4282                        && (h->type == STT_FUNC
4283                            || h->type == STT_OBJECT)
4284                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4285                 {
4286                   (*_bfd_error_handler)
4287                     (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4288                      input_bfd,
4289                      h->type == STT_FUNC ? "function" : "data",
4290                      h->root.root.string);
4291                   bfd_set_error (bfd_error_bad_value);
4292                   return FALSE;
4293                 }
4294             }
4295
4296           /* Note that sgot is not involved in this
4297              calculation.  We always want the start of .got.plt.  If we
4298              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4299              permitted by the ABI, we might have to change this
4300              calculation.  */
4301           relocation -= htab->elf.sgotplt->output_section->vma
4302                         + htab->elf.sgotplt->output_offset;
4303           break;
4304
4305         case R_386_GOTPC:
4306           /* Use global offset table as symbol value.  */
4307           relocation = htab->elf.sgotplt->output_section->vma
4308                        + htab->elf.sgotplt->output_offset;
4309           unresolved_reloc = FALSE;
4310           break;
4311
4312         case R_386_PLT32:
4313           /* Relocation is to the entry for this symbol in the
4314              procedure linkage table.  */
4315
4316           /* Resolve a PLT32 reloc against a local symbol directly,
4317              without using the procedure linkage table.  */
4318           if (h == NULL)
4319             break;
4320
4321           if ((h->plt.offset == (bfd_vma) -1
4322                && eh->plt_got.offset == (bfd_vma) -1)
4323               || htab->elf.splt == NULL)
4324             {
4325               /* We didn't make a PLT entry for this symbol.  This
4326                  happens when statically linking PIC code, or when
4327                  using -Bsymbolic.  */
4328               break;
4329             }
4330
4331           if (h->plt.offset != (bfd_vma) -1)
4332             {
4333               resolved_plt = htab->elf.splt;
4334               plt_offset = h->plt.offset;
4335             }
4336           else
4337             {
4338               resolved_plt = htab->plt_got;
4339               plt_offset = eh->plt_got.offset;
4340             }
4341
4342           relocation = (resolved_plt->output_section->vma
4343                         + resolved_plt->output_offset
4344                         + plt_offset);
4345           unresolved_reloc = FALSE;
4346           break;
4347
4348         case R_386_SIZE32:
4349           /* Set to symbol size.  */
4350           relocation = st_size;
4351           /* Fall through.  */
4352
4353         case R_386_32:
4354         case R_386_PC32:
4355           if ((input_section->flags & SEC_ALLOC) == 0
4356               || is_vxworks_tls)
4357             break;
4358
4359           /* Copy dynamic function pointer relocations.  Don't generate
4360              dynamic relocations against resolved undefined weak symbols
4361              in PIE, except for R_386_PC32.  */
4362           if ((bfd_link_pic (info)
4363                && (h == NULL
4364                    || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4365                         && (!resolved_to_zero
4366                             || r_type == R_386_PC32))
4367                        || h->root.type != bfd_link_hash_undefweak))
4368                && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
4369                    || !SYMBOL_CALLS_LOCAL (info, h)))
4370               || (ELIMINATE_COPY_RELOCS
4371                   && !bfd_link_pic (info)
4372                   && h != NULL
4373                   && h->dynindx != -1
4374                   && (!h->non_got_ref
4375                       || eh->func_pointer_refcount > 0
4376                       || (h->root.type == bfd_link_hash_undefweak
4377                           && !resolved_to_zero))
4378                   && ((h->def_dynamic && !h->def_regular)
4379                       /* Undefined weak symbol is bound locally when
4380                          PIC is false.  */
4381                       || h->root.type == bfd_link_hash_undefweak)))
4382             {
4383               Elf_Internal_Rela outrel;
4384               bfd_boolean skip, relocate;
4385               asection *sreloc;
4386
4387               /* When generating a shared object, these relocations
4388                  are copied into the output file to be resolved at run
4389                  time.  */
4390
4391               skip = FALSE;
4392               relocate = FALSE;
4393
4394               outrel.r_offset =
4395                 _bfd_elf_section_offset (output_bfd, info, input_section,
4396                                          rel->r_offset);
4397               if (outrel.r_offset == (bfd_vma) -1)
4398                 skip = TRUE;
4399               else if (outrel.r_offset == (bfd_vma) -2)
4400                 skip = TRUE, relocate = TRUE;
4401               outrel.r_offset += (input_section->output_section->vma
4402                                   + input_section->output_offset);
4403
4404               if (skip)
4405                 memset (&outrel, 0, sizeof outrel);
4406               else if (h != NULL
4407                        && h->dynindx != -1
4408                        && (r_type == R_386_PC32
4409                            || !(bfd_link_executable (info)
4410                                 || SYMBOLIC_BIND (info, h))
4411                            || !h->def_regular))
4412                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4413               else
4414                 {
4415                   /* This symbol is local, or marked to become local.  */
4416                   relocate = TRUE;
4417                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4418                 }
4419
4420               sreloc = elf_section_data (input_section)->sreloc;
4421
4422               if (sreloc == NULL || sreloc->contents == NULL)
4423                 {
4424                   r = bfd_reloc_notsupported;
4425                   goto check_relocation_error;
4426                 }
4427
4428               elf_append_rel (output_bfd, sreloc, &outrel);
4429
4430               /* If this reloc is against an external symbol, we do
4431                  not want to fiddle with the addend.  Otherwise, we
4432                  need to include the symbol value so that it becomes
4433                  an addend for the dynamic reloc.  */
4434               if (! relocate)
4435                 continue;
4436             }
4437           break;
4438
4439         case R_386_TLS_IE:
4440           if (!bfd_link_executable (info))
4441             {
4442               Elf_Internal_Rela outrel;
4443               asection *sreloc;
4444
4445               outrel.r_offset = rel->r_offset
4446                                 + input_section->output_section->vma
4447                                 + input_section->output_offset;
4448               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4449               sreloc = elf_section_data (input_section)->sreloc;
4450               if (sreloc == NULL)
4451                 abort ();
4452               elf_append_rel (output_bfd, sreloc, &outrel);
4453             }
4454           /* Fall through */
4455
4456         case R_386_TLS_GD:
4457         case R_386_TLS_GOTDESC:
4458         case R_386_TLS_DESC_CALL:
4459         case R_386_TLS_IE_32:
4460         case R_386_TLS_GOTIE:
4461           tls_type = GOT_UNKNOWN;
4462           if (h == NULL && local_got_offsets)
4463             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4464           else if (h != NULL)
4465             tls_type = elf_i386_hash_entry(h)->tls_type;
4466           if (tls_type == GOT_TLS_IE)
4467             tls_type = GOT_TLS_IE_NEG;
4468
4469           if (! elf_i386_tls_transition (info, input_bfd,
4470                                          input_section, contents,
4471                                          symtab_hdr, sym_hashes,
4472                                          &r_type, tls_type, rel,
4473                                          relend, h, r_symndx, TRUE))
4474             return FALSE;
4475
4476           if (r_type == R_386_TLS_LE_32)
4477             {
4478               BFD_ASSERT (! unresolved_reloc);
4479               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4480                 {
4481                   unsigned int type;
4482                   bfd_vma roff;
4483
4484                   /* GD->LE transition.  */
4485                   type = *(contents + rel->r_offset - 2);
4486                   if (type == 0x04)
4487                     {
4488                       /* Change
4489                                 leal foo@tlsgd(,%ebx,1), %eax
4490                                 call ___tls_get_addr@PLT
4491                          into:
4492                                 movl %gs:0, %eax
4493                                 subl $foo@tpoff, %eax
4494                          (6 byte form of subl).  */
4495                       roff = rel->r_offset + 5;
4496                     }
4497                   else
4498                     {
4499                       /* Change
4500                                 leal foo@tlsgd(%ebx), %eax
4501                                 call ___tls_get_addr@PLT
4502                                 nop
4503                          or
4504                                 leal foo@tlsgd(%reg), %eax
4505                                 call *___tls_get_addr@GOT(%reg)
4506                                 which may be converted to
4507                                 addr32 call ___tls_get_addr
4508                          into:
4509                                 movl %gs:0, %eax; subl $foo@tpoff, %eax
4510                          (6 byte form of subl).  */
4511                       roff = rel->r_offset + 6;
4512                     }
4513                   memcpy (contents + roff - 8,
4514                           "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4515                   bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4516                               contents + roff);
4517                   /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X.  */
4518                   rel++;
4519                   wrel++;
4520                   continue;
4521                 }
4522               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4523                 {
4524                   /* GDesc -> LE transition.
4525                      It's originally something like:
4526                      leal x@tlsdesc(%ebx), %eax
4527
4528                      leal x@ntpoff, %eax
4529
4530                      Registers other than %eax may be set up here.  */
4531
4532                   unsigned int val;
4533                   bfd_vma roff;
4534
4535                   roff = rel->r_offset;
4536                   val = bfd_get_8 (input_bfd, contents + roff - 1);
4537
4538                   /* Now modify the instruction as appropriate.  */
4539                   /* aoliva FIXME: remove the above and xor the byte
4540                      below with 0x86.  */
4541                   bfd_put_8 (output_bfd, val ^ 0x86,
4542                              contents + roff - 1);
4543                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4544                               contents + roff);
4545                   continue;
4546                 }
4547               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4548                 {
4549                   /* GDesc -> LE transition.
4550                      It's originally:
4551                      call *(%eax)
4552                      Turn it into:
4553                      xchg %ax,%ax  */
4554
4555                   bfd_vma roff;
4556
4557                   roff = rel->r_offset;
4558                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4559                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4560                   continue;
4561                 }
4562               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
4563                 {
4564                   unsigned int val;
4565
4566                   /* IE->LE transition:
4567                      Originally it can be one of:
4568                      movl foo, %eax
4569                      movl foo, %reg
4570                      addl foo, %reg
4571                      We change it into:
4572                      movl $foo, %eax
4573                      movl $foo, %reg
4574                      addl $foo, %reg.  */
4575                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4576                   if (val == 0xa1)
4577                     {
4578                       /* movl foo, %eax.  */
4579                       bfd_put_8 (output_bfd, 0xb8,
4580                                  contents + rel->r_offset - 1);
4581                     }
4582                   else
4583                     {
4584                       unsigned int type;
4585
4586                       type = bfd_get_8 (input_bfd,
4587                                         contents + rel->r_offset - 2);
4588                       switch (type)
4589                         {
4590                         case 0x8b:
4591                           /* movl */
4592                           bfd_put_8 (output_bfd, 0xc7,
4593                                      contents + rel->r_offset - 2);
4594                           bfd_put_8 (output_bfd,
4595                                      0xc0 | ((val >> 3) & 7),
4596                                      contents + rel->r_offset - 1);
4597                           break;
4598                         case 0x03:
4599                           /* addl */
4600                           bfd_put_8 (output_bfd, 0x81,
4601                                      contents + rel->r_offset - 2);
4602                           bfd_put_8 (output_bfd,
4603                                      0xc0 | ((val >> 3) & 7),
4604                                      contents + rel->r_offset - 1);
4605                           break;
4606                         default:
4607                           BFD_FAIL ();
4608                           break;
4609                         }
4610                     }
4611                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4612                               contents + rel->r_offset);
4613                   continue;
4614                 }
4615               else
4616                 {
4617                   unsigned int val, type;
4618
4619                   /* {IE_32,GOTIE}->LE transition:
4620                      Originally it can be one of:
4621                      subl foo(%reg1), %reg2
4622                      movl foo(%reg1), %reg2
4623                      addl foo(%reg1), %reg2
4624                      We change it into:
4625                      subl $foo, %reg2
4626                      movl $foo, %reg2 (6 byte form)
4627                      addl $foo, %reg2.  */
4628                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4629                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4630                   if (type == 0x8b)
4631                     {
4632                       /* movl */
4633                       bfd_put_8 (output_bfd, 0xc7,
4634                                  contents + rel->r_offset - 2);
4635                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4636                                  contents + rel->r_offset - 1);
4637                     }
4638                   else if (type == 0x2b)
4639                     {
4640                       /* subl */
4641                       bfd_put_8 (output_bfd, 0x81,
4642                                  contents + rel->r_offset - 2);
4643                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4644                                  contents + rel->r_offset - 1);
4645                     }
4646                   else if (type == 0x03)
4647                     {
4648                       /* addl */
4649                       bfd_put_8 (output_bfd, 0x81,
4650                                  contents + rel->r_offset - 2);
4651                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4652                                  contents + rel->r_offset - 1);
4653                     }
4654                   else
4655                     BFD_FAIL ();
4656                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4657                     bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4658                                 contents + rel->r_offset);
4659                   else
4660                     bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4661                                 contents + rel->r_offset);
4662                   continue;
4663                 }
4664             }
4665
4666           if (htab->elf.sgot == NULL)
4667             abort ();
4668
4669           if (h != NULL)
4670             {
4671               off = h->got.offset;
4672               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4673             }
4674           else
4675             {
4676               if (local_got_offsets == NULL)
4677                 abort ();
4678
4679               off = local_got_offsets[r_symndx];
4680               offplt = local_tlsdesc_gotents[r_symndx];
4681             }
4682
4683           if ((off & 1) != 0)
4684             off &= ~1;
4685           else
4686             {
4687               Elf_Internal_Rela outrel;
4688               int dr_type;
4689               asection *sreloc;
4690
4691               if (htab->elf.srelgot == NULL)
4692                 abort ();
4693
4694               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4695
4696               if (GOT_TLS_GDESC_P (tls_type))
4697                 {
4698                   bfd_byte *loc;
4699                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4700                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4701                               <= htab->elf.sgotplt->size);
4702                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4703                                      + htab->elf.sgotplt->output_offset
4704                                      + offplt
4705                                      + htab->sgotplt_jump_table_size);
4706                   sreloc = htab->elf.srelplt;
4707                   loc = sreloc->contents;
4708                   loc += (htab->next_tls_desc_index++
4709                           * sizeof (Elf32_External_Rel));
4710                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4711                               <= sreloc->contents + sreloc->size);
4712                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4713                   if (indx == 0)
4714                     {
4715                       BFD_ASSERT (! unresolved_reloc);
4716                       bfd_put_32 (output_bfd,
4717                                   relocation - elf_i386_dtpoff_base (info),
4718                                   htab->elf.sgotplt->contents + offplt
4719                                   + htab->sgotplt_jump_table_size + 4);
4720                     }
4721                   else
4722                     {
4723                       bfd_put_32 (output_bfd, 0,
4724                                   htab->elf.sgotplt->contents + offplt
4725                                   + htab->sgotplt_jump_table_size + 4);
4726                     }
4727                 }
4728
4729               sreloc = htab->elf.srelgot;
4730
4731               outrel.r_offset = (htab->elf.sgot->output_section->vma
4732                                  + htab->elf.sgot->output_offset + off);
4733
4734               if (GOT_TLS_GD_P (tls_type))
4735                 dr_type = R_386_TLS_DTPMOD32;
4736               else if (GOT_TLS_GDESC_P (tls_type))
4737                 goto dr_done;
4738               else if (tls_type == GOT_TLS_IE_POS)
4739                 dr_type = R_386_TLS_TPOFF;
4740               else
4741                 dr_type = R_386_TLS_TPOFF32;
4742
4743               if (dr_type == R_386_TLS_TPOFF && indx == 0)
4744                 bfd_put_32 (output_bfd,
4745                             relocation - elf_i386_dtpoff_base (info),
4746                             htab->elf.sgot->contents + off);
4747               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4748                 bfd_put_32 (output_bfd,
4749                             elf_i386_dtpoff_base (info) - relocation,
4750                             htab->elf.sgot->contents + off);
4751               else if (dr_type != R_386_TLS_DESC)
4752                 bfd_put_32 (output_bfd, 0,
4753                             htab->elf.sgot->contents + off);
4754               outrel.r_info = ELF32_R_INFO (indx, dr_type);
4755
4756               elf_append_rel (output_bfd, sreloc, &outrel);
4757
4758               if (GOT_TLS_GD_P (tls_type))
4759                 {
4760                   if (indx == 0)
4761                     {
4762                       BFD_ASSERT (! unresolved_reloc);
4763                       bfd_put_32 (output_bfd,
4764                                   relocation - elf_i386_dtpoff_base (info),
4765                                   htab->elf.sgot->contents + off + 4);
4766                     }
4767                   else
4768                     {
4769                       bfd_put_32 (output_bfd, 0,
4770                                   htab->elf.sgot->contents + off + 4);
4771                       outrel.r_info = ELF32_R_INFO (indx,
4772                                                     R_386_TLS_DTPOFF32);
4773                       outrel.r_offset += 4;
4774                       elf_append_rel (output_bfd, sreloc, &outrel);
4775                     }
4776                 }
4777               else if (tls_type == GOT_TLS_IE_BOTH)
4778                 {
4779                   bfd_put_32 (output_bfd,
4780                               (indx == 0
4781                                ? relocation - elf_i386_dtpoff_base (info)
4782                                : 0),
4783                               htab->elf.sgot->contents + off + 4);
4784                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4785                   outrel.r_offset += 4;
4786                   elf_append_rel (output_bfd, sreloc, &outrel);
4787                 }
4788
4789             dr_done:
4790               if (h != NULL)
4791                 h->got.offset |= 1;
4792               else
4793                 local_got_offsets[r_symndx] |= 1;
4794             }
4795
4796           if (off >= (bfd_vma) -2
4797               && ! GOT_TLS_GDESC_P (tls_type))
4798             abort ();
4799           if (r_type == R_386_TLS_GOTDESC
4800               || r_type == R_386_TLS_DESC_CALL)
4801             {
4802               relocation = htab->sgotplt_jump_table_size + offplt;
4803               unresolved_reloc = FALSE;
4804             }
4805           else if (r_type == ELF32_R_TYPE (rel->r_info))
4806             {
4807               bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4808                               + htab->elf.sgotplt->output_offset;
4809               relocation = htab->elf.sgot->output_section->vma
4810                 + htab->elf.sgot->output_offset + off - g_o_t;
4811               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4812                   && tls_type == GOT_TLS_IE_BOTH)
4813                 relocation += 4;
4814               if (r_type == R_386_TLS_IE)
4815                 relocation += g_o_t;
4816               unresolved_reloc = FALSE;
4817             }
4818           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4819             {
4820               unsigned int val, type;
4821               bfd_vma roff;
4822
4823               /* GD->IE transition.  */
4824               type = *(contents + rel->r_offset - 2);
4825               val = *(contents + rel->r_offset - 1);
4826               if (type == 0x04)
4827                 {
4828                   /* Change
4829                         leal foo@tlsgd(,%ebx,1), %eax
4830                         call ___tls_get_addr@PLT
4831                      into:
4832                         movl %gs:0, %eax
4833                         subl $foo@gottpoff(%ebx), %eax.  */
4834                   val >>= 3;
4835                   roff = rel->r_offset - 3;
4836                 }
4837               else
4838                 {
4839                   /* Change
4840                         leal foo@tlsgd(%ebx), %eax
4841                         call ___tls_get_addr@PLT
4842                         nop
4843                      or
4844                         leal foo@tlsgd(%reg), %eax
4845                         call *___tls_get_addr@GOT(%reg)
4846                         which may be converted to
4847                         addr32 call ___tls_get_addr
4848                      into:
4849                         movl %gs:0, %eax;
4850                         subl $foo@gottpoff(%reg), %eax.  */
4851                   roff = rel->r_offset - 2;
4852                 }
4853               memcpy (contents + roff,
4854                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4855               contents[roff + 7] = 0x80 | (val & 7);
4856               /* If foo is used only with foo@gotntpoff(%reg) and
4857                  foo@indntpoff, but not with foo@gottpoff(%reg), change
4858                  subl $foo@gottpoff(%reg), %eax
4859                  into:
4860                  addl $foo@gotntpoff(%reg), %eax.  */
4861               if (tls_type == GOT_TLS_IE_POS)
4862                 contents[roff + 6] = 0x03;
4863               bfd_put_32 (output_bfd,
4864                           htab->elf.sgot->output_section->vma
4865                           + htab->elf.sgot->output_offset + off
4866                           - htab->elf.sgotplt->output_section->vma
4867                           - htab->elf.sgotplt->output_offset,
4868                           contents + roff + 8);
4869               /* Skip R_386_PLT32 and R_386_GOT32X.  */
4870               rel++;
4871               wrel++;
4872               continue;
4873             }
4874           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4875             {
4876               /* GDesc -> IE transition.
4877                  It's originally something like:
4878                  leal x@tlsdesc(%ebx), %eax
4879
4880                  Change it to:
4881                  movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4882                  or:
4883                  movl x@gottpoff(%ebx), %eax # before negl %eax
4884
4885                  Registers other than %eax may be set up here.  */
4886
4887               bfd_vma roff;
4888
4889               /* First, make sure it's a leal adding ebx to a 32-bit
4890                  offset into any register, although it's probably
4891                  almost always going to be eax.  */
4892               roff = rel->r_offset;
4893
4894               /* Now modify the instruction as appropriate.  */
4895               /* To turn a leal into a movl in the form we use it, it
4896                  suffices to change the first byte from 0x8d to 0x8b.
4897                  aoliva FIXME: should we decide to keep the leal, all
4898                  we have to do is remove the statement below, and
4899                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
4900               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4901
4902               if (tls_type == GOT_TLS_IE_BOTH)
4903                 off += 4;
4904
4905               bfd_put_32 (output_bfd,
4906                           htab->elf.sgot->output_section->vma
4907                           + htab->elf.sgot->output_offset + off
4908                           - htab->elf.sgotplt->output_section->vma
4909                           - htab->elf.sgotplt->output_offset,
4910                           contents + roff);
4911               continue;
4912             }
4913           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4914             {
4915               /* GDesc -> IE transition.
4916                  It's originally:
4917                  call *(%eax)
4918
4919                  Change it to:
4920                  xchg %ax,%ax
4921                  or
4922                  negl %eax
4923                  depending on how we transformed the TLS_GOTDESC above.
4924               */
4925
4926               bfd_vma roff;
4927
4928               roff = rel->r_offset;
4929
4930               /* Now modify the instruction as appropriate.  */
4931               if (tls_type != GOT_TLS_IE_NEG)
4932                 {
4933                   /* xchg %ax,%ax */
4934                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4935                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4936                 }
4937               else
4938                 {
4939                   /* negl %eax */
4940                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
4941                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4942                 }
4943
4944               continue;
4945             }
4946           else
4947             BFD_ASSERT (FALSE);
4948           break;
4949
4950         case R_386_TLS_LDM:
4951           if (! elf_i386_tls_transition (info, input_bfd,
4952                                          input_section, contents,
4953                                          symtab_hdr, sym_hashes,
4954                                          &r_type, GOT_UNKNOWN, rel,
4955                                          relend, h, r_symndx, TRUE))
4956             return FALSE;
4957
4958           if (r_type != R_386_TLS_LDM)
4959             {
4960               /* LD->LE transition.  Change
4961                         leal foo@tlsldm(%ebx) %eax
4962                         call ___tls_get_addr@PLT
4963                  into:
4964                         movl %gs:0, %eax
4965                         nop
4966                         leal 0(%esi,1), %esi
4967                  or change
4968                         leal foo@tlsldm(%reg) %eax
4969                         call *___tls_get_addr@GOT(%reg)
4970                         which may be converted to
4971                         addr32 call ___tls_get_addr
4972                  into:
4973                         movl %gs:0, %eax
4974                         leal 0(%esi), %esi  */
4975               BFD_ASSERT (r_type == R_386_TLS_LE_32);
4976               if (*(contents + rel->r_offset + 4) == 0xff
4977                   || *(contents + rel->r_offset + 4) == 0x67)
4978                 memcpy (contents + rel->r_offset - 2,
4979                         "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
4980               else
4981                 memcpy (contents + rel->r_offset - 2,
4982                         "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4983               /* Skip R_386_PC32/R_386_PLT32.  */
4984               rel++;
4985               wrel++;
4986               continue;
4987             }
4988
4989           if (htab->elf.sgot == NULL)
4990             abort ();
4991
4992           off = htab->tls_ldm_got.offset;
4993           if (off & 1)
4994             off &= ~1;
4995           else
4996             {
4997               Elf_Internal_Rela outrel;
4998
4999               if (htab->elf.srelgot == NULL)
5000                 abort ();
5001
5002               outrel.r_offset = (htab->elf.sgot->output_section->vma
5003                                  + htab->elf.sgot->output_offset + off);
5004
5005               bfd_put_32 (output_bfd, 0,
5006                           htab->elf.sgot->contents + off);
5007               bfd_put_32 (output_bfd, 0,
5008                           htab->elf.sgot->contents + off + 4);
5009               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
5010               elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
5011               htab->tls_ldm_got.offset |= 1;
5012             }
5013           relocation = htab->elf.sgot->output_section->vma
5014                        + htab->elf.sgot->output_offset + off
5015                        - htab->elf.sgotplt->output_section->vma
5016                        - htab->elf.sgotplt->output_offset;
5017           unresolved_reloc = FALSE;
5018           break;
5019
5020         case R_386_TLS_LDO_32:
5021           if (!bfd_link_executable (info)
5022               || (input_section->flags & SEC_CODE) == 0)
5023             relocation -= elf_i386_dtpoff_base (info);
5024           else
5025             /* When converting LDO to LE, we must negate.  */
5026             relocation = -elf_i386_tpoff (info, relocation);
5027           break;
5028
5029         case R_386_TLS_LE_32:
5030         case R_386_TLS_LE:
5031           if (!bfd_link_executable (info))
5032             {
5033               Elf_Internal_Rela outrel;
5034               asection *sreloc;
5035
5036               outrel.r_offset = rel->r_offset
5037                                 + input_section->output_section->vma
5038                                 + input_section->output_offset;
5039               if (h != NULL && h->dynindx != -1)
5040                 indx = h->dynindx;
5041               else
5042                 indx = 0;
5043               if (r_type == R_386_TLS_LE_32)
5044                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
5045               else
5046                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
5047               sreloc = elf_section_data (input_section)->sreloc;
5048               if (sreloc == NULL)
5049                 abort ();
5050               elf_append_rel (output_bfd, sreloc, &outrel);
5051               if (indx)
5052                 continue;
5053               else if (r_type == R_386_TLS_LE_32)
5054                 relocation = elf_i386_dtpoff_base (info) - relocation;
5055               else
5056                 relocation -= elf_i386_dtpoff_base (info);
5057             }
5058           else if (r_type == R_386_TLS_LE_32)
5059             relocation = elf_i386_tpoff (info, relocation);
5060           else
5061             relocation = -elf_i386_tpoff (info, relocation);
5062           break;
5063
5064         default:
5065           break;
5066         }
5067
5068       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5069          because such sections are not SEC_ALLOC and thus ld.so will
5070          not process them.  */
5071       if (unresolved_reloc
5072           && !((input_section->flags & SEC_DEBUGGING) != 0
5073                && h->def_dynamic)
5074           && _bfd_elf_section_offset (output_bfd, info, input_section,
5075                                       rel->r_offset) != (bfd_vma) -1)
5076         {
5077           (*_bfd_error_handler)
5078             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5079              input_bfd,
5080              input_section,
5081              (long) rel->r_offset,
5082              howto->name,
5083              h->root.root.string);
5084           return FALSE;
5085         }
5086
5087 do_relocation:
5088       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5089                                     contents, rel->r_offset,
5090                                     relocation, 0);
5091
5092 check_relocation_error:
5093       if (r != bfd_reloc_ok)
5094         {
5095           const char *name;
5096
5097           if (h != NULL)
5098             name = h->root.root.string;
5099           else
5100             {
5101               name = bfd_elf_string_from_elf_section (input_bfd,
5102                                                       symtab_hdr->sh_link,
5103                                                       sym->st_name);
5104               if (name == NULL)
5105                 return FALSE;
5106               if (*name == '\0')
5107                 name = bfd_section_name (input_bfd, sec);
5108             }
5109
5110           if (r == bfd_reloc_overflow)
5111             (*info->callbacks->reloc_overflow)
5112               (info, (h ? &h->root : NULL), name, howto->name,
5113                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
5114           else
5115             {
5116               (*_bfd_error_handler)
5117                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5118                  input_bfd, input_section,
5119                  (long) rel->r_offset, name, (int) r);
5120               return FALSE;
5121             }
5122         }
5123
5124       if (wrel != rel)
5125         *wrel = *rel;
5126     }
5127
5128   if (wrel != rel)
5129     {
5130       Elf_Internal_Shdr *rel_hdr;
5131       size_t deleted = rel - wrel;
5132
5133       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5134       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5135       if (rel_hdr->sh_size == 0)
5136         {
5137           /* It is too late to remove an empty reloc section.  Leave
5138              one NONE reloc.
5139              ??? What is wrong with an empty section???  */
5140           rel_hdr->sh_size = rel_hdr->sh_entsize;
5141           deleted -= 1;
5142         }
5143       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5144       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5145       input_section->reloc_count -= deleted;
5146     }
5147
5148   return TRUE;
5149 }
5150
5151 /* Finish up dynamic symbol handling.  We set the contents of various
5152    dynamic sections here.  */
5153
5154 static bfd_boolean
5155 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5156                                 struct bfd_link_info *info,
5157                                 struct elf_link_hash_entry *h,
5158                                 Elf_Internal_Sym *sym)
5159 {
5160   struct elf_i386_link_hash_table *htab;
5161   unsigned plt_entry_size;
5162   const struct elf_i386_backend_data *abed;
5163   struct elf_i386_link_hash_entry *eh;
5164   bfd_boolean local_undefweak;
5165
5166   htab = elf_i386_hash_table (info);
5167   if (htab == NULL)
5168     return FALSE;
5169
5170   abed = get_elf_i386_backend_data (output_bfd);
5171   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5172
5173   eh = (struct elf_i386_link_hash_entry *) h;
5174
5175   /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5176      resolved undefined weak symbols in executable so that their
5177      references have value 0 at run-time.  */
5178   local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5179                                                      eh->has_got_reloc,
5180                                                      eh);
5181
5182   if (h->plt.offset != (bfd_vma) -1)
5183     {
5184       bfd_vma plt_index;
5185       bfd_vma got_offset;
5186       Elf_Internal_Rela rel;
5187       bfd_byte *loc;
5188       asection *plt, *gotplt, *relplt;
5189
5190       /* When building a static executable, use .iplt, .igot.plt and
5191          .rel.iplt sections for STT_GNU_IFUNC symbols.  */
5192       if (htab->elf.splt != NULL)
5193         {
5194           plt = htab->elf.splt;
5195           gotplt = htab->elf.sgotplt;
5196           relplt = htab->elf.srelplt;
5197         }
5198       else
5199         {
5200           plt = htab->elf.iplt;
5201           gotplt = htab->elf.igotplt;
5202           relplt = htab->elf.irelplt;
5203         }
5204
5205       /* This symbol has an entry in the procedure linkage table.  Set
5206          it up.  */
5207
5208       if ((h->dynindx == -1
5209            && !local_undefweak
5210            && !((h->forced_local || bfd_link_executable (info))
5211                 && h->def_regular
5212                 && h->type == STT_GNU_IFUNC))
5213           || plt == NULL
5214           || gotplt == NULL
5215           || relplt == NULL)
5216         abort ();
5217
5218       /* Get the index in the procedure linkage table which
5219          corresponds to this symbol.  This is the index of this symbol
5220          in all the symbols for which we are making plt entries.  The
5221          first entry in the procedure linkage table is reserved.
5222
5223          Get the offset into the .got table of the entry that
5224          corresponds to this function.  Each .got entry is 4 bytes.
5225          The first three are reserved.
5226
5227          For static executables, we don't reserve anything.  */
5228
5229       if (plt == htab->elf.splt)
5230         {
5231           got_offset = h->plt.offset / plt_entry_size - 1;
5232           got_offset = (got_offset + 3) * 4;
5233         }
5234       else
5235         {
5236           got_offset = h->plt.offset / plt_entry_size;
5237           got_offset = got_offset * 4;
5238         }
5239
5240       /* Fill in the entry in the procedure linkage table.  */
5241       if (! bfd_link_pic (info))
5242         {
5243           memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5244                   abed->plt->plt_entry_size);
5245           bfd_put_32 (output_bfd,
5246                       (gotplt->output_section->vma
5247                        + gotplt->output_offset
5248                        + got_offset),
5249                       plt->contents + h->plt.offset
5250                       + abed->plt->plt_got_offset);
5251
5252           if (abed->is_vxworks)
5253             {
5254               int s, k, reloc_index;
5255
5256               /* Create the R_386_32 relocation referencing the GOT
5257                  for this PLT entry.  */
5258
5259               /* S: Current slot number (zero-based).  */
5260               s = ((h->plt.offset - abed->plt->plt_entry_size)
5261                    / abed->plt->plt_entry_size);
5262               /* K: Number of relocations for PLTResolve. */
5263               if (bfd_link_pic (info))
5264                 k = PLTRESOLVE_RELOCS_SHLIB;
5265               else
5266                 k = PLTRESOLVE_RELOCS;
5267               /* Skip the PLTresolve relocations, and the relocations for
5268                  the other PLT slots. */
5269               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5270               loc = (htab->srelplt2->contents + reloc_index
5271                      * sizeof (Elf32_External_Rel));
5272
5273               rel.r_offset = (htab->elf.splt->output_section->vma
5274                               + htab->elf.splt->output_offset
5275                               + h->plt.offset + 2),
5276               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5277               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5278
5279               /* Create the R_386_32 relocation referencing the beginning of
5280                  the PLT for this GOT entry.  */
5281               rel.r_offset = (htab->elf.sgotplt->output_section->vma
5282                               + htab->elf.sgotplt->output_offset
5283                               + got_offset);
5284               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5285               bfd_elf32_swap_reloc_out (output_bfd, &rel,
5286                                         loc + sizeof (Elf32_External_Rel));
5287             }
5288         }
5289       else
5290         {
5291           memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5292                   abed->plt->plt_entry_size);
5293           bfd_put_32 (output_bfd, got_offset,
5294                       plt->contents + h->plt.offset
5295                       + abed->plt->plt_got_offset);
5296         }
5297
5298       /* Fill in the entry in the global offset table.  Leave the entry
5299          as zero for undefined weak symbol in PIE.  No PLT relocation
5300          against undefined weak symbol in PIE.  */
5301       if (!local_undefweak)
5302         {
5303           bfd_put_32 (output_bfd,
5304                       (plt->output_section->vma
5305                        + plt->output_offset
5306                        + h->plt.offset
5307                        + abed->plt->plt_lazy_offset),
5308                       gotplt->contents + got_offset);
5309
5310           /* Fill in the entry in the .rel.plt section.  */
5311           rel.r_offset = (gotplt->output_section->vma
5312                           + gotplt->output_offset
5313                           + got_offset);
5314           if (h->dynindx == -1
5315               || ((bfd_link_executable (info)
5316                    || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5317                   && h->def_regular
5318                   && h->type == STT_GNU_IFUNC))
5319             {
5320               /* If an STT_GNU_IFUNC symbol is locally defined, generate
5321                  R_386_IRELATIVE instead of R_386_JUMP_SLOT.  Store addend
5322                  in the .got.plt section.  */
5323               bfd_put_32 (output_bfd,
5324                           (h->root.u.def.value
5325                            + h->root.u.def.section->output_section->vma
5326                            + h->root.u.def.section->output_offset),
5327                           gotplt->contents + got_offset);
5328               rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5329               /* R_386_IRELATIVE comes last.  */
5330               plt_index = htab->next_irelative_index--;
5331             }
5332           else
5333             {
5334               rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5335               plt_index = htab->next_jump_slot_index++;
5336             }
5337
5338           loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5339           bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5340
5341           /* Don't fill PLT entry for static executables.  */
5342           if (plt == htab->elf.splt)
5343             {
5344               bfd_put_32 (output_bfd,
5345                           plt_index * sizeof (Elf32_External_Rel),
5346                           plt->contents + h->plt.offset
5347                           + abed->plt->plt_reloc_offset);
5348               bfd_put_32 (output_bfd, - (h->plt.offset
5349                                          + abed->plt->plt_plt_offset + 4),
5350                           plt->contents + h->plt.offset
5351                           + abed->plt->plt_plt_offset);
5352             }
5353         }
5354     }
5355   else if (eh->plt_got.offset != (bfd_vma) -1)
5356     {
5357       bfd_vma got_offset, plt_offset;
5358       asection *plt, *got, *gotplt;
5359       const bfd_byte *got_plt_entry;
5360
5361       /* Offset of displacement of the indirect jump.  */
5362       bfd_vma plt_got_offset = 2;
5363
5364       /* Set the entry in the GOT procedure linkage table.  */
5365       plt = htab->plt_got;
5366       got = htab->elf.sgot;
5367       gotplt = htab->elf.sgotplt;
5368       got_offset = h->got.offset;
5369
5370       if (got_offset == (bfd_vma) -1
5371           || plt == NULL
5372           || got == NULL
5373           || gotplt == NULL)
5374         abort ();
5375
5376       /* Fill in the entry in the GOT procedure linkage table.  */
5377       if (! bfd_link_pic (info))
5378         {
5379           got_plt_entry = elf_i386_got_plt_entry;
5380           got_offset += got->output_section->vma + got->output_offset;
5381         }
5382       else
5383         {
5384           got_plt_entry = elf_i386_pic_got_plt_entry;
5385           got_offset += (got->output_section->vma
5386                          + got->output_offset
5387                          - gotplt->output_section->vma
5388                          - gotplt->output_offset);
5389         }
5390
5391       plt_offset = eh->plt_got.offset;
5392       memcpy (plt->contents + plt_offset, got_plt_entry,
5393               sizeof (elf_i386_got_plt_entry));
5394       bfd_put_32 (output_bfd, got_offset,
5395                   plt->contents + plt_offset + plt_got_offset);
5396     }
5397
5398   if (!local_undefweak
5399       && !h->def_regular
5400       && (h->plt.offset != (bfd_vma) -1
5401           || eh->plt_got.offset != (bfd_vma) -1))
5402     {
5403       /* Mark the symbol as undefined, rather than as defined in
5404          the .plt section.  Leave the value if there were any
5405          relocations where pointer equality matters (this is a clue
5406          for the dynamic linker, to make function pointer
5407          comparisons work between an application and shared
5408          library), otherwise set it to zero.  If a function is only
5409          called from a binary, there is no need to slow down
5410          shared libraries because of that.  */
5411       sym->st_shndx = SHN_UNDEF;
5412       if (!h->pointer_equality_needed)
5413         sym->st_value = 0;
5414     }
5415
5416   /* Don't generate dynamic GOT relocation against undefined weak
5417      symbol in executable.  */
5418   if (h->got.offset != (bfd_vma) -1
5419       && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
5420       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5421       && !local_undefweak)
5422     {
5423       Elf_Internal_Rela rel;
5424
5425       /* This symbol has an entry in the global offset table.  Set it
5426          up.  */
5427
5428       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5429         abort ();
5430
5431       rel.r_offset = (htab->elf.sgot->output_section->vma
5432                       + htab->elf.sgot->output_offset
5433                       + (h->got.offset & ~(bfd_vma) 1));
5434
5435       /* If this is a static link, or it is a -Bsymbolic link and the
5436          symbol is defined locally or was forced to be local because
5437          of a version file, we just want to emit a RELATIVE reloc.
5438          The entry in the global offset table will already have been
5439          initialized in the relocate_section function.  */
5440       if (h->def_regular
5441           && h->type == STT_GNU_IFUNC)
5442         {
5443           if (bfd_link_pic (info))
5444             {
5445               /* Generate R_386_GLOB_DAT.  */
5446               goto do_glob_dat;
5447             }
5448           else
5449             {
5450               asection *plt;
5451
5452               if (!h->pointer_equality_needed)
5453                 abort ();
5454
5455               /* For non-shared object, we can't use .got.plt, which
5456                  contains the real function addres if we need pointer
5457                  equality.  We load the GOT entry with the PLT entry.  */
5458               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5459               bfd_put_32 (output_bfd,
5460                           (plt->output_section->vma
5461                            + plt->output_offset + h->plt.offset),
5462                           htab->elf.sgot->contents + h->got.offset);
5463               return TRUE;
5464             }
5465         }
5466       else if (bfd_link_pic (info)
5467                && SYMBOL_REFERENCES_LOCAL (info, h))
5468         {
5469           BFD_ASSERT((h->got.offset & 1) != 0);
5470           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5471         }
5472       else
5473         {
5474           BFD_ASSERT((h->got.offset & 1) == 0);
5475 do_glob_dat:
5476           bfd_put_32 (output_bfd, (bfd_vma) 0,
5477                       htab->elf.sgot->contents + h->got.offset);
5478           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5479         }
5480
5481       elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
5482     }
5483
5484   if (h->needs_copy)
5485     {
5486       Elf_Internal_Rela rel;
5487
5488       /* This symbol needs a copy reloc.  Set it up.  */
5489
5490       if (h->dynindx == -1
5491           || (h->root.type != bfd_link_hash_defined
5492               && h->root.type != bfd_link_hash_defweak)
5493           || htab->srelbss == NULL)
5494         abort ();
5495
5496       rel.r_offset = (h->root.u.def.value
5497                       + h->root.u.def.section->output_section->vma
5498                       + h->root.u.def.section->output_offset);
5499       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
5500       elf_append_rel (output_bfd, htab->srelbss, &rel);
5501     }
5502
5503   return TRUE;
5504 }
5505
5506 /* Finish up local dynamic symbol handling.  We set the contents of
5507    various dynamic sections here.  */
5508
5509 static bfd_boolean
5510 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5511 {
5512   struct elf_link_hash_entry *h
5513     = (struct elf_link_hash_entry *) *slot;
5514   struct bfd_link_info *info
5515     = (struct bfd_link_info *) inf;
5516
5517   return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5518                                          h, NULL);
5519 }
5520
5521 /* Finish up undefined weak symbol handling in PIE.  Fill its PLT entry
5522    here since undefined weak symbol may not be dynamic and may not be
5523    called for elf_i386_finish_dynamic_symbol.  */
5524
5525 static bfd_boolean
5526 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5527                                       void *inf)
5528 {
5529   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5530   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5531
5532   if (h->root.type != bfd_link_hash_undefweak
5533       || h->dynindx != -1)
5534     return TRUE;
5535
5536   return elf_i386_finish_dynamic_symbol (info->output_bfd,
5537                                              info, h, NULL);
5538 }
5539
5540 /* Used to decide how to sort relocs in an optimal manner for the
5541    dynamic linker, before writing them out.  */
5542
5543 static enum elf_reloc_type_class
5544 elf_i386_reloc_type_class (const struct bfd_link_info *info,
5545                            const asection *rel_sec ATTRIBUTE_UNUSED,
5546                            const Elf_Internal_Rela *rela)
5547 {
5548   bfd *abfd = info->output_bfd;
5549   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5550   struct elf_link_hash_table *htab = elf_hash_table (info);
5551
5552   if (htab->dynsym != NULL
5553       && htab->dynsym->contents != NULL)
5554     {
5555       /* Check relocation against STT_GNU_IFUNC symbol if there are
5556          dynamic symbols.  */
5557       unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5558       Elf_Internal_Sym sym;
5559       if (!bed->s->swap_symbol_in (abfd,
5560                                    (htab->dynsym->contents
5561                                     + r_symndx * sizeof (Elf32_External_Sym)),
5562                                    0, &sym))
5563         abort ();
5564
5565       if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5566         return reloc_class_ifunc;
5567     }
5568
5569   switch (ELF32_R_TYPE (rela->r_info))
5570     {
5571     case R_386_RELATIVE:
5572       return reloc_class_relative;
5573     case R_386_JUMP_SLOT:
5574       return reloc_class_plt;
5575     case R_386_COPY:
5576       return reloc_class_copy;
5577     default:
5578       return reloc_class_normal;
5579     }
5580 }
5581
5582 /* Finish up the dynamic sections.  */
5583
5584 static bfd_boolean
5585 elf_i386_finish_dynamic_sections (bfd *output_bfd,
5586                                   struct bfd_link_info *info)
5587 {
5588   struct elf_i386_link_hash_table *htab;
5589   bfd *dynobj;
5590   asection *sdyn;
5591   const struct elf_i386_backend_data *abed;
5592
5593   htab = elf_i386_hash_table (info);
5594   if (htab == NULL)
5595     return FALSE;
5596
5597   dynobj = htab->elf.dynobj;
5598   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5599   abed = get_elf_i386_backend_data (output_bfd);
5600
5601   if (htab->elf.dynamic_sections_created)
5602     {
5603       Elf32_External_Dyn *dyncon, *dynconend;
5604
5605       if (sdyn == NULL || htab->elf.sgot == NULL)
5606         abort ();
5607
5608       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5609       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5610       for (; dyncon < dynconend; dyncon++)
5611         {
5612           Elf_Internal_Dyn dyn;
5613           asection *s;
5614
5615           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5616
5617           switch (dyn.d_tag)
5618             {
5619             default:
5620               if (abed->is_vxworks
5621                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
5622                 break;
5623               continue;
5624
5625             case DT_PLTGOT:
5626               s = htab->elf.sgotplt;
5627               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5628               break;
5629
5630             case DT_JMPREL:
5631               s = htab->elf.srelplt;
5632               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5633               break;
5634
5635             case DT_PLTRELSZ:
5636               s = htab->elf.srelplt;
5637               dyn.d_un.d_val = s->size;
5638               break;
5639
5640             case DT_RELSZ:
5641               /* My reading of the SVR4 ABI indicates that the
5642                  procedure linkage table relocs (DT_JMPREL) should be
5643                  included in the overall relocs (DT_REL).  This is
5644                  what Solaris does.  However, UnixWare can not handle
5645                  that case.  Therefore, we override the DT_RELSZ entry
5646                  here to make it not include the JMPREL relocs.  */
5647               s = htab->elf.srelplt;
5648               if (s == NULL)
5649                 continue;
5650               dyn.d_un.d_val -= s->size;
5651               break;
5652
5653             case DT_REL:
5654               /* We may not be using the standard ELF linker script.
5655                  If .rel.plt is the first .rel section, we adjust
5656                  DT_REL to not include it.  */
5657               s = htab->elf.srelplt;
5658               if (s == NULL)
5659                 continue;
5660               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
5661                 continue;
5662               dyn.d_un.d_ptr += s->size;
5663               break;
5664             }
5665
5666           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5667         }
5668
5669       /* Fill in the first entry in the procedure linkage table.  */
5670       if (htab->elf.splt && htab->elf.splt->size > 0)
5671         {
5672           if (bfd_link_pic (info))
5673             {
5674               memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5675                       abed->plt->plt0_entry_size);
5676               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5677                       abed->plt0_pad_byte,
5678                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5679             }
5680           else
5681             {
5682               memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5683                       abed->plt->plt0_entry_size);
5684               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5685                       abed->plt0_pad_byte,
5686                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5687               bfd_put_32 (output_bfd,
5688                           (htab->elf.sgotplt->output_section->vma
5689                            + htab->elf.sgotplt->output_offset
5690                            + 4),
5691                           htab->elf.splt->contents
5692                           + abed->plt->plt0_got1_offset);
5693               bfd_put_32 (output_bfd,
5694                           (htab->elf.sgotplt->output_section->vma
5695                            + htab->elf.sgotplt->output_offset
5696                            + 8),
5697                           htab->elf.splt->contents
5698                           + abed->plt->plt0_got2_offset);
5699
5700               if (abed->is_vxworks)
5701                 {
5702                   Elf_Internal_Rela rel;
5703
5704                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5705                      On IA32 we use REL relocations so the addend goes in
5706                      the PLT directly.  */
5707                   rel.r_offset = (htab->elf.splt->output_section->vma
5708                                   + htab->elf.splt->output_offset
5709                                   + abed->plt->plt0_got1_offset);
5710                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5711                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
5712                                             htab->srelplt2->contents);
5713                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
5714                   rel.r_offset = (htab->elf.splt->output_section->vma
5715                                   + htab->elf.splt->output_offset
5716                                   + abed->plt->plt0_got2_offset);
5717                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5718                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
5719                                             htab->srelplt2->contents +
5720                                             sizeof (Elf32_External_Rel));
5721                 }
5722             }
5723
5724           /* UnixWare sets the entsize of .plt to 4, although that doesn't
5725              really seem like the right value.  */
5726           elf_section_data (htab->elf.splt->output_section)
5727             ->this_hdr.sh_entsize = 4;
5728
5729           /* Correct the .rel.plt.unloaded relocations.  */
5730           if (abed->is_vxworks && !bfd_link_pic (info))
5731             {
5732               int num_plts = (htab->elf.splt->size
5733                               / abed->plt->plt_entry_size) - 1;
5734               unsigned char *p;
5735
5736               p = htab->srelplt2->contents;
5737               if (bfd_link_pic (info))
5738                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5739               else
5740                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5741
5742               for (; num_plts; num_plts--)
5743                 {
5744                   Elf_Internal_Rela rel;
5745                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5746                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5747                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5748                   p += sizeof (Elf32_External_Rel);
5749
5750                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5751                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5752                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5753                   p += sizeof (Elf32_External_Rel);
5754                 }
5755             }
5756         }
5757     }
5758
5759   if (htab->elf.sgotplt)
5760     {
5761       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5762         {
5763           (*_bfd_error_handler)
5764             (_("discarded output section: `%A'"), htab->elf.sgotplt);
5765           return FALSE;
5766         }
5767
5768       /* Fill in the first three entries in the global offset table.  */
5769       if (htab->elf.sgotplt->size > 0)
5770         {
5771           bfd_put_32 (output_bfd,
5772                       (sdyn == NULL ? 0
5773                        : sdyn->output_section->vma + sdyn->output_offset),
5774                       htab->elf.sgotplt->contents);
5775           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5776           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5777         }
5778
5779       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5780     }
5781
5782   /* Adjust .eh_frame for .plt section.  */
5783   if (htab->plt_eh_frame != NULL
5784       && htab->plt_eh_frame->contents != NULL)
5785     {
5786       if (htab->elf.splt != NULL
5787           && htab->elf.splt->size != 0
5788           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5789           && htab->elf.splt->output_section != NULL
5790           && htab->plt_eh_frame->output_section != NULL)
5791         {
5792           bfd_vma plt_start = htab->elf.splt->output_section->vma;
5793           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5794                                    + htab->plt_eh_frame->output_offset
5795                                    + PLT_FDE_START_OFFSET;
5796           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5797                              htab->plt_eh_frame->contents
5798                              + PLT_FDE_START_OFFSET);
5799         }
5800       if (htab->plt_eh_frame->sec_info_type
5801           == SEC_INFO_TYPE_EH_FRAME)
5802         {
5803           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5804                                                  htab->plt_eh_frame,
5805                                                  htab->plt_eh_frame->contents))
5806             return FALSE;
5807         }
5808     }
5809
5810   if (htab->elf.sgot && htab->elf.sgot->size > 0)
5811     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5812
5813   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
5814   htab_traverse (htab->loc_hash_table,
5815                  elf_i386_finish_local_dynamic_symbol,
5816                  info);
5817
5818   /* Fill PLT entries for undefined weak symbols in PIE.  */
5819   if (bfd_link_pie (info))
5820     bfd_hash_traverse (&info->hash->table,
5821                        elf_i386_pie_finish_undefweak_symbol,
5822                        info);
5823
5824   return TRUE;
5825 }
5826
5827 /* Return an array of PLT entry symbol values.  */
5828
5829 static bfd_vma *
5830 elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5831                           asection *relplt)
5832 {
5833   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5834   arelent *p;
5835   long count, i;
5836   bfd_vma *plt_sym_val;
5837   bfd_vma plt_offset;
5838   bfd_byte *plt_contents;
5839   const struct elf_i386_backend_data *bed
5840     = get_elf_i386_backend_data (abfd);
5841   Elf_Internal_Shdr *hdr;
5842
5843   /* Get the .plt section contents.  */
5844   plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5845   if (plt_contents == NULL)
5846     return NULL;
5847   if (!bfd_get_section_contents (abfd, (asection *) plt,
5848                                  plt_contents, 0, plt->size))
5849     {
5850 bad_return:
5851       free (plt_contents);
5852       return NULL;
5853     }
5854
5855   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5856   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5857     goto bad_return;
5858
5859   hdr = &elf_section_data (relplt)->this_hdr;
5860   count = relplt->size / hdr->sh_entsize;
5861
5862   plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5863   if (plt_sym_val == NULL)
5864     goto bad_return;
5865
5866   for (i = 0; i < count; i++)
5867     plt_sym_val[i] = -1;
5868
5869   plt_offset = bed->plt->plt_entry_size;
5870   p = relplt->relocation;
5871   for (i = 0; i < count; i++, p++)
5872     {
5873       long reloc_index;
5874
5875       /* Skip unknown relocation.  PR 17512: file: bc9d6cf5.  */
5876       if (p->howto == NULL)
5877         continue;
5878
5879       if (p->howto->type != R_386_JUMP_SLOT
5880           && p->howto->type != R_386_IRELATIVE)
5881         continue;
5882
5883       reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5884                                      + bed->plt->plt_reloc_offset));
5885       reloc_index /= sizeof (Elf32_External_Rel);
5886       if (reloc_index < count)
5887         plt_sym_val[reloc_index] = plt->vma + plt_offset;
5888
5889       plt_offset += bed->plt->plt_entry_size;
5890
5891       /* PR binutils/18437: Skip extra relocations in the .rel.plt
5892          section.  */
5893       if (plt_offset >= plt->size)
5894         break;
5895     }
5896
5897   free (plt_contents);
5898
5899   return plt_sym_val;
5900 }
5901
5902 /* Similar to _bfd_elf_get_synthetic_symtab.  */
5903
5904 static long
5905 elf_i386_get_synthetic_symtab (bfd *abfd,
5906                                long symcount,
5907                                asymbol **syms,
5908                                long dynsymcount,
5909                                asymbol **dynsyms,
5910                                asymbol **ret)
5911 {
5912   asection *plt = bfd_get_section_by_name (abfd, ".plt");
5913   return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5914                                               dynsymcount, dynsyms, ret,
5915                                               plt,
5916                                               elf_i386_get_plt_sym_val);
5917 }
5918
5919 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5920
5921 static bfd_boolean
5922 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5923 {
5924   if (h->plt.offset != (bfd_vma) -1
5925       && !h->def_regular
5926       && !h->pointer_equality_needed)
5927     return FALSE;
5928
5929   return _bfd_elf_hash_symbol (h);
5930 }
5931
5932 #define TARGET_LITTLE_SYM               i386_elf32_vec
5933 #define TARGET_LITTLE_NAME              "elf32-i386"
5934 #define ELF_ARCH                        bfd_arch_i386
5935 #define ELF_TARGET_ID                   I386_ELF_DATA
5936 #define ELF_MACHINE_CODE                EM_386
5937 #define ELF_MAXPAGESIZE                 0x1000
5938
5939 #define elf_backend_can_gc_sections     1
5940 #define elf_backend_can_refcount        1
5941 #define elf_backend_want_got_plt        1
5942 #define elf_backend_plt_readonly        1
5943 #define elf_backend_want_plt_sym        0
5944 #define elf_backend_got_header_size     12
5945 #define elf_backend_plt_alignment       4
5946 #define elf_backend_extern_protected_data 1
5947 #define elf_backend_caches_rawsize      1
5948
5949 /* Support RELA for objdump of prelink objects.  */
5950 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
5951 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
5952
5953 #define bfd_elf32_mkobject                    elf_i386_mkobject
5954
5955 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
5956 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
5957 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
5958 #define bfd_elf32_bfd_reloc_name_lookup       elf_i386_reloc_name_lookup
5959 #define bfd_elf32_get_synthetic_symtab        elf_i386_get_synthetic_symtab
5960
5961 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
5962 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
5963 #define elf_backend_check_relocs              elf_i386_check_relocs
5964 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
5965 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
5966 #define elf_backend_fake_sections             elf_i386_fake_sections
5967 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
5968 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
5969 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
5970 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
5971 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
5972 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
5973 #define elf_backend_relocate_section          elf_i386_relocate_section
5974 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
5975 #define elf_backend_always_size_sections      elf_i386_always_size_sections
5976 #define elf_backend_omit_section_dynsym \
5977   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5978 #define elf_backend_hash_symbol               elf_i386_hash_symbol
5979 #define elf_backend_fixup_symbol              elf_i386_fixup_symbol
5980
5981 #include "elf32-target.h"
5982
5983 /* FreeBSD support.  */
5984
5985 #undef  TARGET_LITTLE_SYM
5986 #define TARGET_LITTLE_SYM               i386_elf32_fbsd_vec
5987 #undef  TARGET_LITTLE_NAME
5988 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
5989 #undef  ELF_OSABI
5990 #define ELF_OSABI                       ELFOSABI_FREEBSD
5991
5992 /* The kernel recognizes executables as valid only if they carry a
5993    "FreeBSD" label in the ELF header.  So we put this label on all
5994    executables and (for simplicity) also all other object files.  */
5995
5996 static void
5997 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5998 {
5999   _bfd_elf_post_process_headers (abfd, info);
6000
6001 #ifdef OLD_FREEBSD_ABI_LABEL
6002   {
6003     /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
6004     Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
6005     memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
6006   }
6007 #endif
6008 }
6009
6010 #undef  elf_backend_post_process_headers
6011 #define elf_backend_post_process_headers        elf_i386_fbsd_post_process_headers
6012 #undef  elf32_bed
6013 #define elf32_bed                               elf32_i386_fbsd_bed
6014
6015 #undef elf_backend_add_symbol_hook
6016
6017 #include "elf32-target.h"
6018
6019 /* Solaris 2.  */
6020
6021 #undef  TARGET_LITTLE_SYM
6022 #define TARGET_LITTLE_SYM               i386_elf32_sol2_vec
6023 #undef  TARGET_LITTLE_NAME
6024 #define TARGET_LITTLE_NAME              "elf32-i386-sol2"
6025
6026 #undef elf_backend_post_process_headers
6027
6028 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6029    objects won't be recognized.  */
6030 #undef ELF_OSABI
6031
6032 #undef  elf32_bed
6033 #define elf32_bed                       elf32_i386_sol2_bed
6034
6035 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6036    boundary.  */
6037 #undef  elf_backend_static_tls_alignment
6038 #define elf_backend_static_tls_alignment 8
6039
6040 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6041
6042    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6043    File, p.63.  */
6044 #undef  elf_backend_want_plt_sym
6045 #define elf_backend_want_plt_sym        1
6046
6047 #undef  elf_backend_strtab_flags
6048 #define elf_backend_strtab_flags        SHF_STRINGS
6049
6050 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6051    has a type >= SHT_LOOS.  Returns TRUE if these fields were initialised
6052    FALSE otherwise.  ISECTION is the best guess matching section from the
6053    input bfd IBFD, but it might be NULL.  */
6054
6055 static bfd_boolean
6056 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
6057                                                 bfd *obfd ATTRIBUTE_UNUSED,
6058                                                 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
6059                                                 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
6060 {
6061   /* PR 19938: FIXME: Need to add code for setting the sh_info
6062      and sh_link fields of Solaris specific section types.  */
6063   return FALSE;
6064
6065   /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6066      Object File Format, Table 13-9  ELF sh_link and sh_info Interpretation:
6067
6068 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6069
6070      The following values should be set:
6071
6072 Type                 Link                           Info
6073 -----------------------------------------------------------------------------
6074 SHT_SUNW_ancillary   The section header index of    0
6075  [0x6fffffee]        the associated string table.
6076
6077 SHT_SUNW_capinfo     The section header index of    For a dynamic object, the
6078  [0x6ffffff0]        the associated symbol table.   section header index of
6079                                                     the associated
6080                                                     SHT_SUNW_capchain table,
6081                                                     otherwise 0.
6082
6083 SHT_SUNW_symsort     The section header index of    0
6084  [0x6ffffff1]        the associated symbol table.
6085
6086 SHT_SUNW_tlssort     The section header index of    0
6087  [0x6ffffff2]        the associated symbol table.
6088
6089 SHT_SUNW_LDYNSYM     The section header index of    One greater than the
6090  [0x6ffffff3]        the associated string table.   symbol table index of the
6091                      This index is the same string  last local symbol,
6092                      table used by the SHT_DYNSYM   STB_LOCAL. Since
6093                      section.                       SHT_SUNW_LDYNSYM only
6094                                                     contains local symbols,
6095                                                     sh_info is equivalent to
6096                                                     the number of symbols in
6097                                                     the table.
6098
6099 SHT_SUNW_cap         If symbol capabilities exist,  If any capabilities refer
6100  [0x6ffffff5]        the section header index of    to named strings, the
6101                      the associated                 section header index of
6102                      SHT_SUNW_capinfo table,        the associated string
6103                           otherwise 0.              table, otherwise 0.
6104
6105 SHT_SUNW_move        The section header index of    0
6106  [0x6ffffffa]        the associated symbol table.
6107
6108 SHT_SUNW_COMDAT      0                              0
6109  [0x6ffffffb]
6110
6111 SHT_SUNW_syminfo     The section header index of    The section header index
6112  [0x6ffffffc]        the associated symbol table.   of the associated
6113                                                     .dynamic section.
6114
6115 SHT_SUNW_verdef      The section header index of    The number of version
6116  [0x6ffffffd]        the associated string table.   definitions within the
6117                                                     section.
6118
6119 SHT_SUNW_verneed     The section header index of    The number of version
6120  [0x6ffffffe]        the associated string table.   dependencies within the
6121                                                     section.
6122
6123 SHT_SUNW_versym      The section header index of    0
6124  [0x6fffffff]        the associated symbol table.  */
6125 }
6126
6127 #undef  elf_backend_copy_special_section_fields
6128 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6129
6130 #include "elf32-target.h"
6131
6132 /* Intel MCU support.  */
6133
6134 static bfd_boolean
6135 elf32_iamcu_elf_object_p (bfd *abfd)
6136 {
6137   /* Set the right machine number for an IAMCU elf32 file.  */
6138   bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6139   return TRUE;
6140 }
6141
6142 #undef  TARGET_LITTLE_SYM
6143 #define TARGET_LITTLE_SYM               iamcu_elf32_vec
6144 #undef  TARGET_LITTLE_NAME
6145 #define TARGET_LITTLE_NAME              "elf32-iamcu"
6146 #undef  ELF_ARCH
6147 #define ELF_ARCH                        bfd_arch_iamcu
6148
6149 #undef  ELF_MACHINE_CODE
6150 #define ELF_MACHINE_CODE                EM_IAMCU
6151
6152 #undef  ELF_OSABI
6153
6154 #undef  elf32_bed
6155 #define elf32_bed                       elf32_iamcu_bed
6156
6157 #undef  elf_backend_object_p
6158 #define elf_backend_object_p            elf32_iamcu_elf_object_p
6159
6160 #undef  elf_backend_static_tls_alignment
6161
6162 #undef  elf_backend_want_plt_sym
6163 #define elf_backend_want_plt_sym            0
6164
6165 #undef  elf_backend_strtab_flags
6166 #undef  elf_backend_copy_special_section_fields
6167
6168 #include "elf32-target.h"
6169
6170 /* Restore defaults.  */
6171 #undef  ELF_ARCH
6172 #define ELF_ARCH                        bfd_arch_i386
6173 #undef  ELF_MACHINE_CODE
6174 #define ELF_MACHINE_CODE                EM_386
6175
6176 /* Native Client support.  */
6177
6178 #undef  TARGET_LITTLE_SYM
6179 #define TARGET_LITTLE_SYM               i386_elf32_nacl_vec
6180 #undef  TARGET_LITTLE_NAME
6181 #define TARGET_LITTLE_NAME              "elf32-i386-nacl"
6182 #undef  elf32_bed
6183 #define elf32_bed                       elf32_i386_nacl_bed
6184
6185 #undef  ELF_MAXPAGESIZE
6186 #define ELF_MAXPAGESIZE                 0x10000
6187
6188 /* Restore defaults.  */
6189 #undef  ELF_OSABI
6190 #undef  elf_backend_want_plt_sym
6191 #define elf_backend_want_plt_sym        0
6192 #undef  elf_backend_post_process_headers
6193 #undef  elf_backend_static_tls_alignment
6194
6195 /* NaCl uses substantially different PLT entries for the same effects.  */
6196
6197 #undef  elf_backend_plt_alignment
6198 #define elf_backend_plt_alignment       5
6199 #define NACL_PLT_ENTRY_SIZE             64
6200 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
6201
6202 static const bfd_byte elf_i386_nacl_plt0_entry[] =
6203   {
6204     0xff, 0x35,                   /* pushl contents of address */
6205     0, 0, 0, 0,                   /* replaced with address of .got + 4.  */
6206     0x8b, 0x0d,                   /* movl contents of address, %ecx */
6207     0, 0, 0, 0,                   /* replaced with address of .got + 8.  */
6208     0x83, 0xe1, NACLMASK,         /* andl $NACLMASK, %ecx */
6209     0xff, 0xe1                    /* jmp *%ecx */
6210   };
6211
6212 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6213   {
6214     0x8b, 0x0d,                         /* movl contents of address, %ecx */
6215     0, 0, 0, 0,                         /* replaced with GOT slot address.  */
6216     0x83, 0xe1, NACLMASK,               /* andl $NACLMASK, %ecx */
6217     0xff, 0xe1,                         /* jmp *%ecx */
6218
6219     /* Pad to the next 32-byte boundary with nop instructions.  */
6220     0x90,
6221     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6222     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6223
6224     /* Lazy GOT entries point here (32-byte aligned).  */
6225     0x68,                              /* pushl immediate */
6226     0, 0, 0, 0,                        /* replaced with reloc offset.  */
6227     0xe9,                              /* jmp relative */
6228     0, 0, 0, 0,                        /* replaced with offset to .plt.  */
6229
6230     /* Pad to the next 32-byte boundary with nop instructions.  */
6231     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6232     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6233     0x90, 0x90
6234   };
6235
6236 static const bfd_byte
6237 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6238   {
6239     0xff, 0x73, 0x04,           /* pushl 4(%ebx) */
6240     0x8b, 0x4b, 0x08,           /* mov 0x8(%ebx), %ecx */
6241     0x83, 0xe1, 0xe0,           /* and $NACLMASK, %ecx */
6242     0xff, 0xe1,                 /* jmp *%ecx */
6243
6244     /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6245        so pad to that size with nop instructions.  */
6246     0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6247   };
6248
6249 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6250   {
6251     0x8b, 0x8b,          /* movl offset(%ebx), %ecx */
6252     0, 0, 0, 0,          /* replaced with offset of this symbol in .got.  */
6253     0x83, 0xe1, 0xe0,    /* andl $NACLMASK, %ecx */
6254     0xff, 0xe1,          /* jmp *%ecx */
6255
6256     /* Pad to the next 32-byte boundary with nop instructions.  */
6257     0x90,
6258     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6259     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6260
6261     /* Lazy GOT entries point here (32-byte aligned).  */
6262     0x68,                /* pushl immediate */
6263     0, 0, 0, 0,          /* replaced with offset into relocation table.  */
6264     0xe9,                /* jmp relative */
6265     0, 0, 0, 0,          /* replaced with offset to start of .plt.  */
6266
6267     /* Pad to the next 32-byte boundary with nop instructions.  */
6268     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6269     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6270     0x90, 0x90
6271   };
6272
6273 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6274   {
6275 #if (PLT_CIE_LENGTH != 20                               \
6276      || PLT_FDE_LENGTH != 36                            \
6277      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
6278      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6279 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6280 #endif
6281     PLT_CIE_LENGTH, 0, 0, 0,            /* CIE length */
6282     0, 0, 0, 0,                         /* CIE ID */
6283     1,                                  /* CIE version */
6284     'z', 'R', 0,                        /* Augmentation string */
6285     1,                                  /* Code alignment factor */
6286     0x7c,                               /* Data alignment factor: -4 */
6287     8,                                  /* Return address column */
6288     1,                                  /* Augmentation size */
6289     DW_EH_PE_pcrel | DW_EH_PE_sdata4,   /* FDE encoding */
6290     DW_CFA_def_cfa, 4, 4,               /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6291     DW_CFA_offset + 8, 1,               /* DW_CFA_offset: r8 (eip) at cfa-4 */
6292     DW_CFA_nop, DW_CFA_nop,
6293
6294     PLT_FDE_LENGTH, 0, 0, 0,     /* FDE length */
6295     PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6296     0, 0, 0, 0,                  /* R_386_PC32 .plt goes here */
6297     0, 0, 0, 0,                  /* .plt size goes here */
6298     0,                           /* Augmentation size */
6299     DW_CFA_def_cfa_offset, 8,    /* DW_CFA_def_cfa_offset: 8 */
6300     DW_CFA_advance_loc + 6,      /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6301     DW_CFA_def_cfa_offset, 12,   /* DW_CFA_def_cfa_offset: 12 */
6302     DW_CFA_advance_loc + 58,     /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6303     DW_CFA_def_cfa_expression,   /* DW_CFA_def_cfa_expression */
6304     13,                          /* Block length */
6305     DW_OP_breg4, 4,              /* DW_OP_breg4 (esp): 4 */
6306     DW_OP_breg8, 0,              /* DW_OP_breg8 (eip): 0 */
6307     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6308     DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6309     DW_CFA_nop, DW_CFA_nop
6310   };
6311
6312 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6313   {
6314     elf_i386_nacl_plt0_entry,           /* plt0_entry */
6315     sizeof (elf_i386_nacl_plt0_entry),  /* plt0_entry_size */
6316     2,                                  /* plt0_got1_offset */
6317     8,                                  /* plt0_got2_offset */
6318     elf_i386_nacl_plt_entry,            /* plt_entry */
6319     NACL_PLT_ENTRY_SIZE,                /* plt_entry_size */
6320     2,                                  /* plt_got_offset */
6321     33,                                 /* plt_reloc_offset */
6322     38,                                 /* plt_plt_offset */
6323     32,                                 /* plt_lazy_offset */
6324     elf_i386_nacl_pic_plt0_entry,       /* pic_plt0_entry */
6325     elf_i386_nacl_pic_plt_entry,        /* pic_plt_entry */
6326     elf_i386_nacl_eh_frame_plt,         /* eh_frame_plt */
6327     sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6328   };
6329
6330 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6331   {
6332     &elf_i386_nacl_plt,                      /* plt */
6333     0x90,                               /* plt0_pad_byte: nop insn */
6334     0,                                  /* is_vxworks */
6335   };
6336
6337 static bfd_boolean
6338 elf32_i386_nacl_elf_object_p (bfd *abfd)
6339 {
6340   /* Set the right machine number for a NaCl i386 ELF32 file.  */
6341   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6342   return TRUE;
6343 }
6344
6345 #undef  elf_backend_arch_data
6346 #define elf_backend_arch_data   &elf_i386_nacl_arch_bed
6347
6348 #undef  elf_backend_object_p
6349 #define elf_backend_object_p                    elf32_i386_nacl_elf_object_p
6350 #undef  elf_backend_modify_segment_map
6351 #define elf_backend_modify_segment_map          nacl_modify_segment_map
6352 #undef  elf_backend_modify_program_headers
6353 #define elf_backend_modify_program_headers      nacl_modify_program_headers
6354 #undef  elf_backend_final_write_processing
6355 #define elf_backend_final_write_processing      nacl_final_write_processing
6356
6357 #include "elf32-target.h"
6358
6359 /* Restore defaults.  */
6360 #undef  elf_backend_object_p
6361 #undef  elf_backend_modify_segment_map
6362 #undef  elf_backend_modify_program_headers
6363 #undef  elf_backend_final_write_processing
6364
6365 /* VxWorks support.  */
6366
6367 #undef  TARGET_LITTLE_SYM
6368 #define TARGET_LITTLE_SYM               i386_elf32_vxworks_vec
6369 #undef  TARGET_LITTLE_NAME
6370 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
6371 #undef  ELF_OSABI
6372 #undef  elf_backend_plt_alignment
6373 #define elf_backend_plt_alignment       4
6374
6375 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6376   {
6377     &elf_i386_plt,                      /* plt */
6378     0x90,                               /* plt0_pad_byte */
6379     1,                                  /* is_vxworks */
6380   };
6381
6382 #undef  elf_backend_arch_data
6383 #define elf_backend_arch_data   &elf_i386_vxworks_arch_bed
6384
6385 #undef elf_backend_relocs_compatible
6386 #undef elf_backend_add_symbol_hook
6387 #define elf_backend_add_symbol_hook \
6388   elf_vxworks_add_symbol_hook
6389 #undef elf_backend_link_output_symbol_hook
6390 #define elf_backend_link_output_symbol_hook \
6391   elf_vxworks_link_output_symbol_hook
6392 #undef elf_backend_emit_relocs
6393 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
6394 #undef elf_backend_final_write_processing
6395 #define elf_backend_final_write_processing \
6396   elf_vxworks_final_write_processing
6397 #undef elf_backend_static_tls_alignment
6398
6399 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6400    define it.  */
6401 #undef elf_backend_want_plt_sym
6402 #define elf_backend_want_plt_sym        1
6403
6404 #undef  elf32_bed
6405 #define elf32_bed                               elf32_i386_vxworks_bed
6406
6407 #include "elf32-target.h"