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