bfd/elf32-i386.c

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