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