bfd/elf32-i386.c

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