bfd/elf32-i386.c

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