bfd/elf32-i386.c

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