bfd/elf32-i386.c

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