bfd/elf32-i386.c

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