bfd/elf32-i386.c

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