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           /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1521              it here if it is defined in a non-shared object.  */
1522           if (h->type == STT_GNU_IFUNC
1523               && h->def_regular)
1524             {
1525               /* It is referenced by a non-shared object. */
1526               h->ref_regular = 1;
1527               h->needs_plt = 1;
1528
1529               /* STT_GNU_IFUNC symbol must go through PLT.  */
1530               h->plt.refcount += 1;
1531
1532               /* STT_GNU_IFUNC needs dynamic sections.  */
1533               if (htab->elf.dynobj == NULL)
1534                 htab->elf.dynobj = abfd;
1535
1536               switch (r_type)
1537                 {
1538                 default:
1539                   if (h->root.root.string)
1540                     name = h->root.root.string;
1541                   else
1542                     name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1543                                              NULL);
1544                   (*_bfd_error_handler)
1545                     (_("%B: relocation %s against STT_GNU_IFUNC "
1546                        "symbol `%s' isn't handled by %s"), abfd,
1547                      elf_howto_table[r_type].name,
1548                      name, __FUNCTION__);
1549                   bfd_set_error (bfd_error_bad_value);
1550                   return FALSE;
1551
1552                 case R_386_32:
1553                   h->non_got_ref = 1;
1554                   h->pointer_equality_needed = 1;
1555                   if (info->shared)
1556                     {
1557                       /* We must copy these reloc types into the
1558                          output file.  Create a reloc section in
1559                          dynobj and make room for this reloc.  */
1560                       sreloc = _bfd_elf_create_ifunc_dyn_reloc
1561                         (abfd, info, sec, sreloc,
1562                          &((struct elf_i386_link_hash_entry *) h)->dyn_relocs);
1563                       if (sreloc == NULL)
1564                         return FALSE;
1565                     }
1566                   break;
1567
1568                 case R_386_PC32:
1569                   h->non_got_ref = 1;
1570                   break;
1571
1572                 case R_386_PLT32:
1573                   break;
1574
1575                 case R_386_GOT32:
1576                 case R_386_GOTOFF:
1577                   h->got.refcount += 1;
1578                   if (htab->elf.sgot == NULL
1579                       && !_bfd_elf_create_got_section (htab->elf.dynobj,
1580                                                        info))
1581                     return FALSE;
1582                   break;
1583                 }
1584
1585               continue;
1586             }
1587         }
1588
1589       if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1590                                      symtab_hdr, sym_hashes,
1591                                      &r_type, GOT_UNKNOWN,
1592                                      rel, rel_end, h, r_symndx))
1593         return FALSE;
1594
1595       switch (r_type)
1596         {
1597         case R_386_TLS_LDM:
1598           htab->tls_ldm_got.refcount += 1;
1599           goto create_got;
1600
1601         case R_386_PLT32:
1602           /* This symbol requires a procedure linkage table entry.  We
1603              actually build the entry in adjust_dynamic_symbol,
1604              because this might be a case of linking PIC code which is
1605              never referenced by a dynamic object, in which case we
1606              don't need to generate a procedure linkage table entry
1607              after all.  */
1608
1609           /* If this is a local symbol, we resolve it directly without
1610              creating a procedure linkage table entry.  */
1611           if (h == NULL)
1612             continue;
1613
1614           h->needs_plt = 1;
1615           h->plt.refcount += 1;
1616           break;
1617
1618         case R_386_TLS_IE_32:
1619         case R_386_TLS_IE:
1620         case R_386_TLS_GOTIE:
1621           if (!info->executable)
1622             info->flags |= DF_STATIC_TLS;
1623           /* Fall through */
1624
1625         case R_386_GOT32:
1626         case R_386_TLS_GD:
1627         case R_386_TLS_GOTDESC:
1628         case R_386_TLS_DESC_CALL:
1629           /* This symbol requires a global offset table entry.  */
1630           {
1631             int tls_type, old_tls_type;
1632
1633             switch (r_type)
1634               {
1635               default:
1636               case R_386_GOT32: tls_type = GOT_NORMAL; break;
1637               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1638               case R_386_TLS_GOTDESC:
1639               case R_386_TLS_DESC_CALL:
1640                 tls_type = GOT_TLS_GDESC; break;
1641               case R_386_TLS_IE_32:
1642                 if (ELF32_R_TYPE (rel->r_info) == r_type)
1643                   tls_type = GOT_TLS_IE_NEG;
1644                 else
1645                   /* If this is a GD->IE transition, we may use either of
1646                      R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  */
1647                   tls_type = GOT_TLS_IE;
1648                 break;
1649               case R_386_TLS_IE:
1650               case R_386_TLS_GOTIE:
1651                 tls_type = GOT_TLS_IE_POS; break;
1652               }
1653
1654             if (h != NULL)
1655               {
1656                 h->got.refcount += 1;
1657                 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1658               }
1659             else
1660               {
1661                 bfd_signed_vma *local_got_refcounts;
1662
1663                 /* This is a global offset table entry for a local symbol.  */
1664                 local_got_refcounts = elf_local_got_refcounts (abfd);
1665                 if (local_got_refcounts == NULL)
1666                   {
1667                     bfd_size_type size;
1668
1669                     size = symtab_hdr->sh_info;
1670                     size *= (sizeof (bfd_signed_vma)
1671                              + sizeof (bfd_vma) + sizeof(char));
1672                     local_got_refcounts = (bfd_signed_vma *)
1673                         bfd_zalloc (abfd, size);
1674                     if (local_got_refcounts == NULL)
1675                       return FALSE;
1676                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1677                     elf_i386_local_tlsdesc_gotent (abfd)
1678                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1679                     elf_i386_local_got_tls_type (abfd)
1680                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1681                   }
1682                 local_got_refcounts[r_symndx] += 1;
1683                 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1684               }
1685
1686             if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1687               tls_type |= old_tls_type;
1688             /* If a TLS symbol is accessed using IE at least once,
1689                there is no point to use dynamic model for it.  */
1690             else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1691                      && (! GOT_TLS_GD_ANY_P (old_tls_type)
1692                          || (tls_type & GOT_TLS_IE) == 0))
1693               {
1694                 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1695                   tls_type = old_tls_type;
1696                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1697                          && GOT_TLS_GD_ANY_P (tls_type))
1698                   tls_type |= old_tls_type;
1699                 else
1700                   {
1701                     if (h)
1702                       name = h->root.root.string;
1703                     else
1704                       name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1705                                              NULL);
1706                     (*_bfd_error_handler)
1707                       (_("%B: `%s' accessed both as normal and "
1708                          "thread local symbol"),
1709                        abfd, name);
1710                     return FALSE;
1711                   }
1712               }
1713
1714             if (old_tls_type != tls_type)
1715               {
1716                 if (h != NULL)
1717                   elf_i386_hash_entry (h)->tls_type = tls_type;
1718                 else
1719                   elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1720               }
1721           }
1722           /* Fall through */
1723
1724         case R_386_GOTOFF:
1725         case R_386_GOTPC:
1726         create_got:
1727           if (htab->elf.sgot == NULL)
1728             {
1729               if (htab->elf.dynobj == NULL)
1730                 htab->elf.dynobj = abfd;
1731               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1732                 return FALSE;
1733             }
1734           if (r_type != R_386_TLS_IE)
1735             break;
1736           /* Fall through */
1737
1738         case R_386_TLS_LE_32:
1739         case R_386_TLS_LE:
1740           if (info->executable)
1741             break;
1742           info->flags |= DF_STATIC_TLS;
1743           /* Fall through */
1744
1745         case R_386_32:
1746         case R_386_PC32:
1747           if (h != NULL && info->executable)
1748             {
1749               /* If this reloc is in a read-only section, we might
1750                  need a copy reloc.  We can't check reliably at this
1751                  stage whether the section is read-only, as input
1752                  sections have not yet been mapped to output sections.
1753                  Tentatively set the flag for now, and correct in
1754                  adjust_dynamic_symbol.  */
1755               h->non_got_ref = 1;
1756
1757               /* We may need a .plt entry if the function this reloc
1758                  refers to is in a shared lib.  */
1759               h->plt.refcount += 1;
1760               if (r_type != R_386_PC32)
1761                 h->pointer_equality_needed = 1;
1762             }
1763
1764           /* If we are creating a shared library, and this is a reloc
1765              against a global symbol, or a non PC relative reloc
1766              against a local symbol, then we need to copy the reloc
1767              into the shared library.  However, if we are linking with
1768              -Bsymbolic, we do not need to copy a reloc against a
1769              global symbol which is defined in an object we are
1770              including in the link (i.e., DEF_REGULAR is set).  At
1771              this point we have not seen all the input files, so it is
1772              possible that DEF_REGULAR is not set now but will be set
1773              later (it is never cleared).  In case of a weak definition,
1774              DEF_REGULAR may be cleared later by a strong definition in
1775              a shared library.  We account for that possibility below by
1776              storing information in the relocs_copied field of the hash
1777              table entry.  A similar situation occurs when creating
1778              shared libraries and symbol visibility changes render the
1779              symbol local.
1780
1781              If on the other hand, we are creating an executable, we
1782              may need to keep relocations for symbols satisfied by a
1783              dynamic library if we manage to avoid copy relocs for the
1784              symbol.  */
1785           if ((info->shared
1786                && (sec->flags & SEC_ALLOC) != 0
1787                && (r_type != R_386_PC32
1788                    || (h != NULL
1789                        && (! SYMBOLIC_BIND (info, h)
1790                            || h->root.type == bfd_link_hash_defweak
1791                            || !h->def_regular))))
1792               || (ELIMINATE_COPY_RELOCS
1793                   && !info->shared
1794                   && (sec->flags & SEC_ALLOC) != 0
1795                   && h != NULL
1796                   && (h->root.type == bfd_link_hash_defweak
1797                       || !h->def_regular)))
1798             {
1799               struct elf_dyn_relocs *p;
1800               struct elf_dyn_relocs **head;
1801
1802               /* We must copy these reloc types into the output file.
1803                  Create a reloc section in dynobj and make room for
1804                  this reloc.  */
1805               if (sreloc == NULL)
1806                 {
1807                   if (htab->elf.dynobj == NULL)
1808                     htab->elf.dynobj = abfd;
1809
1810                   sreloc = _bfd_elf_make_dynamic_reloc_section
1811                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1812
1813                   if (sreloc == NULL)
1814                     return FALSE;
1815                 }
1816
1817               /* If this is a global symbol, we count the number of
1818                  relocations we need for this symbol.  */
1819               if (h != NULL)
1820                 {
1821                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1822                 }
1823               else
1824                 {
1825                   /* Track dynamic relocs needed for local syms too.
1826                      We really need local syms available to do this
1827                      easily.  Oh well.  */
1828                   void **vpp;
1829                   asection *s;
1830
1831                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1832                                                 abfd, r_symndx);
1833                   if (isym == NULL)
1834                     return FALSE;
1835
1836                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1837                   if (s == NULL)
1838                     s = sec;
1839
1840                   vpp = &elf_section_data (s)->local_dynrel;
1841                   head = (struct elf_dyn_relocs **)vpp;
1842                 }
1843
1844               p = *head;
1845               if (p == NULL || p->sec != sec)
1846                 {
1847                   bfd_size_type amt = sizeof *p;
1848                   p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1849                                                            amt);
1850                   if (p == NULL)
1851                     return FALSE;
1852                   p->next = *head;
1853                   *head = p;
1854                   p->sec = sec;
1855                   p->count = 0;
1856                   p->pc_count = 0;
1857                 }
1858
1859               p->count += 1;
1860               if (r_type == R_386_PC32)
1861                 p->pc_count += 1;
1862             }
1863           break;
1864
1865           /* This relocation describes the C++ object vtable hierarchy.
1866              Reconstruct it for later use during GC.  */
1867         case R_386_GNU_VTINHERIT:
1868           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1869             return FALSE;
1870           break;
1871
1872           /* This relocation describes which C++ vtable entries are actually
1873              used.  Record for later use during GC.  */
1874         case R_386_GNU_VTENTRY:
1875           BFD_ASSERT (h != NULL);
1876           if (h != NULL
1877               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1878             return FALSE;
1879           break;
1880
1881         default:
1882           break;
1883         }
1884     }
1885
1886   return TRUE;
1887 }
1888
1889 /* Return the section that should be marked against GC for a given
1890    relocation.  */
1891
1892 static asection *
1893 elf_i386_gc_mark_hook (asection *sec,
1894                        struct bfd_link_info *info,
1895                        Elf_Internal_Rela *rel,
1896                        struct elf_link_hash_entry *h,
1897                        Elf_Internal_Sym *sym)
1898 {
1899   if (h != NULL)
1900     switch (ELF32_R_TYPE (rel->r_info))
1901       {
1902       case R_386_GNU_VTINHERIT:
1903       case R_386_GNU_VTENTRY:
1904         return NULL;
1905       }
1906
1907   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1908 }
1909
1910 /* Update the got entry reference counts for the section being removed.  */
1911
1912 static bfd_boolean
1913 elf_i386_gc_sweep_hook (bfd *abfd,
1914                         struct bfd_link_info *info,
1915                         asection *sec,
1916                         const Elf_Internal_Rela *relocs)
1917 {
1918   struct elf_i386_link_hash_table *htab;
1919   Elf_Internal_Shdr *symtab_hdr;
1920   struct elf_link_hash_entry **sym_hashes;
1921   bfd_signed_vma *local_got_refcounts;
1922   const Elf_Internal_Rela *rel, *relend;
1923
1924   if (info->relocatable)
1925     return TRUE;
1926
1927   htab = elf_i386_hash_table (info);
1928   if (htab == NULL)
1929     return FALSE;
1930
1931   elf_section_data (sec)->local_dynrel = NULL;
1932
1933   symtab_hdr = &elf_symtab_hdr (abfd);
1934   sym_hashes = elf_sym_hashes (abfd);
1935   local_got_refcounts = elf_local_got_refcounts (abfd);
1936
1937   relend = relocs + sec->reloc_count;
1938   for (rel = relocs; rel < relend; rel++)
1939     {
1940       unsigned long r_symndx;
1941       unsigned int r_type;
1942       struct elf_link_hash_entry *h = NULL;
1943
1944       r_symndx = ELF32_R_SYM (rel->r_info);
1945       if (r_symndx >= symtab_hdr->sh_info)
1946         {
1947           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1948           while (h->root.type == bfd_link_hash_indirect
1949                  || h->root.type == bfd_link_hash_warning)
1950             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1951         }
1952       else
1953         {
1954           /* A local symbol.  */
1955           Elf_Internal_Sym *isym;
1956
1957           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1958                                         abfd, r_symndx);
1959
1960           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1961           if (isym != NULL
1962               && ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1963             {
1964               h = elf_i386_get_local_sym_hash (htab, abfd, rel, FALSE);
1965               if (h == NULL)
1966                 abort ();
1967             }
1968         }
1969
1970       if (h)
1971         {
1972           struct elf_i386_link_hash_entry *eh;
1973           struct elf_dyn_relocs **pp;
1974           struct elf_dyn_relocs *p;
1975
1976           eh = (struct elf_i386_link_hash_entry *) h;
1977           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1978             if (p->sec == sec)
1979               {
1980                 /* Everything must go for SEC.  */
1981                 *pp = p->next;
1982                 break;
1983               }
1984         }
1985
1986       r_type = ELF32_R_TYPE (rel->r_info);
1987       if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1988                                      symtab_hdr, sym_hashes,
1989                                      &r_type, GOT_UNKNOWN,
1990                                      rel, relend, h, r_symndx))
1991         return FALSE;
1992
1993       switch (r_type)
1994         {
1995         case R_386_TLS_LDM:
1996           if (htab->tls_ldm_got.refcount > 0)
1997             htab->tls_ldm_got.refcount -= 1;
1998           break;
1999
2000         case R_386_TLS_GD:
2001         case R_386_TLS_GOTDESC:
2002         case R_386_TLS_DESC_CALL:
2003         case R_386_TLS_IE_32:
2004         case R_386_TLS_IE:
2005         case R_386_TLS_GOTIE:
2006         case R_386_GOT32:
2007           if (h != NULL)
2008             {
2009               if (h->got.refcount > 0)
2010                 h->got.refcount -= 1;
2011               if (h->type == STT_GNU_IFUNC)
2012                 {
2013                   if (h->plt.refcount > 0)
2014                     h->plt.refcount -= 1;
2015                 }
2016             }
2017           else if (local_got_refcounts != NULL)
2018             {
2019               if (local_got_refcounts[r_symndx] > 0)
2020                 local_got_refcounts[r_symndx] -= 1;
2021             }
2022           break;
2023
2024         case R_386_32:
2025         case R_386_PC32:
2026           if (info->shared
2027               && (h == NULL || h->type != STT_GNU_IFUNC))
2028             break;
2029           /* Fall through */
2030
2031         case R_386_PLT32:
2032           if (h != NULL)
2033             {
2034               if (h->plt.refcount > 0)
2035                 h->plt.refcount -= 1;
2036             }
2037           break;
2038
2039         case R_386_GOTOFF:
2040           if (h != NULL && h->type == STT_GNU_IFUNC)
2041             {
2042               if (h->got.refcount > 0)
2043                 h->got.refcount -= 1;
2044               if (h->plt.refcount > 0)
2045                 h->plt.refcount -= 1;
2046             }
2047           break;
2048
2049         default:
2050           break;
2051         }
2052     }
2053
2054   return TRUE;
2055 }
2056
2057 /* Adjust a symbol defined by a dynamic object and referenced by a
2058    regular object.  The current definition is in some section of the
2059    dynamic object, but we're not including those sections.  We have to
2060    change the definition to something the rest of the link can
2061    understand.  */
2062
2063 static bfd_boolean
2064 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2065                                 struct elf_link_hash_entry *h)
2066 {
2067   struct elf_i386_link_hash_table *htab;
2068   asection *s;
2069
2070   /* STT_GNU_IFUNC symbol must go through PLT. */
2071   if (h->type == STT_GNU_IFUNC)
2072     {
2073       if (h->plt.refcount <= 0)
2074         {
2075           h->plt.offset = (bfd_vma) -1;
2076           h->needs_plt = 0;
2077         }
2078       return TRUE;
2079     }
2080
2081   /* If this is a function, put it in the procedure linkage table.  We
2082      will fill in the contents of the procedure linkage table later,
2083      when we know the address of the .got section.  */
2084   if (h->type == STT_FUNC
2085       || h->needs_plt)
2086     {
2087       if (h->plt.refcount <= 0
2088           || SYMBOL_CALLS_LOCAL (info, h)
2089           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2090               && h->root.type == bfd_link_hash_undefweak))
2091         {
2092           /* This case can occur if we saw a PLT32 reloc in an input
2093              file, but the symbol was never referred to by a dynamic
2094              object, or if all references were garbage collected.  In
2095              such a case, we don't actually need to build a procedure
2096              linkage table, and we can just do a PC32 reloc instead.  */
2097           h->plt.offset = (bfd_vma) -1;
2098           h->needs_plt = 0;
2099         }
2100
2101       return TRUE;
2102     }
2103   else
2104     /* It's possible that we incorrectly decided a .plt reloc was
2105        needed for an R_386_PC32 reloc to a non-function sym in
2106        check_relocs.  We can't decide accurately between function and
2107        non-function syms in check-relocs;  Objects loaded later in
2108        the link may change h->type.  So fix it now.  */
2109     h->plt.offset = (bfd_vma) -1;
2110
2111   /* If this is a weak symbol, and there is a real definition, the
2112      processor independent code will have arranged for us to see the
2113      real definition first, and we can just use the same value.  */
2114   if (h->u.weakdef != NULL)
2115     {
2116       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2117                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2118       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2119       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2120       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2121         h->non_got_ref = h->u.weakdef->non_got_ref;
2122       return TRUE;
2123     }
2124
2125   /* This is a reference to a symbol defined by a dynamic object which
2126      is not a function.  */
2127
2128   /* If we are creating a shared library, we must presume that the
2129      only references to the symbol are via the global offset table.
2130      For such cases we need not do anything here; the relocations will
2131      be handled correctly by relocate_section.  */
2132   if (info->shared)
2133     return TRUE;
2134
2135   /* If there are no references to this symbol that do not use the
2136      GOT, we don't need to generate a copy reloc.  */
2137   if (!h->non_got_ref)
2138     return TRUE;
2139
2140   /* If -z nocopyreloc was given, we won't generate them either.  */
2141   if (info->nocopyreloc)
2142     {
2143       h->non_got_ref = 0;
2144       return TRUE;
2145     }
2146
2147   htab = elf_i386_hash_table (info);
2148   if (htab == NULL)
2149     return FALSE;
2150
2151   /* If there aren't any dynamic relocs in read-only sections, then
2152      we can keep the dynamic relocs and avoid the copy reloc.  This
2153      doesn't work on VxWorks, where we can not have dynamic relocations
2154      (other than copy and jump slot relocations) in an executable.  */
2155   if (ELIMINATE_COPY_RELOCS
2156       && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2157     {
2158       struct elf_i386_link_hash_entry * eh;
2159       struct elf_dyn_relocs *p;
2160
2161       eh = (struct elf_i386_link_hash_entry *) h;
2162       for (p = eh->dyn_relocs; p != NULL; p = p->next)
2163         {
2164           s = p->sec->output_section;
2165           if (s != NULL && (s->flags & SEC_READONLY) != 0)
2166             break;
2167         }
2168
2169       if (p == NULL)
2170         {
2171           h->non_got_ref = 0;
2172           return TRUE;
2173         }
2174     }
2175
2176   /* We must allocate the symbol in our .dynbss section, which will
2177      become part of the .bss section of the executable.  There will be
2178      an entry for this symbol in the .dynsym section.  The dynamic
2179      object will contain position independent code, so all references
2180      from the dynamic object to this symbol will go through the global
2181      offset table.  The dynamic linker will use the .dynsym entry to
2182      determine the address it must put in the global offset table, so
2183      both the dynamic object and the regular object will refer to the
2184      same memory location for the variable.  */
2185
2186   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2187      copy the initial value out of the dynamic object and into the
2188      runtime process image.  */
2189   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2190     {
2191       htab->srelbss->size += sizeof (Elf32_External_Rel);
2192       h->needs_copy = 1;
2193     }
2194
2195   s = htab->sdynbss;
2196
2197   return _bfd_elf_adjust_dynamic_copy (h, s);
2198 }
2199
2200 /* Allocate space in .plt, .got and associated reloc sections for
2201    dynamic relocs.  */
2202
2203 static bfd_boolean
2204 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2205 {
2206   struct bfd_link_info *info;
2207   struct elf_i386_link_hash_table *htab;
2208   struct elf_i386_link_hash_entry *eh;
2209   struct elf_dyn_relocs *p;
2210   unsigned plt_entry_size;
2211
2212   if (h->root.type == bfd_link_hash_indirect)
2213     return TRUE;
2214
2215   eh = (struct elf_i386_link_hash_entry *) h;
2216
2217   info = (struct bfd_link_info *) inf;
2218   htab = elf_i386_hash_table (info);
2219   if (htab == NULL)
2220     return FALSE;
2221
2222   plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2223
2224   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2225      here if it is defined and referenced in a non-shared object.  */
2226   if (h->type == STT_GNU_IFUNC
2227       && h->def_regular)
2228     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2229                                                plt_entry_size, 4);
2230   else if (htab->elf.dynamic_sections_created
2231            && h->plt.refcount > 0)
2232     {
2233       /* Make sure this symbol is output as a dynamic symbol.
2234          Undefined weak syms won't yet be marked as dynamic.  */
2235       if (h->dynindx == -1
2236           && !h->forced_local)
2237         {
2238           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2239             return FALSE;
2240         }
2241
2242       if (info->shared
2243           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2244         {
2245           asection *s = htab->elf.splt;
2246
2247           /* If this is the first .plt entry, make room for the special
2248              first entry.  */
2249           if (s->size == 0)
2250             s->size += plt_entry_size;
2251
2252           h->plt.offset = s->size;
2253
2254           /* If this symbol is not defined in a regular file, and we are
2255              not generating a shared library, then set the symbol to this
2256              location in the .plt.  This is required to make function
2257              pointers compare as equal between the normal executable and
2258              the shared library.  */
2259           if (! info->shared
2260               && !h->def_regular)
2261             {
2262               h->root.u.def.section = s;
2263               h->root.u.def.value = h->plt.offset;
2264             }
2265
2266           /* Make room for this entry.  */
2267           s->size += plt_entry_size;
2268
2269           /* We also need to make an entry in the .got.plt section, which
2270              will be placed in the .got section by the linker script.  */
2271           htab->elf.sgotplt->size += 4;
2272
2273           /* We also need to make an entry in the .rel.plt section.  */
2274           htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2275           htab->elf.srelplt->reloc_count++;
2276
2277           if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2278               && !info->shared)
2279             {
2280               /* VxWorks has a second set of relocations for each PLT entry
2281                  in executables.  They go in a separate relocation section,
2282                  which is processed by the kernel loader.  */
2283
2284               /* There are two relocations for the initial PLT entry: an
2285                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2286                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
2287
2288               if (h->plt.offset == plt_entry_size)
2289                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2290
2291               /* There are two extra relocations for each subsequent PLT entry:
2292                  an R_386_32 relocation for the GOT entry, and an R_386_32
2293                  relocation for the PLT entry.  */
2294
2295               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2296             }
2297         }
2298       else
2299         {
2300           h->plt.offset = (bfd_vma) -1;
2301           h->needs_plt = 0;
2302         }
2303     }
2304   else
2305     {
2306       h->plt.offset = (bfd_vma) -1;
2307       h->needs_plt = 0;
2308     }
2309
2310   eh->tlsdesc_got = (bfd_vma) -1;
2311
2312   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2313      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
2314   if (h->got.refcount > 0
2315       && info->executable
2316       && h->dynindx == -1
2317       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2318     h->got.offset = (bfd_vma) -1;
2319   else if (h->got.refcount > 0)
2320     {
2321       asection *s;
2322       bfd_boolean dyn;
2323       int tls_type = elf_i386_hash_entry(h)->tls_type;
2324
2325       /* Make sure this symbol is output as a dynamic symbol.
2326          Undefined weak syms won't yet be marked as dynamic.  */
2327       if (h->dynindx == -1
2328           && !h->forced_local)
2329         {
2330           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2331             return FALSE;
2332         }
2333
2334       s = htab->elf.sgot;
2335       if (GOT_TLS_GDESC_P (tls_type))
2336         {
2337           eh->tlsdesc_got = htab->elf.sgotplt->size
2338             - elf_i386_compute_jump_table_size (htab);
2339           htab->elf.sgotplt->size += 8;
2340           h->got.offset = (bfd_vma) -2;
2341         }
2342       if (! GOT_TLS_GDESC_P (tls_type)
2343           || GOT_TLS_GD_P (tls_type))
2344         {
2345           h->got.offset = s->size;
2346           s->size += 4;
2347           /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
2348           if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2349             s->size += 4;
2350         }
2351       dyn = htab->elf.dynamic_sections_created;
2352       /* R_386_TLS_IE_32 needs one dynamic relocation,
2353          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2354          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2355          need two), R_386_TLS_GD needs one if local symbol and two if
2356          global.  */
2357       if (tls_type == GOT_TLS_IE_BOTH)
2358         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2359       else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2360                || (tls_type & GOT_TLS_IE))
2361         htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2362       else if (GOT_TLS_GD_P (tls_type))
2363         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2364       else if (! GOT_TLS_GDESC_P (tls_type)
2365                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2366                    || h->root.type != bfd_link_hash_undefweak)
2367                && (info->shared
2368                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2369         htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2370       if (GOT_TLS_GDESC_P (tls_type))
2371         htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2372     }
2373   else
2374     h->got.offset = (bfd_vma) -1;
2375
2376   if (eh->dyn_relocs == NULL)
2377     return TRUE;
2378
2379   /* In the shared -Bsymbolic case, discard space allocated for
2380      dynamic pc-relative relocs against symbols which turn out to be
2381      defined in regular objects.  For the normal shared case, discard
2382      space for pc-relative relocs that have become local due to symbol
2383      visibility changes.  */
2384
2385   if (info->shared)
2386     {
2387       /* The only reloc that uses pc_count is R_386_PC32, which will
2388          appear on a call or on something like ".long foo - .".  We
2389          want calls to protected symbols to resolve directly to the
2390          function rather than going via the plt.  If people want
2391          function pointer comparisons to work as expected then they
2392          should avoid writing assembly like ".long foo - .".  */
2393       if (SYMBOL_CALLS_LOCAL (info, h))
2394         {
2395           struct elf_dyn_relocs **pp;
2396
2397           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2398             {
2399               p->count -= p->pc_count;
2400               p->pc_count = 0;
2401               if (p->count == 0)
2402                 *pp = p->next;
2403               else
2404                 pp = &p->next;
2405             }
2406         }
2407
2408       if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2409         {
2410           struct elf_dyn_relocs **pp;
2411           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2412             {
2413               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2414                 *pp = p->next;
2415               else
2416                 pp = &p->next;
2417             }
2418         }
2419
2420       /* Also discard relocs on undefined weak syms with non-default
2421          visibility.  */
2422       if (eh->dyn_relocs != NULL
2423           && h->root.type == bfd_link_hash_undefweak)
2424         {
2425           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2426             eh->dyn_relocs = NULL;
2427
2428           /* Make sure undefined weak symbols are output as a dynamic
2429              symbol in PIEs.  */
2430           else if (h->dynindx == -1
2431                    && !h->forced_local)
2432             {
2433               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2434                 return FALSE;
2435             }
2436         }
2437     }
2438   else if (ELIMINATE_COPY_RELOCS)
2439     {
2440       /* For the non-shared case, discard space for relocs against
2441          symbols which turn out to need copy relocs or are not
2442          dynamic.  */
2443
2444       if (!h->non_got_ref
2445           && ((h->def_dynamic
2446                && !h->def_regular)
2447               || (htab->elf.dynamic_sections_created
2448                   && (h->root.type == bfd_link_hash_undefweak
2449                       || h->root.type == bfd_link_hash_undefined))))
2450         {
2451           /* Make sure this symbol is output as a dynamic symbol.
2452              Undefined weak syms won't yet be marked as dynamic.  */
2453           if (h->dynindx == -1
2454               && !h->forced_local)
2455             {
2456               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2457                 return FALSE;
2458             }
2459
2460           /* If that succeeded, we know we'll be keeping all the
2461              relocs.  */
2462           if (h->dynindx != -1)
2463             goto keep;
2464         }
2465
2466       eh->dyn_relocs = NULL;
2467
2468     keep: ;
2469     }
2470
2471   /* Finally, allocate space.  */
2472   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2473     {
2474       asection *sreloc;
2475
2476       sreloc = elf_section_data (p->sec)->sreloc;
2477
2478       BFD_ASSERT (sreloc != NULL);
2479       sreloc->size += p->count * sizeof (Elf32_External_Rel);
2480     }
2481
2482   return TRUE;
2483 }
2484
2485 /* Allocate space in .plt, .got and associated reloc sections for
2486    local dynamic relocs.  */
2487
2488 static bfd_boolean
2489 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2490 {
2491   struct elf_link_hash_entry *h
2492     = (struct elf_link_hash_entry *) *slot;
2493
2494   if (h->type != STT_GNU_IFUNC
2495       || !h->def_regular
2496       || !h->ref_regular
2497       || !h->forced_local
2498       || h->root.type != bfd_link_hash_defined)
2499     abort ();
2500
2501   return elf_i386_allocate_dynrelocs (h, inf);
2502 }
2503
2504 /* Find any dynamic relocs that apply to read-only sections.  */
2505
2506 static bfd_boolean
2507 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2508 {
2509   struct elf_i386_link_hash_entry *eh;
2510   struct elf_dyn_relocs *p;
2511
2512   /* Skip local IFUNC symbols. */
2513   if (h->forced_local && h->type == STT_GNU_IFUNC)
2514     return TRUE;
2515
2516   eh = (struct elf_i386_link_hash_entry *) h;
2517   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2518     {
2519       asection *s = p->sec->output_section;
2520
2521       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2522         {
2523           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2524
2525           info->flags |= DF_TEXTREL;
2526
2527           if (info->warn_shared_textrel && info->shared)
2528             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2529                                     p->sec->owner, h->root.root.string,
2530                                     p->sec);
2531
2532           /* Not an error, just cut short the traversal.  */
2533           return FALSE;
2534         }
2535     }
2536   return TRUE;
2537 }
2538
2539 /* Set the sizes of the dynamic sections.  */
2540
2541 static bfd_boolean
2542 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2543 {
2544   struct elf_i386_link_hash_table *htab;
2545   bfd *dynobj;
2546   asection *s;
2547   bfd_boolean relocs;
2548   bfd *ibfd;
2549
2550   htab = elf_i386_hash_table (info);
2551   if (htab == NULL)
2552     return FALSE;
2553   dynobj = htab->elf.dynobj;
2554   if (dynobj == NULL)
2555     abort ();
2556
2557   if (htab->elf.dynamic_sections_created)
2558     {
2559       /* Set the contents of the .interp section to the interpreter.  */
2560       if (info->executable)
2561         {
2562           s = bfd_get_linker_section (dynobj, ".interp");
2563           if (s == NULL)
2564             abort ();
2565           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2566           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2567         }
2568     }
2569
2570   /* Set up .got offsets for local syms, and space for local dynamic
2571      relocs.  */
2572   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2573     {
2574       bfd_signed_vma *local_got;
2575       bfd_signed_vma *end_local_got;
2576       char *local_tls_type;
2577       bfd_vma *local_tlsdesc_gotent;
2578       bfd_size_type locsymcount;
2579       Elf_Internal_Shdr *symtab_hdr;
2580       asection *srel;
2581
2582       if (! is_i386_elf (ibfd))
2583         continue;
2584
2585       for (s = ibfd->sections; s != NULL; s = s->next)
2586         {
2587           struct elf_dyn_relocs *p;
2588
2589           for (p = ((struct elf_dyn_relocs *)
2590                      elf_section_data (s)->local_dynrel);
2591                p != NULL;
2592                p = p->next)
2593             {
2594               if (!bfd_is_abs_section (p->sec)
2595                   && bfd_is_abs_section (p->sec->output_section))
2596                 {
2597                   /* Input section has been discarded, either because
2598                      it is a copy of a linkonce section or due to
2599                      linker script /DISCARD/, so we'll be discarding
2600                      the relocs too.  */
2601                 }
2602               else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2603                        && strcmp (p->sec->output_section->name,
2604                                   ".tls_vars") == 0)
2605                 {
2606                   /* Relocations in vxworks .tls_vars sections are
2607                      handled specially by the loader.  */
2608                 }
2609               else if (p->count != 0)
2610                 {
2611                   srel = elf_section_data (p->sec)->sreloc;
2612                   srel->size += p->count * sizeof (Elf32_External_Rel);
2613                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2614                       && (info->flags & DF_TEXTREL) == 0)
2615                     {
2616                       info->flags |= DF_TEXTREL;
2617                       if (info->warn_shared_textrel && info->shared)
2618                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2619                                                 p->sec->owner, p->sec);
2620                     }
2621                 }
2622             }
2623         }
2624
2625       local_got = elf_local_got_refcounts (ibfd);
2626       if (!local_got)
2627         continue;
2628
2629       symtab_hdr = &elf_symtab_hdr (ibfd);
2630       locsymcount = symtab_hdr->sh_info;
2631       end_local_got = local_got + locsymcount;
2632       local_tls_type = elf_i386_local_got_tls_type (ibfd);
2633       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
2634       s = htab->elf.sgot;
2635       srel = htab->elf.srelgot;
2636       for (; local_got < end_local_got;
2637            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2638         {
2639           *local_tlsdesc_gotent = (bfd_vma) -1;
2640           if (*local_got > 0)
2641             {
2642               if (GOT_TLS_GDESC_P (*local_tls_type))
2643                 {
2644                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2645                     - elf_i386_compute_jump_table_size (htab);
2646                   htab->elf.sgotplt->size += 8;
2647                   *local_got = (bfd_vma) -2;
2648                 }
2649               if (! GOT_TLS_GDESC_P (*local_tls_type)
2650                   || GOT_TLS_GD_P (*local_tls_type))
2651                 {
2652                   *local_got = s->size;
2653                   s->size += 4;
2654                   if (GOT_TLS_GD_P (*local_tls_type)
2655                       || *local_tls_type == GOT_TLS_IE_BOTH)
2656                     s->size += 4;
2657                 }
2658               if (info->shared
2659                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2660                   || (*local_tls_type & GOT_TLS_IE))
2661                 {
2662                   if (*local_tls_type == GOT_TLS_IE_BOTH)
2663                     srel->size += 2 * sizeof (Elf32_External_Rel);
2664                   else if (GOT_TLS_GD_P (*local_tls_type)
2665                            || ! GOT_TLS_GDESC_P (*local_tls_type))
2666                     srel->size += sizeof (Elf32_External_Rel);
2667                   if (GOT_TLS_GDESC_P (*local_tls_type))
2668                     htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2669                 }
2670             }
2671           else
2672             *local_got = (bfd_vma) -1;
2673         }
2674     }
2675
2676   if (htab->tls_ldm_got.refcount > 0)
2677     {
2678       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2679          relocs.  */
2680       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2681       htab->elf.sgot->size += 8;
2682       htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2683     }
2684   else
2685     htab->tls_ldm_got.offset = -1;
2686
2687   /* Allocate global sym .plt and .got entries, and space for global
2688      sym dynamic relocs.  */
2689   elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
2690
2691   /* Allocate .plt and .got entries, and space for local symbols.  */
2692   htab_traverse (htab->loc_hash_table,
2693                  elf_i386_allocate_local_dynrelocs,
2694                  info);
2695
2696   /* For every jump slot reserved in the sgotplt, reloc_count is
2697      incremented.  However, when we reserve space for TLS descriptors,
2698      it's not incremented, so in order to compute the space reserved
2699      for them, it suffices to multiply the reloc count by the jump
2700      slot size.
2701
2702      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2703      so that R_386_IRELATIVE entries come last.  */
2704   if (htab->elf.srelplt)
2705     {
2706       htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2707       htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2708       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2709     }
2710   else if (htab->elf.irelplt)
2711     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2712
2713
2714   if (htab->elf.sgotplt)
2715     {
2716       struct elf_link_hash_entry *got;
2717       got = elf_link_hash_lookup (elf_hash_table (info),
2718                                   "_GLOBAL_OFFSET_TABLE_",
2719                                   FALSE, FALSE, FALSE);
2720
2721       /* Don't allocate .got.plt section if there are no GOT nor PLT
2722          entries and there is no reference to _GLOBAL_OFFSET_TABLE_.  */
2723       if ((got == NULL
2724            || !got->ref_regular_nonweak)
2725           && (htab->elf.sgotplt->size
2726               == get_elf_backend_data (output_bfd)->got_header_size)
2727           && (htab->elf.splt == NULL
2728               || htab->elf.splt->size == 0)
2729           && (htab->elf.sgot == NULL
2730               || htab->elf.sgot->size == 0)
2731           && (htab->elf.iplt == NULL
2732               || htab->elf.iplt->size == 0)
2733           && (htab->elf.igotplt == NULL
2734               || htab->elf.igotplt->size == 0))
2735         htab->elf.sgotplt->size = 0;
2736     }
2737
2738
2739   if (htab->plt_eh_frame != NULL
2740       && htab->elf.splt != NULL
2741       && htab->elf.splt->size != 0
2742       && !bfd_is_abs_section (htab->elf.splt->output_section)
2743       && _bfd_elf_eh_frame_present (info))
2744     htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
2745
2746   /* We now have determined the sizes of the various dynamic sections.
2747      Allocate memory for them.  */
2748   relocs = FALSE;
2749   for (s = dynobj->sections; s != NULL; s = s->next)
2750     {
2751       bfd_boolean strip_section = TRUE;
2752
2753       if ((s->flags & SEC_LINKER_CREATED) == 0)
2754         continue;
2755
2756       if (s == htab->elf.splt
2757           || s == htab->elf.sgot)
2758         {
2759           /* Strip this section if we don't need it; see the
2760              comment below.  */
2761           /* We'd like to strip these sections if they aren't needed, but if
2762              we've exported dynamic symbols from them we must leave them.
2763              It's too late to tell BFD to get rid of the symbols.  */
2764
2765           if (htab->elf.hplt != NULL)
2766             strip_section = FALSE;
2767         }
2768       else if (s == htab->elf.sgotplt
2769                || s == htab->elf.iplt
2770                || s == htab->elf.igotplt
2771                || s == htab->plt_eh_frame
2772                || s == htab->sdynbss)
2773         {
2774           /* Strip these too.  */
2775         }
2776       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2777         {
2778           if (s->size != 0
2779               && s != htab->elf.srelplt
2780               && s != htab->srelplt2)
2781             relocs = TRUE;
2782
2783           /* We use the reloc_count field as a counter if we need
2784              to copy relocs into the output file.  */
2785           s->reloc_count = 0;
2786         }
2787       else
2788         {
2789           /* It's not one of our sections, so don't allocate space.  */
2790           continue;
2791         }
2792
2793       if (s->size == 0)
2794         {
2795           /* If we don't need this section, strip it from the
2796              output file.  This is mostly to handle .rel.bss and
2797              .rel.plt.  We must create both sections in
2798              create_dynamic_sections, because they must be created
2799              before the linker maps input sections to output
2800              sections.  The linker does that before
2801              adjust_dynamic_symbol is called, and it is that
2802              function which decides whether anything needs to go
2803              into these sections.  */
2804           if (strip_section)
2805             s->flags |= SEC_EXCLUDE;
2806           continue;
2807         }
2808
2809       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2810         continue;
2811
2812       /* Allocate memory for the section contents.  We use bfd_zalloc
2813          here in case unused entries are not reclaimed before the
2814          section's contents are written out.  This should not happen,
2815          but this way if it does, we get a R_386_NONE reloc instead
2816          of garbage.  */
2817       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2818       if (s->contents == NULL)
2819         return FALSE;
2820     }
2821
2822   if (htab->plt_eh_frame != NULL
2823       && htab->plt_eh_frame->contents != NULL)
2824     {
2825       memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
2826               sizeof (elf_i386_eh_frame_plt));
2827       bfd_put_32 (dynobj, htab->elf.splt->size,
2828                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2829     }
2830
2831   if (htab->elf.dynamic_sections_created)
2832     {
2833       /* Add some entries to the .dynamic section.  We fill in the
2834          values later, in elf_i386_finish_dynamic_sections, but we
2835          must add the entries now so that we get the correct size for
2836          the .dynamic section.  The DT_DEBUG entry is filled in by the
2837          dynamic linker and used by the debugger.  */
2838 #define add_dynamic_entry(TAG, VAL) \
2839   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2840
2841       if (info->executable)
2842         {
2843           if (!add_dynamic_entry (DT_DEBUG, 0))
2844             return FALSE;
2845         }
2846
2847       if (htab->elf.splt->size != 0)
2848         {
2849           if (!add_dynamic_entry (DT_PLTGOT, 0)
2850               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2851               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2852               || !add_dynamic_entry (DT_JMPREL, 0))
2853             return FALSE;
2854         }
2855
2856       if (relocs)
2857         {
2858           if (!add_dynamic_entry (DT_REL, 0)
2859               || !add_dynamic_entry (DT_RELSZ, 0)
2860               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2861             return FALSE;
2862
2863           /* If any dynamic relocs apply to a read-only section,
2864              then we need a DT_TEXTREL entry.  */
2865           if ((info->flags & DF_TEXTREL) == 0)
2866             elf_link_hash_traverse (&htab->elf,
2867                                     elf_i386_readonly_dynrelocs, info);
2868
2869           if ((info->flags & DF_TEXTREL) != 0)
2870             {
2871               if (!add_dynamic_entry (DT_TEXTREL, 0))
2872                 return FALSE;
2873             }
2874         }
2875       if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2876           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2877         return FALSE;
2878     }
2879 #undef add_dynamic_entry
2880
2881   return TRUE;
2882 }
2883
2884 static bfd_boolean
2885 elf_i386_always_size_sections (bfd *output_bfd,
2886                                struct bfd_link_info *info)
2887 {
2888   asection *tls_sec = elf_hash_table (info)->tls_sec;
2889
2890   if (tls_sec)
2891     {
2892       struct elf_link_hash_entry *tlsbase;
2893
2894       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2895                                       "_TLS_MODULE_BASE_",
2896                                       FALSE, FALSE, FALSE);
2897
2898       if (tlsbase && tlsbase->type == STT_TLS)
2899         {
2900           struct elf_i386_link_hash_table *htab;
2901           struct bfd_link_hash_entry *bh = NULL;
2902           const struct elf_backend_data *bed
2903             = get_elf_backend_data (output_bfd);
2904
2905           htab = elf_i386_hash_table (info);
2906           if (htab == NULL)
2907             return FALSE;
2908
2909           if (!(_bfd_generic_link_add_one_symbol
2910                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2911                  tls_sec, 0, NULL, FALSE,
2912                  bed->collect, &bh)))
2913             return FALSE;
2914
2915           htab->tls_module_base = bh;
2916
2917           tlsbase = (struct elf_link_hash_entry *)bh;
2918           tlsbase->def_regular = 1;
2919           tlsbase->other = STV_HIDDEN;
2920           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2921         }
2922     }
2923
2924   return TRUE;
2925 }
2926
2927 /* Set the correct type for an x86 ELF section.  We do this by the
2928    section name, which is a hack, but ought to work.  */
2929
2930 static bfd_boolean
2931 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2932                         Elf_Internal_Shdr *hdr,
2933                         asection *sec)
2934 {
2935   const char *name;
2936
2937   name = bfd_get_section_name (abfd, sec);
2938
2939   /* This is an ugly, but unfortunately necessary hack that is
2940      needed when producing EFI binaries on x86. It tells
2941      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2942      containing ELF relocation info.  We need this hack in order to
2943      be able to generate ELF binaries that can be translated into
2944      EFI applications (which are essentially COFF objects).  Those
2945      files contain a COFF ".reloc" section inside an ELFNN object,
2946      which would normally cause BFD to segfault because it would
2947      attempt to interpret this section as containing relocation
2948      entries for section "oc".  With this hack enabled, ".reloc"
2949      will be treated as a normal data section, which will avoid the
2950      segfault.  However, you won't be able to create an ELFNN binary
2951      with a section named "oc" that needs relocations, but that's
2952      the kind of ugly side-effects you get when detecting section
2953      types based on their names...  In practice, this limitation is
2954      unlikely to bite.  */
2955   if (strcmp (name, ".reloc") == 0)
2956     hdr->sh_type = SHT_PROGBITS;
2957
2958   return TRUE;
2959 }
2960
2961 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2962    executables.  Rather than setting it to the beginning of the TLS
2963    section, we have to set it to the end.    This function may be called
2964    multiple times, it is idempotent.  */
2965
2966 static void
2967 elf_i386_set_tls_module_base (struct bfd_link_info *info)
2968 {
2969   struct elf_i386_link_hash_table *htab;
2970   struct bfd_link_hash_entry *base;
2971
2972   if (!info->executable)
2973     return;
2974
2975   htab = elf_i386_hash_table (info);
2976   if (htab == NULL)
2977     return;
2978
2979   base = htab->tls_module_base;
2980   if (base == NULL)
2981     return;
2982
2983   base->u.def.value = htab->elf.tls_size;
2984 }
2985
2986 /* Return the base VMA address which should be subtracted from real addresses
2987    when resolving @dtpoff relocation.
2988    This is PT_TLS segment p_vaddr.  */
2989
2990 static bfd_vma
2991 elf_i386_dtpoff_base (struct bfd_link_info *info)
2992 {
2993   /* If tls_sec is NULL, we should have signalled an error already.  */
2994   if (elf_hash_table (info)->tls_sec == NULL)
2995     return 0;
2996   return elf_hash_table (info)->tls_sec->vma;
2997 }
2998
2999 /* Return the relocation value for @tpoff relocation
3000    if STT_TLS virtual address is ADDRESS.  */
3001
3002 static bfd_vma
3003 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3004 {
3005   struct elf_link_hash_table *htab = elf_hash_table (info);
3006   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3007   bfd_vma static_tls_size;
3008
3009   /* If tls_sec is NULL, we should have signalled an error already.  */
3010   if (htab->tls_sec == NULL)
3011     return 0;
3012
3013   /* Consider special static TLS alignment requirements.  */
3014   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3015   return static_tls_size + htab->tls_sec->vma - address;
3016 }
3017
3018 /* Relocate an i386 ELF section.  */
3019
3020 static bfd_boolean
3021 elf_i386_relocate_section (bfd *output_bfd,
3022                            struct bfd_link_info *info,
3023                            bfd *input_bfd,
3024                            asection *input_section,
3025                            bfd_byte *contents,
3026                            Elf_Internal_Rela *relocs,
3027                            Elf_Internal_Sym *local_syms,
3028                            asection **local_sections)
3029 {
3030   struct elf_i386_link_hash_table *htab;
3031   Elf_Internal_Shdr *symtab_hdr;
3032   struct elf_link_hash_entry **sym_hashes;
3033   bfd_vma *local_got_offsets;
3034   bfd_vma *local_tlsdesc_gotents;
3035   Elf_Internal_Rela *rel;
3036   Elf_Internal_Rela *relend;
3037   bfd_boolean is_vxworks_tls;
3038   unsigned plt_entry_size;
3039
3040   BFD_ASSERT (is_i386_elf (input_bfd));
3041
3042   htab = elf_i386_hash_table (info);
3043   if (htab == NULL)
3044     return FALSE;
3045   symtab_hdr = &elf_symtab_hdr (input_bfd);
3046   sym_hashes = elf_sym_hashes (input_bfd);
3047   local_got_offsets = elf_local_got_offsets (input_bfd);
3048   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3049   /* We have to handle relocations in vxworks .tls_vars sections
3050      specially, because the dynamic loader is 'weird'.  */
3051   is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3052                     && info->shared
3053                     && !strcmp (input_section->output_section->name,
3054                                 ".tls_vars"));
3055
3056   elf_i386_set_tls_module_base (info);
3057
3058   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3059
3060   rel = relocs;
3061   relend = relocs + input_section->reloc_count;
3062   for (; rel < relend; rel++)
3063     {
3064       unsigned int r_type;
3065       reloc_howto_type *howto;
3066       unsigned long r_symndx;
3067       struct elf_link_hash_entry *h;
3068       Elf_Internal_Sym *sym;
3069       asection *sec;
3070       bfd_vma off, offplt;
3071       bfd_vma relocation;
3072       bfd_boolean unresolved_reloc;
3073       bfd_reloc_status_type r;
3074       unsigned int indx;
3075       int tls_type;
3076
3077       r_type = ELF32_R_TYPE (rel->r_info);
3078       if (r_type == R_386_GNU_VTINHERIT
3079           || r_type == R_386_GNU_VTENTRY)
3080         continue;
3081
3082       if ((indx = r_type) >= R_386_standard
3083           && ((indx = r_type - R_386_ext_offset) - R_386_standard
3084               >= R_386_ext - R_386_standard)
3085           && ((indx = r_type - R_386_tls_offset) - R_386_ext
3086               >= R_386_irelative - R_386_ext))
3087         {
3088           (*_bfd_error_handler)
3089             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3090              input_bfd, input_section, r_type);
3091           bfd_set_error (bfd_error_bad_value);
3092           return FALSE;
3093         }
3094       howto = elf_howto_table + indx;
3095
3096       r_symndx = ELF32_R_SYM (rel->r_info);
3097       h = NULL;
3098       sym = NULL;
3099       sec = NULL;
3100       unresolved_reloc = FALSE;
3101       if (r_symndx < symtab_hdr->sh_info)
3102         {
3103           sym = local_syms + r_symndx;
3104           sec = local_sections[r_symndx];
3105           relocation = (sec->output_section->vma
3106                         + sec->output_offset
3107                         + sym->st_value);
3108
3109           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3110               && ((sec->flags & SEC_MERGE) != 0
3111                   || (info->relocatable
3112                       && sec->output_offset != 0)))
3113             {
3114               bfd_vma addend;
3115               bfd_byte *where = contents + rel->r_offset;
3116
3117               switch (howto->size)
3118                 {
3119                 case 0:
3120                   addend = bfd_get_8 (input_bfd, where);
3121                   if (howto->pc_relative)
3122                     {
3123                       addend = (addend ^ 0x80) - 0x80;
3124                       addend += 1;
3125                     }
3126                   break;
3127                 case 1:
3128                   addend = bfd_get_16 (input_bfd, where);
3129                   if (howto->pc_relative)
3130                     {
3131                       addend = (addend ^ 0x8000) - 0x8000;
3132                       addend += 2;
3133                     }
3134                   break;
3135                 case 2:
3136                   addend = bfd_get_32 (input_bfd, where);
3137                   if (howto->pc_relative)
3138                     {
3139                       addend = (addend ^ 0x80000000) - 0x80000000;
3140                       addend += 4;
3141                     }
3142                   break;
3143                 default:
3144                   abort ();
3145                 }
3146
3147               if (info->relocatable)
3148                 addend += sec->output_offset;
3149               else
3150                 {
3151                   asection *msec = sec;
3152                   addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3153                                                    addend);
3154                   addend -= relocation;
3155                   addend += msec->output_section->vma + msec->output_offset;
3156                 }
3157
3158               switch (howto->size)
3159                 {
3160                 case 0:
3161                   /* FIXME: overflow checks.  */
3162                   if (howto->pc_relative)
3163                     addend -= 1;
3164                   bfd_put_8 (input_bfd, addend, where);
3165                   break;
3166                 case 1:
3167                   if (howto->pc_relative)
3168                     addend -= 2;
3169                   bfd_put_16 (input_bfd, addend, where);
3170                   break;
3171                 case 2:
3172                   if (howto->pc_relative)
3173                     addend -= 4;
3174                   bfd_put_32 (input_bfd, addend, where);
3175                   break;
3176                 }
3177             }
3178           else if (!info->relocatable
3179                    && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3180             {
3181               /* Relocate against local STT_GNU_IFUNC symbol.  */
3182               h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3183                                                FALSE);
3184               if (h == NULL)
3185                 abort ();
3186
3187               /* Set STT_GNU_IFUNC symbol value.  */
3188               h->root.u.def.value = sym->st_value;
3189               h->root.u.def.section = sec;
3190             }
3191         }
3192       else
3193         {
3194           bfd_boolean warned ATTRIBUTE_UNUSED;
3195
3196           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3197                                    r_symndx, symtab_hdr, sym_hashes,
3198                                    h, sec, relocation,
3199                                    unresolved_reloc, warned);
3200         }
3201
3202       if (sec != NULL && discarded_section (sec))
3203         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3204                                          rel, 1, relend, howto, 0, contents);
3205
3206       if (info->relocatable)
3207         continue;
3208
3209       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3210          it here if it is defined in a non-shared object.  */
3211       if (h != NULL
3212           && h->type == STT_GNU_IFUNC
3213           && h->def_regular)
3214         {
3215           asection *plt, *gotplt, *base_got;
3216           bfd_vma plt_index;
3217           const char *name;
3218
3219           if ((input_section->flags & SEC_ALLOC) == 0
3220               || h->plt.offset == (bfd_vma) -1)
3221             abort ();
3222
3223           /* STT_GNU_IFUNC symbol must go through PLT.  */
3224           if (htab->elf.splt != NULL)
3225             {
3226               plt = htab->elf.splt;
3227               gotplt = htab->elf.sgotplt;
3228             }
3229           else
3230             {
3231               plt = htab->elf.iplt;
3232               gotplt = htab->elf.igotplt;
3233             }
3234
3235           relocation = (plt->output_section->vma
3236                         + plt->output_offset + h->plt.offset);
3237
3238           switch (r_type)
3239             {
3240             default:
3241               if (h->root.root.string)
3242                 name = h->root.root.string;
3243               else
3244                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3245                                          NULL);
3246               (*_bfd_error_handler)
3247                 (_("%B: relocation %s against STT_GNU_IFUNC "
3248                    "symbol `%s' isn't handled by %s"), input_bfd,
3249                  elf_howto_table[r_type].name,
3250                  name, __FUNCTION__);
3251               bfd_set_error (bfd_error_bad_value);
3252               return FALSE;
3253
3254             case R_386_32:
3255               /* Generate dynamic relcoation only when there is a
3256                  non-GOT reference in a shared object.  */
3257               if (info->shared && h->non_got_ref)
3258                 {
3259                   Elf_Internal_Rela outrel;
3260                   bfd_byte *loc;
3261                   asection *sreloc;
3262                   bfd_vma offset;
3263
3264                   /* Need a dynamic relocation to get the real function
3265                      adddress.  */
3266                   offset = _bfd_elf_section_offset (output_bfd,
3267                                                     info,
3268                                                     input_section,
3269                                                     rel->r_offset);
3270                   if (offset == (bfd_vma) -1
3271                       || offset == (bfd_vma) -2)
3272                     abort ();
3273
3274                   outrel.r_offset = (input_section->output_section->vma
3275                                      + input_section->output_offset
3276                                      + offset);
3277
3278                   if (h->dynindx == -1
3279                       || h->forced_local
3280                       || info->executable)
3281                     {
3282                       /* This symbol is resolved locally.  */
3283                       outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3284                       bfd_put_32 (output_bfd,
3285                                   (h->root.u.def.value
3286                                    + h->root.u.def.section->output_section->vma
3287                                    + h->root.u.def.section->output_offset),
3288                                   contents + offset);
3289                     }
3290                   else
3291                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3292
3293                   sreloc = htab->elf.irelifunc;
3294                   loc = sreloc->contents;
3295                   loc += (sreloc->reloc_count++
3296                           * sizeof (Elf32_External_Rel));
3297                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3298
3299                   /* If this reloc is against an external symbol, we
3300                      do not want to fiddle with the addend.  Otherwise,
3301                      we need to include the symbol value so that it
3302                      becomes an addend for the dynamic reloc.  For an
3303                      internal symbol, we have updated addend.  */
3304                   continue;
3305                 }
3306               /* FALLTHROUGH */
3307             case R_386_PC32:
3308             case R_386_PLT32:
3309               goto do_relocation;
3310
3311             case R_386_GOT32:
3312               base_got = htab->elf.sgot;
3313               off = h->got.offset;
3314
3315               if (base_got == NULL)
3316                 abort ();
3317
3318               if (off == (bfd_vma) -1)
3319                 {
3320                   /* We can't use h->got.offset here to save state, or
3321                      even just remember the offset, as finish_dynamic_symbol
3322                      would use that as offset into .got.  */
3323
3324                   if (htab->elf.splt != NULL)
3325                     {
3326                       plt_index = h->plt.offset / plt_entry_size - 1;
3327                       off = (plt_index + 3) * 4;
3328                       base_got = htab->elf.sgotplt;
3329                     }
3330                   else
3331                     {
3332                       plt_index = h->plt.offset / plt_entry_size;
3333                       off = plt_index * 4;
3334                       base_got = htab->elf.igotplt;
3335                     }
3336
3337                   if (h->dynindx == -1
3338                       || h->forced_local
3339                       || info->symbolic)
3340                     {
3341                       /* This references the local defitionion.  We must
3342                          initialize this entry in the global offset table.
3343                          Since the offset must always be a multiple of 8,
3344                          we use the least significant bit to record
3345                          whether we have initialized it already.
3346
3347                          When doing a dynamic link, we create a .rela.got
3348                          relocation entry to initialize the value.  This
3349                          is done in the finish_dynamic_symbol routine.   */
3350                       if ((off & 1) != 0)
3351                         off &= ~1;
3352                       else
3353                         {
3354                           bfd_put_32 (output_bfd, relocation,
3355                                       base_got->contents + off);
3356                           h->got.offset |= 1;
3357                         }
3358                     }
3359
3360                   relocation = off;
3361
3362                   /* Adjust for static executables.  */
3363                   if (htab->elf.splt == NULL)
3364                     relocation += gotplt->output_offset;
3365                 }
3366               else
3367                 {
3368                   relocation = (base_got->output_section->vma
3369                                 + base_got->output_offset + off
3370                                 - gotplt->output_section->vma
3371                                 - gotplt->output_offset);
3372                   /* Adjust for static executables.  */
3373                   if (htab->elf.splt == NULL)
3374                     relocation += gotplt->output_offset;
3375                 }
3376
3377               goto do_relocation;
3378
3379             case R_386_GOTOFF:
3380               relocation -= (gotplt->output_section->vma
3381                              + gotplt->output_offset);
3382               goto do_relocation;
3383             }
3384         }
3385
3386       switch (r_type)
3387         {
3388         case R_386_GOT32:
3389           /* Relocation is to the entry for this symbol in the global
3390              offset table.  */
3391           if (htab->elf.sgot == NULL)
3392             abort ();
3393
3394           if (h != NULL)
3395             {
3396               bfd_boolean dyn;
3397
3398               off = h->got.offset;
3399               dyn = htab->elf.dynamic_sections_created;
3400               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3401                   || (info->shared
3402                       && SYMBOL_REFERENCES_LOCAL (info, h))
3403                   || (ELF_ST_VISIBILITY (h->other)
3404                       && h->root.type == bfd_link_hash_undefweak))
3405                 {
3406                   /* This is actually a static link, or it is a
3407                      -Bsymbolic link and the symbol is defined
3408                      locally, or the symbol was forced to be local
3409                      because of a version file.  We must initialize
3410                      this entry in the global offset table.  Since the
3411                      offset must always be a multiple of 4, we use the
3412                      least significant bit to record whether we have
3413                      initialized it already.
3414
3415                      When doing a dynamic link, we create a .rel.got
3416                      relocation entry to initialize the value.  This
3417                      is done in the finish_dynamic_symbol routine.  */
3418                   if ((off & 1) != 0)
3419                     off &= ~1;
3420                   else
3421                     {
3422                       bfd_put_32 (output_bfd, relocation,
3423                                   htab->elf.sgot->contents + off);
3424                       h->got.offset |= 1;
3425                     }
3426                 }
3427               else
3428                 unresolved_reloc = FALSE;
3429             }
3430           else
3431             {
3432               if (local_got_offsets == NULL)
3433                 abort ();
3434
3435               off = local_got_offsets[r_symndx];
3436
3437               /* The offset must always be a multiple of 4.  We use
3438                  the least significant bit to record whether we have
3439                  already generated the necessary reloc.  */
3440               if ((off & 1) != 0)
3441                 off &= ~1;
3442               else
3443                 {
3444                   bfd_put_32 (output_bfd, relocation,
3445                               htab->elf.sgot->contents + off);
3446
3447                   if (info->shared)
3448                     {
3449                       asection *s;
3450                       Elf_Internal_Rela outrel;
3451                       bfd_byte *loc;
3452
3453                       s = htab->elf.srelgot;
3454                       if (s == NULL)
3455                         abort ();
3456
3457                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3458                                          + htab->elf.sgot->output_offset
3459                                          + off);
3460                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3461                       loc = s->contents;
3462                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
3463                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3464                     }
3465
3466                   local_got_offsets[r_symndx] |= 1;
3467                 }
3468             }
3469
3470           if (off >= (bfd_vma) -2)
3471             abort ();
3472
3473           relocation = htab->elf.sgot->output_section->vma
3474                        + htab->elf.sgot->output_offset + off
3475                        - htab->elf.sgotplt->output_section->vma
3476                        - htab->elf.sgotplt->output_offset;
3477           break;
3478
3479         case R_386_GOTOFF:
3480           /* Relocation is relative to the start of the global offset
3481              table.  */
3482
3483           /* Check to make sure it isn't a protected function symbol
3484              for shared library since it may not be local when used
3485              as function address.  We also need to make sure that a
3486              symbol is defined locally.  */
3487           if (info->shared && h)
3488             {
3489               if (!h->def_regular)
3490                 {
3491                   const char *v;
3492
3493                   switch (ELF_ST_VISIBILITY (h->other))
3494                     {
3495                     case STV_HIDDEN:
3496                       v = _("hidden symbol");
3497                       break;
3498                     case STV_INTERNAL:
3499                       v = _("internal symbol");
3500                       break;
3501                     case STV_PROTECTED:
3502                       v = _("protected symbol");
3503                       break;
3504                     default:
3505                       v = _("symbol");
3506                       break;
3507                     }
3508
3509                   (*_bfd_error_handler)
3510                     (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3511                      input_bfd, v, h->root.root.string);
3512                   bfd_set_error (bfd_error_bad_value);
3513                   return FALSE;
3514                 }
3515               else if (!info->executable
3516                        && !SYMBOLIC_BIND (info, h)
3517                        && h->type == STT_FUNC
3518                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3519                 {
3520                   (*_bfd_error_handler)
3521                     (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3522                      input_bfd, h->root.root.string);
3523                   bfd_set_error (bfd_error_bad_value);
3524                   return FALSE;
3525                 }
3526             }
3527
3528           /* Note that sgot is not involved in this
3529              calculation.  We always want the start of .got.plt.  If we
3530              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3531              permitted by the ABI, we might have to change this
3532              calculation.  */
3533           relocation -= htab->elf.sgotplt->output_section->vma
3534                         + htab->elf.sgotplt->output_offset;
3535           break;
3536
3537         case R_386_GOTPC:
3538           /* Use global offset table as symbol value.  */
3539           relocation = htab->elf.sgotplt->output_section->vma
3540                        + htab->elf.sgotplt->output_offset;
3541           unresolved_reloc = FALSE;
3542           break;
3543
3544         case R_386_PLT32:
3545           /* Relocation is to the entry for this symbol in the
3546              procedure linkage table.  */
3547
3548           /* Resolve a PLT32 reloc against a local symbol directly,
3549              without using the procedure linkage table.  */
3550           if (h == NULL)
3551             break;
3552
3553           if (h->plt.offset == (bfd_vma) -1
3554               || htab->elf.splt == NULL)
3555             {
3556               /* We didn't make a PLT entry for this symbol.  This
3557                  happens when statically linking PIC code, or when
3558                  using -Bsymbolic.  */
3559               break;
3560             }
3561
3562           relocation = (htab->elf.splt->output_section->vma
3563                         + htab->elf.splt->output_offset
3564                         + h->plt.offset);
3565           unresolved_reloc = FALSE;
3566           break;
3567
3568         case R_386_32:
3569         case R_386_PC32:
3570           if ((input_section->flags & SEC_ALLOC) == 0
3571               || is_vxworks_tls)
3572             break;
3573
3574           if ((info->shared
3575                && (h == NULL
3576                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3577                    || h->root.type != bfd_link_hash_undefweak)
3578                && (r_type != R_386_PC32
3579                    || !SYMBOL_CALLS_LOCAL (info, h)))
3580               || (ELIMINATE_COPY_RELOCS
3581                   && !info->shared
3582                   && h != NULL
3583                   && h->dynindx != -1
3584                   && !h->non_got_ref
3585                   && ((h->def_dynamic
3586                        && !h->def_regular)
3587                       || h->root.type == bfd_link_hash_undefweak
3588                       || h->root.type == bfd_link_hash_undefined)))
3589             {
3590               Elf_Internal_Rela outrel;
3591               bfd_byte *loc;
3592               bfd_boolean skip, relocate;
3593               asection *sreloc;
3594
3595               /* When generating a shared object, these relocations
3596                  are copied into the output file to be resolved at run
3597                  time.  */
3598
3599               skip = FALSE;
3600               relocate = FALSE;
3601
3602               outrel.r_offset =
3603                 _bfd_elf_section_offset (output_bfd, info, input_section,
3604                                          rel->r_offset);
3605               if (outrel.r_offset == (bfd_vma) -1)
3606                 skip = TRUE;
3607               else if (outrel.r_offset == (bfd_vma) -2)
3608                 skip = TRUE, relocate = TRUE;
3609               outrel.r_offset += (input_section->output_section->vma
3610                                   + input_section->output_offset);
3611
3612               if (skip)
3613                 memset (&outrel, 0, sizeof outrel);
3614               else if (h != NULL
3615                        && h->dynindx != -1
3616                        && (r_type == R_386_PC32
3617                            || !info->shared
3618                            || !SYMBOLIC_BIND (info, h)
3619                            || !h->def_regular))
3620                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3621               else
3622                 {
3623                   /* This symbol is local, or marked to become local.  */
3624                   relocate = TRUE;
3625                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3626                 }
3627
3628               sreloc = elf_section_data (input_section)->sreloc;
3629
3630               if (sreloc == NULL || sreloc->contents == NULL)
3631                 {
3632                   r = bfd_reloc_notsupported;
3633                   goto check_relocation_error;
3634                 }
3635
3636               loc = sreloc->contents;
3637               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3638
3639               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3640
3641               /* If this reloc is against an external symbol, we do
3642                  not want to fiddle with the addend.  Otherwise, we
3643                  need to include the symbol value so that it becomes
3644                  an addend for the dynamic reloc.  */
3645               if (! relocate)
3646                 continue;
3647             }
3648           break;
3649
3650         case R_386_TLS_IE:
3651           if (!info->executable)
3652             {
3653               Elf_Internal_Rela outrel;
3654               bfd_byte *loc;
3655               asection *sreloc;
3656
3657               outrel.r_offset = rel->r_offset
3658                                 + input_section->output_section->vma
3659                                 + input_section->output_offset;
3660               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3661               sreloc = elf_section_data (input_section)->sreloc;
3662               if (sreloc == NULL)
3663                 abort ();
3664               loc = sreloc->contents;
3665               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3666               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3667             }
3668           /* Fall through */
3669
3670         case R_386_TLS_GD:
3671         case R_386_TLS_GOTDESC:
3672         case R_386_TLS_DESC_CALL:
3673         case R_386_TLS_IE_32:
3674         case R_386_TLS_GOTIE:
3675           tls_type = GOT_UNKNOWN;
3676           if (h == NULL && local_got_offsets)
3677             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3678           else if (h != NULL)
3679             tls_type = elf_i386_hash_entry(h)->tls_type;
3680           if (tls_type == GOT_TLS_IE)
3681             tls_type = GOT_TLS_IE_NEG;
3682
3683           if (! elf_i386_tls_transition (info, input_bfd,
3684                                          input_section, contents,
3685                                          symtab_hdr, sym_hashes,
3686                                          &r_type, tls_type, rel,
3687                                          relend, h, r_symndx))
3688             return FALSE;
3689
3690           if (r_type == R_386_TLS_LE_32)
3691             {
3692               BFD_ASSERT (! unresolved_reloc);
3693               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3694                 {
3695                   unsigned int type;
3696                   bfd_vma roff;
3697
3698                   /* GD->LE transition.  */
3699                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3700                   if (type == 0x04)
3701                     {
3702                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3703                          Change it into:
3704                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3705                          (6 byte form of subl).  */
3706                       memcpy (contents + rel->r_offset - 3,
3707                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3708                       roff = rel->r_offset + 5;
3709                     }
3710                   else
3711                     {
3712                       /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3713                          Change it into:
3714                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3715                          (6 byte form of subl).  */
3716                       memcpy (contents + rel->r_offset - 2,
3717                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3718                       roff = rel->r_offset + 6;
3719                     }
3720                   bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3721                               contents + roff);
3722                   /* Skip R_386_PC32/R_386_PLT32.  */
3723                   rel++;
3724                   continue;
3725                 }
3726               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3727                 {
3728                   /* GDesc -> LE transition.
3729                      It's originally something like:
3730                      leal x@tlsdesc(%ebx), %eax
3731
3732                      leal x@ntpoff, %eax
3733
3734                      Registers other than %eax may be set up here.  */
3735
3736                   unsigned int val;
3737                   bfd_vma roff;
3738
3739                   roff = rel->r_offset;
3740                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3741
3742                   /* Now modify the instruction as appropriate.  */
3743                   /* aoliva FIXME: remove the above and xor the byte
3744                      below with 0x86.  */
3745                   bfd_put_8 (output_bfd, val ^ 0x86,
3746                              contents + roff - 1);
3747                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3748                               contents + roff);
3749                   continue;
3750                 }
3751               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3752                 {
3753                   /* GDesc -> LE transition.
3754                      It's originally:
3755                      call *(%eax)
3756                      Turn it into:
3757                      xchg %ax,%ax  */
3758
3759                   bfd_vma roff;
3760
3761                   roff = rel->r_offset;
3762                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3763                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3764                   continue;
3765                 }
3766               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
3767                 {
3768                   unsigned int val;
3769
3770                   /* IE->LE transition:
3771                      Originally it can be one of:
3772                      movl foo, %eax
3773                      movl foo, %reg
3774                      addl foo, %reg
3775                      We change it into:
3776                      movl $foo, %eax
3777                      movl $foo, %reg
3778                      addl $foo, %reg.  */
3779                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3780                   if (val == 0xa1)
3781                     {
3782                       /* movl foo, %eax.  */
3783                       bfd_put_8 (output_bfd, 0xb8,
3784                                  contents + rel->r_offset - 1);
3785                     }
3786                   else
3787                     {
3788                       unsigned int type;
3789
3790                       type = bfd_get_8 (input_bfd,
3791                                         contents + rel->r_offset - 2);
3792                       switch (type)
3793                         {
3794                         case 0x8b:
3795                           /* movl */
3796                           bfd_put_8 (output_bfd, 0xc7,
3797                                      contents + rel->r_offset - 2);
3798                           bfd_put_8 (output_bfd,
3799                                      0xc0 | ((val >> 3) & 7),
3800                                      contents + rel->r_offset - 1);
3801                           break;
3802                         case 0x03:
3803                           /* addl */
3804                           bfd_put_8 (output_bfd, 0x81,
3805                                      contents + rel->r_offset - 2);
3806                           bfd_put_8 (output_bfd,
3807                                      0xc0 | ((val >> 3) & 7),
3808                                      contents + rel->r_offset - 1);
3809                           break;
3810                         default:
3811                           BFD_FAIL ();
3812                           break;
3813                         }
3814                     }
3815                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3816                               contents + rel->r_offset);
3817                   continue;
3818                 }
3819               else
3820                 {
3821                   unsigned int val, type;
3822
3823                   /* {IE_32,GOTIE}->LE transition:
3824                      Originally it can be one of:
3825                      subl foo(%reg1), %reg2
3826                      movl foo(%reg1), %reg2
3827                      addl foo(%reg1), %reg2
3828                      We change it into:
3829                      subl $foo, %reg2
3830                      movl $foo, %reg2 (6 byte form)
3831                      addl $foo, %reg2.  */
3832                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3833                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3834                   if (type == 0x8b)
3835                     {
3836                       /* movl */
3837                       bfd_put_8 (output_bfd, 0xc7,
3838                                  contents + rel->r_offset - 2);
3839                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3840                                  contents + rel->r_offset - 1);
3841                     }
3842                   else if (type == 0x2b)
3843                     {
3844                       /* subl */
3845                       bfd_put_8 (output_bfd, 0x81,
3846                                  contents + rel->r_offset - 2);
3847                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3848                                  contents + rel->r_offset - 1);
3849                     }
3850                   else if (type == 0x03)
3851                     {
3852                       /* addl */
3853                       bfd_put_8 (output_bfd, 0x81,
3854                                  contents + rel->r_offset - 2);
3855                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3856                                  contents + rel->r_offset - 1);
3857                     }
3858                   else
3859                     BFD_FAIL ();
3860                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
3861                     bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3862                                 contents + rel->r_offset);
3863                   else
3864                     bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3865                                 contents + rel->r_offset);
3866                   continue;
3867                 }
3868             }
3869
3870           if (htab->elf.sgot == NULL)
3871             abort ();
3872
3873           if (h != NULL)
3874             {
3875               off = h->got.offset;
3876               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3877             }
3878           else
3879             {
3880               if (local_got_offsets == NULL)
3881                 abort ();
3882
3883               off = local_got_offsets[r_symndx];
3884               offplt = local_tlsdesc_gotents[r_symndx];
3885             }
3886
3887           if ((off & 1) != 0)
3888             off &= ~1;
3889           else
3890             {
3891               Elf_Internal_Rela outrel;
3892               bfd_byte *loc;
3893               int dr_type;
3894               asection *sreloc;
3895
3896               if (htab->elf.srelgot == NULL)
3897                 abort ();
3898
3899               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3900
3901               if (GOT_TLS_GDESC_P (tls_type))
3902                 {
3903                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
3904                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
3905                               <= htab->elf.sgotplt->size);
3906                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3907                                      + htab->elf.sgotplt->output_offset
3908                                      + offplt
3909                                      + htab->sgotplt_jump_table_size);
3910                   sreloc = htab->elf.srelplt;
3911                   loc = sreloc->contents;
3912                   loc += (htab->next_tls_desc_index++
3913                           * sizeof (Elf32_External_Rel));
3914                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3915                               <= sreloc->contents + sreloc->size);
3916                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3917                   if (indx == 0)
3918                     {
3919                       BFD_ASSERT (! unresolved_reloc);
3920                       bfd_put_32 (output_bfd,
3921                                   relocation - elf_i386_dtpoff_base (info),
3922                                   htab->elf.sgotplt->contents + offplt
3923                                   + htab->sgotplt_jump_table_size + 4);
3924                     }
3925                   else
3926                     {
3927                       bfd_put_32 (output_bfd, 0,
3928                                   htab->elf.sgotplt->contents + offplt
3929                                   + htab->sgotplt_jump_table_size + 4);
3930                     }
3931                 }
3932
3933               sreloc = htab->elf.srelgot;
3934
3935               outrel.r_offset = (htab->elf.sgot->output_section->vma
3936                                  + htab->elf.sgot->output_offset + off);
3937
3938               if (GOT_TLS_GD_P (tls_type))
3939                 dr_type = R_386_TLS_DTPMOD32;
3940               else if (GOT_TLS_GDESC_P (tls_type))
3941                 goto dr_done;
3942               else if (tls_type == GOT_TLS_IE_POS)
3943                 dr_type = R_386_TLS_TPOFF;
3944               else
3945                 dr_type = R_386_TLS_TPOFF32;
3946
3947               if (dr_type == R_386_TLS_TPOFF && indx == 0)
3948                 bfd_put_32 (output_bfd,
3949                             relocation - elf_i386_dtpoff_base (info),
3950                             htab->elf.sgot->contents + off);
3951               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
3952                 bfd_put_32 (output_bfd,
3953                             elf_i386_dtpoff_base (info) - relocation,
3954                             htab->elf.sgot->contents + off);
3955               else if (dr_type != R_386_TLS_DESC)
3956                 bfd_put_32 (output_bfd, 0,
3957                             htab->elf.sgot->contents + off);
3958               outrel.r_info = ELF32_R_INFO (indx, dr_type);
3959
3960               loc = sreloc->contents;
3961               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3962               BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3963                           <= sreloc->contents + sreloc->size);
3964               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3965
3966               if (GOT_TLS_GD_P (tls_type))
3967                 {
3968                   if (indx == 0)
3969                     {
3970                       BFD_ASSERT (! unresolved_reloc);
3971                       bfd_put_32 (output_bfd,
3972                                   relocation - elf_i386_dtpoff_base (info),
3973                                   htab->elf.sgot->contents + off + 4);
3974                     }
3975                   else
3976                     {
3977                       bfd_put_32 (output_bfd, 0,
3978                                   htab->elf.sgot->contents + off + 4);
3979                       outrel.r_info = ELF32_R_INFO (indx,
3980                                                     R_386_TLS_DTPOFF32);
3981                       outrel.r_offset += 4;
3982                       sreloc->reloc_count++;
3983                       loc += sizeof (Elf32_External_Rel);
3984                       BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3985                                   <= sreloc->contents + sreloc->size);
3986                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3987                     }
3988                 }
3989               else if (tls_type == GOT_TLS_IE_BOTH)
3990                 {
3991                   bfd_put_32 (output_bfd,
3992                               (indx == 0
3993                                ? relocation - elf_i386_dtpoff_base (info)
3994                                : 0),
3995                               htab->elf.sgot->contents + off + 4);
3996                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3997                   outrel.r_offset += 4;
3998                   sreloc->reloc_count++;
3999                   loc += sizeof (Elf32_External_Rel);
4000                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4001                 }
4002
4003             dr_done:
4004               if (h != NULL)
4005                 h->got.offset |= 1;
4006               else
4007                 local_got_offsets[r_symndx] |= 1;
4008             }
4009
4010           if (off >= (bfd_vma) -2
4011               && ! GOT_TLS_GDESC_P (tls_type))
4012             abort ();
4013           if (r_type == R_386_TLS_GOTDESC
4014               || r_type == R_386_TLS_DESC_CALL)
4015             {
4016               relocation = htab->sgotplt_jump_table_size + offplt;
4017               unresolved_reloc = FALSE;
4018             }
4019           else if (r_type == ELF32_R_TYPE (rel->r_info))
4020             {
4021               bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4022                               + htab->elf.sgotplt->output_offset;
4023               relocation = htab->elf.sgot->output_section->vma
4024                 + htab->elf.sgot->output_offset + off - g_o_t;
4025               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4026                   && tls_type == GOT_TLS_IE_BOTH)
4027                 relocation += 4;
4028               if (r_type == R_386_TLS_IE)
4029                 relocation += g_o_t;
4030               unresolved_reloc = FALSE;
4031             }
4032           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4033             {
4034               unsigned int val, type;
4035               bfd_vma roff;
4036
4037               /* GD->IE transition.  */
4038               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4039               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4040               if (type == 0x04)
4041                 {
4042                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4043                      Change it into:
4044                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4045                   val >>= 3;
4046                   roff = rel->r_offset - 3;
4047                 }
4048               else
4049                 {
4050                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4051                      Change it into:
4052                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4053                   roff = rel->r_offset - 2;
4054                 }
4055               memcpy (contents + roff,
4056                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4057               contents[roff + 7] = 0x80 | (val & 7);
4058               /* If foo is used only with foo@gotntpoff(%reg) and
4059                  foo@indntpoff, but not with foo@gottpoff(%reg), change
4060                  subl $foo@gottpoff(%reg), %eax
4061                  into:
4062                  addl $foo@gotntpoff(%reg), %eax.  */
4063               if (tls_type == GOT_TLS_IE_POS)
4064                 contents[roff + 6] = 0x03;
4065               bfd_put_32 (output_bfd,
4066                           htab->elf.sgot->output_section->vma
4067                           + htab->elf.sgot->output_offset + off
4068                           - htab->elf.sgotplt->output_section->vma
4069                           - htab->elf.sgotplt->output_offset,
4070                           contents + roff + 8);
4071               /* Skip R_386_PLT32.  */
4072               rel++;
4073               continue;
4074             }
4075           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4076             {
4077               /* GDesc -> IE transition.
4078                  It's originally something like:
4079                  leal x@tlsdesc(%ebx), %eax
4080
4081                  Change it to:
4082                  movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4083                  or:
4084                  movl x@gottpoff(%ebx), %eax # before negl %eax
4085
4086                  Registers other than %eax may be set up here.  */
4087
4088               bfd_vma roff;
4089
4090               /* First, make sure it's a leal adding ebx to a 32-bit
4091                  offset into any register, although it's probably
4092                  almost always going to be eax.  */
4093               roff = rel->r_offset;
4094
4095               /* Now modify the instruction as appropriate.  */
4096               /* To turn a leal into a movl in the form we use it, it
4097                  suffices to change the first byte from 0x8d to 0x8b.
4098                  aoliva FIXME: should we decide to keep the leal, all
4099                  we have to do is remove the statement below, and
4100                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
4101               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4102
4103               if (tls_type == GOT_TLS_IE_BOTH)
4104                 off += 4;
4105
4106               bfd_put_32 (output_bfd,
4107                           htab->elf.sgot->output_section->vma
4108                           + htab->elf.sgot->output_offset + off
4109                           - htab->elf.sgotplt->output_section->vma
4110                           - htab->elf.sgotplt->output_offset,
4111                           contents + roff);
4112               continue;
4113             }
4114           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4115             {
4116               /* GDesc -> IE transition.
4117                  It's originally:
4118                  call *(%eax)
4119
4120                  Change it to:
4121                  xchg %ax,%ax
4122                  or
4123                  negl %eax
4124                  depending on how we transformed the TLS_GOTDESC above.
4125               */
4126
4127               bfd_vma roff;
4128
4129               roff = rel->r_offset;
4130
4131               /* Now modify the instruction as appropriate.  */
4132               if (tls_type != GOT_TLS_IE_NEG)
4133                 {
4134                   /* xchg %ax,%ax */
4135                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4136                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4137                 }
4138               else
4139                 {
4140                   /* negl %eax */
4141                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
4142                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4143                 }
4144
4145               continue;
4146             }
4147           else
4148             BFD_ASSERT (FALSE);
4149           break;
4150
4151         case R_386_TLS_LDM:
4152           if (! elf_i386_tls_transition (info, input_bfd,
4153                                          input_section, contents,
4154                                          symtab_hdr, sym_hashes,
4155                                          &r_type, GOT_UNKNOWN, rel,
4156                                          relend, h, r_symndx))
4157             return FALSE;
4158
4159           if (r_type != R_386_TLS_LDM)
4160             {
4161               /* LD->LE transition:
4162                  leal foo(%reg), %eax; call ___tls_get_addr.
4163                  We change it into:
4164                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
4165               BFD_ASSERT (r_type == R_386_TLS_LE_32);
4166               memcpy (contents + rel->r_offset - 2,
4167                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4168               /* Skip R_386_PC32/R_386_PLT32.  */
4169               rel++;
4170               continue;
4171             }
4172
4173           if (htab->elf.sgot == NULL)
4174             abort ();
4175
4176           off = htab->tls_ldm_got.offset;
4177           if (off & 1)
4178             off &= ~1;
4179           else
4180             {
4181               Elf_Internal_Rela outrel;
4182               bfd_byte *loc;
4183
4184               if (htab->elf.srelgot == NULL)
4185                 abort ();
4186
4187               outrel.r_offset = (htab->elf.sgot->output_section->vma
4188                                  + htab->elf.sgot->output_offset + off);
4189
4190               bfd_put_32 (output_bfd, 0,
4191                           htab->elf.sgot->contents + off);
4192               bfd_put_32 (output_bfd, 0,
4193                           htab->elf.sgot->contents + off + 4);
4194               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4195               loc = htab->elf.srelgot->contents;
4196               loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
4197               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4198               htab->tls_ldm_got.offset |= 1;
4199             }
4200           relocation = htab->elf.sgot->output_section->vma
4201                        + htab->elf.sgot->output_offset + off
4202                        - htab->elf.sgotplt->output_section->vma
4203                        - htab->elf.sgotplt->output_offset;
4204           unresolved_reloc = FALSE;
4205           break;
4206
4207         case R_386_TLS_LDO_32:
4208           if (!info->executable || (input_section->flags & SEC_CODE) == 0)
4209             relocation -= elf_i386_dtpoff_base (info);
4210           else
4211             /* When converting LDO to LE, we must negate.  */
4212             relocation = -elf_i386_tpoff (info, relocation);
4213           break;
4214
4215         case R_386_TLS_LE_32:
4216         case R_386_TLS_LE:
4217           if (!info->executable)
4218             {
4219               Elf_Internal_Rela outrel;
4220               asection *sreloc;
4221               bfd_byte *loc;
4222
4223               outrel.r_offset = rel->r_offset
4224                                 + input_section->output_section->vma
4225                                 + input_section->output_offset;
4226               if (h != NULL && h->dynindx != -1)
4227                 indx = h->dynindx;
4228               else
4229                 indx = 0;
4230               if (r_type == R_386_TLS_LE_32)
4231                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4232               else
4233                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4234               sreloc = elf_section_data (input_section)->sreloc;
4235               if (sreloc == NULL)
4236                 abort ();
4237               loc = sreloc->contents;
4238               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
4239               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4240               if (indx)
4241                 continue;
4242               else if (r_type == R_386_TLS_LE_32)
4243                 relocation = elf_i386_dtpoff_base (info) - relocation;
4244               else
4245                 relocation -= elf_i386_dtpoff_base (info);
4246             }
4247           else if (r_type == R_386_TLS_LE_32)
4248             relocation = elf_i386_tpoff (info, relocation);
4249           else
4250             relocation = -elf_i386_tpoff (info, relocation);
4251           break;
4252
4253         default:
4254           break;
4255         }
4256
4257       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4258          because such sections are not SEC_ALLOC and thus ld.so will
4259          not process them.  */
4260       if (unresolved_reloc
4261           && !((input_section->flags & SEC_DEBUGGING) != 0
4262                && h->def_dynamic)
4263           && _bfd_elf_section_offset (output_bfd, info, input_section,
4264                                       rel->r_offset) != (bfd_vma) -1)
4265         {
4266           (*_bfd_error_handler)
4267             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4268              input_bfd,
4269              input_section,
4270              (long) rel->r_offset,
4271              howto->name,
4272              h->root.root.string);
4273           return FALSE;
4274         }
4275
4276 do_relocation:
4277       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4278                                     contents, rel->r_offset,
4279                                     relocation, 0);
4280
4281 check_relocation_error:
4282       if (r != bfd_reloc_ok)
4283         {
4284           const char *name;
4285
4286           if (h != NULL)
4287             name = h->root.root.string;
4288           else
4289             {
4290               name = bfd_elf_string_from_elf_section (input_bfd,
4291                                                       symtab_hdr->sh_link,
4292                                                       sym->st_name);
4293               if (name == NULL)
4294                 return FALSE;
4295               if (*name == '\0')
4296                 name = bfd_section_name (input_bfd, sec);
4297             }
4298
4299           if (r == bfd_reloc_overflow)
4300             {
4301               if (! ((*info->callbacks->reloc_overflow)
4302                      (info, (h ? &h->root : NULL), name, howto->name,
4303                       (bfd_vma) 0, input_bfd, input_section,
4304                       rel->r_offset)))
4305                 return FALSE;
4306             }
4307           else
4308             {
4309               (*_bfd_error_handler)
4310                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4311                  input_bfd, input_section,
4312                  (long) rel->r_offset, name, (int) r);
4313               return FALSE;
4314             }
4315         }
4316     }
4317
4318   return TRUE;
4319 }
4320
4321 /* Finish up dynamic symbol handling.  We set the contents of various
4322    dynamic sections here.  */
4323
4324 static bfd_boolean
4325 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4326                                 struct bfd_link_info *info,
4327                                 struct elf_link_hash_entry *h,
4328                                 Elf_Internal_Sym *sym)
4329 {
4330   struct elf_i386_link_hash_table *htab;
4331   unsigned plt_entry_size;
4332   const struct elf_i386_backend_data *abed;
4333
4334   htab = elf_i386_hash_table (info);
4335   if (htab == NULL)
4336     return FALSE;
4337
4338   abed = get_elf_i386_backend_data (output_bfd);
4339   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
4340
4341   if (h->plt.offset != (bfd_vma) -1)
4342     {
4343       bfd_vma plt_index;
4344       bfd_vma got_offset;
4345       Elf_Internal_Rela rel;
4346       bfd_byte *loc;
4347       asection *plt, *gotplt, *relplt;
4348
4349       /* When building a static executable, use .iplt, .igot.plt and
4350          .rel.iplt sections for STT_GNU_IFUNC symbols.  */
4351       if (htab->elf.splt != NULL)
4352         {
4353           plt = htab->elf.splt;
4354           gotplt = htab->elf.sgotplt;
4355           relplt = htab->elf.srelplt;
4356         }
4357       else
4358         {
4359           plt = htab->elf.iplt;
4360           gotplt = htab->elf.igotplt;
4361           relplt = htab->elf.irelplt;
4362         }
4363
4364       /* This symbol has an entry in the procedure linkage table.  Set
4365          it up.  */
4366
4367       if ((h->dynindx == -1
4368            && !((h->forced_local || info->executable)
4369                 && h->def_regular
4370                 && h->type == STT_GNU_IFUNC))
4371           || plt == NULL
4372           || gotplt == NULL
4373           || relplt == NULL)
4374         return FALSE;
4375
4376       /* Get the index in the procedure linkage table which
4377          corresponds to this symbol.  This is the index of this symbol
4378          in all the symbols for which we are making plt entries.  The
4379          first entry in the procedure linkage table is reserved.
4380
4381          Get the offset into the .got table of the entry that
4382          corresponds to this function.  Each .got entry is 4 bytes.
4383          The first three are reserved.
4384
4385          For static executables, we don't reserve anything.  */
4386
4387       if (plt == htab->elf.splt)
4388         {
4389           got_offset = h->plt.offset / plt_entry_size - 1;
4390           got_offset = (got_offset + 3) * 4;
4391         }
4392       else
4393         {
4394           got_offset = h->plt.offset / plt_entry_size;
4395           got_offset = got_offset * 4;
4396         }
4397
4398       /* Fill in the entry in the procedure linkage table.  */
4399       if (! info->shared)
4400         {
4401           memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
4402                   abed->plt->plt_entry_size);
4403           bfd_put_32 (output_bfd,
4404                       (gotplt->output_section->vma
4405                        + gotplt->output_offset
4406                        + got_offset),
4407                       plt->contents + h->plt.offset
4408                       + abed->plt->plt_got_offset);
4409
4410           if (abed->is_vxworks)
4411             {
4412               int s, k, reloc_index;
4413
4414               /* Create the R_386_32 relocation referencing the GOT
4415                  for this PLT entry.  */
4416
4417               /* S: Current slot number (zero-based).  */
4418               s = ((h->plt.offset - abed->plt->plt_entry_size)
4419                    / abed->plt->plt_entry_size);
4420               /* K: Number of relocations for PLTResolve. */
4421               if (info->shared)
4422                 k = PLTRESOLVE_RELOCS_SHLIB;
4423               else
4424                 k = PLTRESOLVE_RELOCS;
4425               /* Skip the PLTresolve relocations, and the relocations for
4426                  the other PLT slots. */
4427               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4428               loc = (htab->srelplt2->contents + reloc_index
4429                      * sizeof (Elf32_External_Rel));
4430
4431               rel.r_offset = (htab->elf.splt->output_section->vma
4432                               + htab->elf.splt->output_offset
4433                               + h->plt.offset + 2),
4434               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4435               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4436
4437               /* Create the R_386_32 relocation referencing the beginning of
4438                  the PLT for this GOT entry.  */
4439               rel.r_offset = (htab->elf.sgotplt->output_section->vma
4440                               + htab->elf.sgotplt->output_offset
4441                               + got_offset);
4442               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4443               bfd_elf32_swap_reloc_out (output_bfd, &rel,
4444               loc + sizeof (Elf32_External_Rel));
4445             }
4446         }
4447       else
4448         {
4449           memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
4450                   abed->plt->plt_entry_size);
4451           bfd_put_32 (output_bfd, got_offset,
4452                       plt->contents + h->plt.offset
4453                       + abed->plt->plt_got_offset);
4454         }
4455
4456       /* Fill in the entry in the global offset table.  */
4457       bfd_put_32 (output_bfd,
4458                   (plt->output_section->vma
4459                    + plt->output_offset
4460                    + h->plt.offset
4461                    + abed->plt->plt_lazy_offset),
4462                   gotplt->contents + got_offset);
4463
4464       /* Fill in the entry in the .rel.plt section.  */
4465       rel.r_offset = (gotplt->output_section->vma
4466                       + gotplt->output_offset
4467                       + got_offset);
4468       if (h->dynindx == -1
4469           || ((info->executable
4470                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4471               && h->def_regular
4472                && h->type == STT_GNU_IFUNC))
4473         {
4474           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4475              R_386_IRELATIVE instead of R_386_JUMP_SLOT.  Store addend
4476              in the .got.plt section.  */
4477           bfd_put_32 (output_bfd,
4478                       (h->root.u.def.value
4479                        + h->root.u.def.section->output_section->vma
4480                        + h->root.u.def.section->output_offset),
4481                       gotplt->contents + got_offset);
4482           rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4483           /* R_386_IRELATIVE comes last.  */
4484           plt_index = htab->next_irelative_index--;
4485         }
4486       else
4487         {
4488           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
4489           plt_index = htab->next_jump_slot_index++;
4490         }
4491       loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
4492       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4493
4494       /* Don't fill PLT entry for static executables.  */
4495       if (plt == htab->elf.splt)
4496         {
4497           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
4498                       plt->contents + h->plt.offset
4499                       + abed->plt->plt_reloc_offset);
4500           bfd_put_32 (output_bfd, - (h->plt.offset
4501                                      + abed->plt->plt_plt_offset + 4),
4502                       plt->contents + h->plt.offset
4503                       + abed->plt->plt_plt_offset);
4504         }
4505
4506       if (!h->def_regular)
4507         {
4508           /* Mark the symbol as undefined, rather than as defined in
4509              the .plt section.  Leave the value if there were any
4510              relocations where pointer equality matters (this is a clue
4511              for the dynamic linker, to make function pointer
4512              comparisons work between an application and shared
4513              library), otherwise set it to zero.  If a function is only
4514              called from a binary, there is no need to slow down
4515              shared libraries because of that.  */
4516           sym->st_shndx = SHN_UNDEF;
4517           if (!h->pointer_equality_needed)
4518             sym->st_value = 0;
4519         }
4520     }
4521
4522   if (h->got.offset != (bfd_vma) -1
4523       && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
4524       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
4525     {
4526       Elf_Internal_Rela rel;
4527       bfd_byte *loc;
4528
4529       /* This symbol has an entry in the global offset table.  Set it
4530          up.  */
4531
4532       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4533         abort ();
4534
4535       rel.r_offset = (htab->elf.sgot->output_section->vma
4536                       + htab->elf.sgot->output_offset
4537                       + (h->got.offset & ~(bfd_vma) 1));
4538
4539       /* If this is a static link, or it is a -Bsymbolic link and the
4540          symbol is defined locally or was forced to be local because
4541          of a version file, we just want to emit a RELATIVE reloc.
4542          The entry in the global offset table will already have been
4543          initialized in the relocate_section function.  */
4544       if (h->def_regular
4545           && h->type == STT_GNU_IFUNC)
4546         {
4547           if (info->shared)
4548             {
4549               /* Generate R_386_GLOB_DAT.  */
4550               goto do_glob_dat;
4551             }
4552           else
4553             {
4554               asection *plt;
4555
4556               if (!h->pointer_equality_needed)
4557                 abort ();
4558
4559               /* For non-shared object, we can't use .got.plt, which
4560                  contains the real function addres if we need pointer
4561                  equality.  We load the GOT entry with the PLT entry.  */
4562               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4563               bfd_put_32 (output_bfd,
4564                           (plt->output_section->vma
4565                            + plt->output_offset + h->plt.offset),
4566                           htab->elf.sgot->contents + h->got.offset);
4567               return TRUE;
4568             }
4569         }
4570       else if (info->shared
4571                && SYMBOL_REFERENCES_LOCAL (info, h))
4572         {
4573           BFD_ASSERT((h->got.offset & 1) != 0);
4574           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4575         }
4576       else
4577         {
4578           BFD_ASSERT((h->got.offset & 1) == 0);
4579 do_glob_dat:
4580           bfd_put_32 (output_bfd, (bfd_vma) 0,
4581                       htab->elf.sgot->contents + h->got.offset);
4582           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
4583         }
4584
4585       loc = htab->elf.srelgot->contents;
4586       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
4587       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4588     }
4589
4590   if (h->needs_copy)
4591     {
4592       Elf_Internal_Rela rel;
4593       bfd_byte *loc;
4594
4595       /* This symbol needs a copy reloc.  Set it up.  */
4596
4597       if (h->dynindx == -1
4598           || (h->root.type != bfd_link_hash_defined
4599               && h->root.type != bfd_link_hash_defweak)
4600           || htab->srelbss == NULL)
4601         abort ();
4602
4603       rel.r_offset = (h->root.u.def.value
4604                       + h->root.u.def.section->output_section->vma
4605                       + h->root.u.def.section->output_offset);
4606       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
4607       loc = htab->srelbss->contents;
4608       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
4609       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4610     }
4611
4612   return TRUE;
4613 }
4614
4615 /* Finish up local dynamic symbol handling.  We set the contents of
4616    various dynamic sections here.  */
4617
4618 static bfd_boolean
4619 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
4620 {
4621   struct elf_link_hash_entry *h
4622     = (struct elf_link_hash_entry *) *slot;
4623   struct bfd_link_info *info
4624     = (struct bfd_link_info *) inf;
4625
4626   return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
4627                                          h, NULL);
4628 }
4629
4630 /* Used to decide how to sort relocs in an optimal manner for the
4631    dynamic linker, before writing them out.  */
4632
4633 static enum elf_reloc_type_class
4634 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
4635 {
4636   switch (ELF32_R_TYPE (rela->r_info))
4637     {
4638     case R_386_RELATIVE:
4639       return reloc_class_relative;
4640     case R_386_JUMP_SLOT:
4641       return reloc_class_plt;
4642     case R_386_COPY:
4643       return reloc_class_copy;
4644     default:
4645       return reloc_class_normal;
4646     }
4647 }
4648
4649 /* Finish up the dynamic sections.  */
4650
4651 static bfd_boolean
4652 elf_i386_finish_dynamic_sections (bfd *output_bfd,
4653                                   struct bfd_link_info *info)
4654 {
4655   struct elf_i386_link_hash_table *htab;
4656   bfd *dynobj;
4657   asection *sdyn;
4658   const struct elf_i386_backend_data *abed;
4659
4660   htab = elf_i386_hash_table (info);
4661   if (htab == NULL)
4662     return FALSE;
4663
4664   dynobj = htab->elf.dynobj;
4665   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4666   abed = get_elf_i386_backend_data (output_bfd);
4667
4668   if (htab->elf.dynamic_sections_created)
4669     {
4670       Elf32_External_Dyn *dyncon, *dynconend;
4671
4672       if (sdyn == NULL || htab->elf.sgot == NULL)
4673         abort ();
4674
4675       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4676       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4677       for (; dyncon < dynconend; dyncon++)
4678         {
4679           Elf_Internal_Dyn dyn;
4680           asection *s;
4681
4682           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4683
4684           switch (dyn.d_tag)
4685             {
4686             default:
4687               if (abed->is_vxworks
4688                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4689                 break;
4690               continue;
4691
4692             case DT_PLTGOT:
4693               s = htab->elf.sgotplt;
4694               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4695               break;
4696
4697             case DT_JMPREL:
4698               s = htab->elf.srelplt;
4699               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4700               break;
4701
4702             case DT_PLTRELSZ:
4703               s = htab->elf.srelplt;
4704               dyn.d_un.d_val = s->size;
4705               break;
4706
4707             case DT_RELSZ:
4708               /* My reading of the SVR4 ABI indicates that the
4709                  procedure linkage table relocs (DT_JMPREL) should be
4710                  included in the overall relocs (DT_REL).  This is
4711                  what Solaris does.  However, UnixWare can not handle
4712                  that case.  Therefore, we override the DT_RELSZ entry
4713                  here to make it not include the JMPREL relocs.  */
4714               s = htab->elf.srelplt;
4715               if (s == NULL)
4716                 continue;
4717               dyn.d_un.d_val -= s->size;
4718               break;
4719
4720             case DT_REL:
4721               /* We may not be using the standard ELF linker script.
4722                  If .rel.plt is the first .rel section, we adjust
4723                  DT_REL to not include it.  */
4724               s = htab->elf.srelplt;
4725               if (s == NULL)
4726                 continue;
4727               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4728                 continue;
4729               dyn.d_un.d_ptr += s->size;
4730               break;
4731             }
4732
4733           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4734         }
4735
4736       /* Fill in the first entry in the procedure linkage table.  */
4737       if (htab->elf.splt && htab->elf.splt->size > 0)
4738         {
4739           if (info->shared)
4740             {
4741               memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
4742                       abed->plt->plt0_entry_size);
4743               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4744                       abed->plt0_pad_byte,
4745                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4746             }
4747           else
4748             {
4749               memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
4750                       abed->plt->plt0_entry_size);
4751               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4752                       abed->plt0_pad_byte,
4753                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4754               bfd_put_32 (output_bfd,
4755                           (htab->elf.sgotplt->output_section->vma
4756                            + htab->elf.sgotplt->output_offset
4757                            + 4),
4758                           htab->elf.splt->contents
4759                           + abed->plt->plt0_got1_offset);
4760               bfd_put_32 (output_bfd,
4761                           (htab->elf.sgotplt->output_section->vma
4762                            + htab->elf.sgotplt->output_offset
4763                            + 8),
4764                           htab->elf.splt->contents
4765                           + abed->plt->plt0_got2_offset);
4766
4767               if (abed->is_vxworks)
4768                 {
4769                   Elf_Internal_Rela rel;
4770
4771                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4772                      On IA32 we use REL relocations so the addend goes in
4773                      the PLT directly.  */
4774                   rel.r_offset = (htab->elf.splt->output_section->vma
4775                                   + htab->elf.splt->output_offset
4776                                   + abed->plt->plt0_got1_offset);
4777                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4778                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4779                                             htab->srelplt2->contents);
4780                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
4781                   rel.r_offset = (htab->elf.splt->output_section->vma
4782                                   + htab->elf.splt->output_offset
4783                                   + abed->plt->plt0_got2_offset);
4784                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4785                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4786                                             htab->srelplt2->contents +
4787                                             sizeof (Elf32_External_Rel));
4788                 }
4789             }
4790
4791           /* UnixWare sets the entsize of .plt to 4, although that doesn't
4792              really seem like the right value.  */
4793           elf_section_data (htab->elf.splt->output_section)
4794             ->this_hdr.sh_entsize = 4;
4795
4796           /* Correct the .rel.plt.unloaded relocations.  */
4797           if (abed->is_vxworks && !info->shared)
4798             {
4799               int num_plts = (htab->elf.splt->size
4800                               / abed->plt->plt_entry_size) - 1;
4801               unsigned char *p;
4802
4803               p = htab->srelplt2->contents;
4804               if (info->shared)
4805                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4806               else
4807                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4808
4809               for (; num_plts; num_plts--)
4810                 {
4811                   Elf_Internal_Rela rel;
4812                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4813                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4814                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4815                   p += sizeof (Elf32_External_Rel);
4816
4817                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4818                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4819                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4820                   p += sizeof (Elf32_External_Rel);
4821                 }
4822             }
4823         }
4824     }
4825
4826   if (htab->elf.sgotplt)
4827     {
4828       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4829         {
4830           (*_bfd_error_handler)
4831             (_("discarded output section: `%A'"), htab->elf.sgotplt);
4832           return FALSE;
4833         }
4834
4835       /* Fill in the first three entries in the global offset table.  */
4836       if (htab->elf.sgotplt->size > 0)
4837         {
4838           bfd_put_32 (output_bfd,
4839                       (sdyn == NULL ? 0
4840                        : sdyn->output_section->vma + sdyn->output_offset),
4841                       htab->elf.sgotplt->contents);
4842           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
4843           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
4844         }
4845
4846       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
4847     }
4848
4849   /* Adjust .eh_frame for .plt section.  */
4850   if (htab->plt_eh_frame != NULL
4851       && htab->plt_eh_frame->contents != NULL)
4852     {
4853       if (htab->elf.splt != NULL
4854           && htab->elf.splt->size != 0
4855           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4856           && htab->elf.splt->output_section != NULL
4857           && htab->plt_eh_frame->output_section != NULL)
4858         {
4859           bfd_vma plt_start = htab->elf.splt->output_section->vma;
4860           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4861                                    + htab->plt_eh_frame->output_offset
4862                                    + PLT_FDE_START_OFFSET;
4863           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4864                              htab->plt_eh_frame->contents
4865                              + PLT_FDE_START_OFFSET);
4866         }
4867       if (htab->plt_eh_frame->sec_info_type
4868           == SEC_INFO_TYPE_EH_FRAME)
4869         {
4870           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4871                                                  htab->plt_eh_frame,
4872                                                  htab->plt_eh_frame->contents))
4873             return FALSE;
4874         }
4875     }
4876
4877   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4878     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
4879
4880   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4881   htab_traverse (htab->loc_hash_table,
4882                  elf_i386_finish_local_dynamic_symbol,
4883                  info);
4884
4885   return TRUE;
4886 }
4887
4888 /* Return address for Ith PLT stub in section PLT, for relocation REL
4889    or (bfd_vma) -1 if it should not be included.  */
4890
4891 static bfd_vma
4892 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
4893                       const arelent *rel ATTRIBUTE_UNUSED)
4894 {
4895   return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4896 }
4897
4898 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
4899
4900 static bfd_boolean
4901 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
4902 {
4903   if (h->plt.offset != (bfd_vma) -1
4904       && !h->def_regular
4905       && !h->pointer_equality_needed)
4906     return FALSE;
4907
4908   return _bfd_elf_hash_symbol (h);
4909 }
4910
4911 /* Hook called by the linker routine which adds symbols from an object
4912    file.  */
4913
4914 static bfd_boolean
4915 elf_i386_add_symbol_hook (bfd * abfd,
4916                           struct bfd_link_info * info ATTRIBUTE_UNUSED,
4917                           Elf_Internal_Sym * sym,
4918                           const char ** namep ATTRIBUTE_UNUSED,
4919                           flagword * flagsp ATTRIBUTE_UNUSED,
4920                           asection ** secp ATTRIBUTE_UNUSED,
4921                           bfd_vma * valp ATTRIBUTE_UNUSED)
4922 {
4923   if ((abfd->flags & DYNAMIC) == 0
4924       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4925           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4926     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4927
4928   return TRUE;
4929 }
4930
4931 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
4932 #define TARGET_LITTLE_NAME              "elf32-i386"
4933 #define ELF_ARCH                        bfd_arch_i386
4934 #define ELF_TARGET_ID                   I386_ELF_DATA
4935 #define ELF_MACHINE_CODE                EM_386
4936 #define ELF_MAXPAGESIZE                 0x1000
4937
4938 #define elf_backend_can_gc_sections     1
4939 #define elf_backend_can_refcount        1
4940 #define elf_backend_want_got_plt        1
4941 #define elf_backend_plt_readonly        1
4942 #define elf_backend_want_plt_sym        0
4943 #define elf_backend_got_header_size     12
4944 #define elf_backend_plt_alignment       4
4945
4946 /* Support RELA for objdump of prelink objects.  */
4947 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
4948 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
4949
4950 #define bfd_elf32_mkobject                    elf_i386_mkobject
4951
4952 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
4953 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
4954 #define bfd_elf32_bfd_link_hash_table_free    elf_i386_link_hash_table_free
4955 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
4956 #define bfd_elf32_bfd_reloc_name_lookup       elf_i386_reloc_name_lookup
4957
4958 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
4959 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
4960 #define elf_backend_check_relocs              elf_i386_check_relocs
4961 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
4962 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
4963 #define elf_backend_fake_sections             elf_i386_fake_sections
4964 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
4965 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
4966 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
4967 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
4968 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
4969 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
4970 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
4971 #define elf_backend_relocate_section          elf_i386_relocate_section
4972 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
4973 #define elf_backend_always_size_sections      elf_i386_always_size_sections
4974 #define elf_backend_omit_section_dynsym \
4975   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4976 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
4977 #define elf_backend_hash_symbol               elf_i386_hash_symbol
4978 #define elf_backend_add_symbol_hook           elf_i386_add_symbol_hook
4979 #undef  elf_backend_post_process_headers
4980 #define elf_backend_post_process_headers        _bfd_elf_set_osabi
4981
4982 #include "elf32-target.h"
4983
4984 /* FreeBSD support.  */
4985
4986 #undef  TARGET_LITTLE_SYM
4987 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
4988 #undef  TARGET_LITTLE_NAME
4989 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
4990 #undef  ELF_OSABI
4991 #define ELF_OSABI                       ELFOSABI_FREEBSD
4992
4993 /* The kernel recognizes executables as valid only if they carry a
4994    "FreeBSD" label in the ELF header.  So we put this label on all
4995    executables and (for simplicity) also all other object files.  */
4996
4997 static void
4998 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
4999 {
5000   _bfd_elf_set_osabi (abfd, info);
5001
5002 #ifdef OLD_FREEBSD_ABI_LABEL
5003   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
5004   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5005 #endif
5006 }
5007
5008 #undef  elf_backend_post_process_headers
5009 #define elf_backend_post_process_headers        elf_i386_fbsd_post_process_headers
5010 #undef  elf32_bed
5011 #define elf32_bed                               elf32_i386_fbsd_bed
5012
5013 #undef elf_backend_add_symbol_hook
5014
5015 #include "elf32-target.h"
5016
5017 /* Solaris 2.  */
5018
5019 #undef  TARGET_LITTLE_SYM
5020 #define TARGET_LITTLE_SYM               bfd_elf32_i386_sol2_vec
5021 #undef  TARGET_LITTLE_NAME
5022 #define TARGET_LITTLE_NAME              "elf32-i386-sol2"
5023
5024 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5025    objects won't be recognized.  */
5026 #undef ELF_OSABI
5027
5028 #undef  elf32_bed
5029 #define elf32_bed                       elf32_i386_sol2_bed
5030
5031 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5032    boundary.  */
5033 #undef elf_backend_static_tls_alignment
5034 #define elf_backend_static_tls_alignment 8
5035
5036 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5037
5038    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5039    File, p.63.  */
5040 #undef elf_backend_want_plt_sym
5041 #define elf_backend_want_plt_sym        1
5042
5043 #include "elf32-target.h"
5044
5045 /* Native Client support.  */
5046
5047 #undef  TARGET_LITTLE_SYM
5048 #define TARGET_LITTLE_SYM               bfd_elf32_i386_nacl_vec
5049 #undef  TARGET_LITTLE_NAME
5050 #define TARGET_LITTLE_NAME              "elf32-i386-nacl"
5051 #undef  elf32_bed
5052 #define elf32_bed                       elf32_i386_nacl_bed
5053
5054 #undef  ELF_MAXPAGESIZE
5055 #define ELF_MAXPAGESIZE                 0x10000
5056
5057 /* Restore defaults.  */
5058 #undef  ELF_OSABI
5059 #undef  elf_backend_want_plt_sym
5060 #define elf_backend_want_plt_sym        0
5061 #undef  elf_backend_post_process_headers
5062 #define elf_backend_post_process_headers        _bfd_elf_set_osabi
5063 #undef  elf_backend_static_tls_alignment
5064
5065 /* NaCl uses substantially different PLT entries for the same effects.  */
5066
5067 #undef  elf_backend_plt_alignment
5068 #define elf_backend_plt_alignment       5
5069 #define NACL_PLT_ENTRY_SIZE             64
5070 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5071
5072 static const bfd_byte elf_i386_nacl_plt0_entry[] =
5073   {
5074     0xff, 0x35,                   /* pushl contents of address */
5075     0, 0, 0, 0,                   /* replaced with address of .got + 4.  */
5076     0x8b, 0x0d,                   /* movl contents of address, %ecx */
5077     0, 0, 0, 0,                   /* replaced with address of .got + 8.  */
5078     0x83, 0xe1, NACLMASK,         /* andl $NACLMASK, %ecx */
5079     0xff, 0xe1                    /* jmp *%ecx */
5080   };
5081
5082 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5083   {
5084     0x8b, 0x0d,                         /* movl contents of address, %ecx */
5085     0, 0, 0, 0,                         /* replaced with GOT slot address.  */
5086     0x83, 0xe1, NACLMASK,               /* andl $NACLMASK, %ecx */
5087     0xff, 0xe1,                         /* jmp *%ecx */
5088
5089     /* Pad to the next 32-byte boundary with nop instructions.  */
5090     0x90,
5091     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5092     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5093
5094     /* Lazy GOT entries point here (32-byte aligned).  */
5095     0x68,                              /* pushl immediate */
5096     0, 0, 0, 0,                        /* replaced with reloc offset.  */
5097     0xe9,                              /* jmp relative */
5098     0, 0, 0, 0,                        /* replaced with offset to .plt.  */
5099
5100     /* Pad to the next 32-byte boundary with nop instructions.  */
5101     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5102     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5103     0x90, 0x90
5104   };
5105
5106 static const bfd_byte
5107 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
5108   {
5109     0xff, 0x73, 0x04,           /* pushl 4(%ebx) */
5110     0x8b, 0x4b, 0x08,           /* mov 0x8(%ebx), %ecx */
5111     0x83, 0xe1, 0xe0,           /* and $NACLMASK, %ecx */
5112     0xff, 0xe1,                 /* jmp *%ecx */
5113
5114     /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5115        so pad to that size with nop instructions.  */
5116     0x90, 0x90, 0x90, 0x90, 0x90, 0x90
5117   };
5118
5119 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
5120   {
5121     0x8b, 0x8b,          /* movl offset(%ebx), %ecx */
5122     0, 0, 0, 0,          /* replaced with offset of this symbol in .got.  */
5123     0x83, 0xe1, 0xe0,    /* andl $NACLMASK, %ecx */
5124     0xff, 0xe1,          /* jmp *%ecx */
5125
5126     /* Pad to the next 32-byte boundary with nop instructions.  */
5127     0x90,
5128     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5129     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5130
5131     /* Lazy GOT entries point here (32-byte aligned).  */
5132     0x68,                /* pushl immediate */
5133     0, 0, 0, 0,          /* replaced with offset into relocation table.  */
5134     0xe9,                /* jmp relative */
5135     0, 0, 0, 0,          /* replaced with offset to start of .plt.  */
5136
5137     /* Pad to the next 32-byte boundary with nop instructions.  */
5138     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5139     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5140     0x90, 0x90
5141   };
5142
5143 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
5144   {
5145 #if (PLT_CIE_LENGTH != 20                               \
5146      || PLT_FDE_LENGTH != 36                            \
5147      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5148      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5149 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
5150 #endif
5151     PLT_CIE_LENGTH, 0, 0, 0,            /* CIE length */
5152     0, 0, 0, 0,                         /* CIE ID */
5153     1,                                  /* CIE version */
5154     'z', 'R', 0,                        /* Augmentation string */
5155     1,                                  /* Code alignment factor */
5156     0x7c,                               /* Data alignment factor: -4 */
5157     8,                                  /* Return address column */
5158     1,                                  /* Augmentation size */
5159     DW_EH_PE_pcrel | DW_EH_PE_sdata4,   /* FDE encoding */
5160     DW_CFA_def_cfa, 4, 4,               /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
5161     DW_CFA_offset + 8, 1,               /* DW_CFA_offset: r8 (eip) at cfa-4 */
5162     DW_CFA_nop, DW_CFA_nop,
5163
5164     PLT_FDE_LENGTH, 0, 0, 0,     /* FDE length */
5165     PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
5166     0, 0, 0, 0,                  /* R_386_PC32 .plt goes here */
5167     0, 0, 0, 0,                  /* .plt size goes here */
5168     0,                           /* Augmentation size */
5169     DW_CFA_def_cfa_offset, 8,    /* DW_CFA_def_cfa_offset: 8 */
5170     DW_CFA_advance_loc + 6,      /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5171     DW_CFA_def_cfa_offset, 12,   /* DW_CFA_def_cfa_offset: 12 */
5172     DW_CFA_advance_loc + 58,     /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5173     DW_CFA_def_cfa_expression,   /* DW_CFA_def_cfa_expression */
5174     13,                          /* Block length */
5175     DW_OP_breg4, 4,              /* DW_OP_breg4 (esp): 4 */
5176     DW_OP_breg8, 0,              /* DW_OP_breg8 (eip): 0 */
5177     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5178     DW_OP_lit2, DW_OP_shl, DW_OP_plus,
5179     DW_CFA_nop, DW_CFA_nop
5180   };
5181
5182 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
5183   {
5184     elf_i386_nacl_plt0_entry,           /* plt0_entry */
5185     sizeof (elf_i386_nacl_plt0_entry),  /* plt0_entry_size */
5186     2,                                  /* plt0_got1_offset */
5187     8,                                  /* plt0_got2_offset */
5188     elf_i386_nacl_plt_entry,            /* plt_entry */
5189     NACL_PLT_ENTRY_SIZE,                /* plt_entry_size */
5190     2,                                  /* plt_got_offset */
5191     33,                                 /* plt_reloc_offset */
5192     38,                                 /* plt_plt_offset */
5193     32,                                 /* plt_lazy_offset */
5194     elf_i386_nacl_pic_plt0_entry,       /* pic_plt0_entry */
5195     elf_i386_nacl_pic_plt_entry,        /* pic_plt_entry */
5196     elf_i386_nacl_eh_frame_plt,         /* eh_frame_plt */
5197     sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
5198   };
5199
5200 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
5201   {
5202     &elf_i386_nacl_plt,                      /* plt */
5203     0x90,                               /* plt0_pad_byte: nop insn */
5204     0,                                  /* is_vxworks */
5205   };
5206
5207 #undef  elf_backend_arch_data
5208 #define elf_backend_arch_data   &elf_i386_nacl_arch_bed
5209
5210 #undef  elf_backend_modify_segment_map
5211 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5212 #undef  elf_backend_modify_program_headers
5213 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5214
5215 #include "elf32-target.h"
5216
5217 /* Restore defaults.  */
5218 #undef  elf_backend_modify_segment_map
5219 #undef  elf_backend_modify_program_headers
5220
5221 /* VxWorks support.  */
5222
5223 #undef  TARGET_LITTLE_SYM
5224 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
5225 #undef  TARGET_LITTLE_NAME
5226 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
5227 #undef  ELF_OSABI
5228 #undef  elf_backend_plt_alignment
5229 #define elf_backend_plt_alignment       4
5230
5231 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
5232   {
5233     &elf_i386_plt,                      /* plt */
5234     0x90,                               /* plt0_pad_byte */
5235     1,                                  /* is_vxworks */
5236   };
5237
5238 #undef  elf_backend_arch_data
5239 #define elf_backend_arch_data   &elf_i386_vxworks_arch_bed
5240
5241 #undef elf_backend_relocs_compatible
5242 #undef elf_backend_post_process_headers
5243 #undef elf_backend_add_symbol_hook
5244 #define elf_backend_add_symbol_hook \
5245   elf_vxworks_add_symbol_hook
5246 #undef elf_backend_link_output_symbol_hook
5247 #define elf_backend_link_output_symbol_hook \
5248   elf_vxworks_link_output_symbol_hook
5249 #undef elf_backend_emit_relocs
5250 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
5251 #undef elf_backend_final_write_processing
5252 #define elf_backend_final_write_processing \
5253   elf_vxworks_final_write_processing
5254 #undef elf_backend_static_tls_alignment
5255
5256 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
5257    define it.  */
5258 #undef elf_backend_want_plt_sym
5259 #define elf_backend_want_plt_sym        1
5260
5261 #undef  elf32_bed
5262 #define elf32_bed                               elf32_i386_vxworks_bed
5263
5264 #include "elf32-target.h"