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