bfd/elf32-i386.c

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