bfd/elf32-i386.c

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