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 /* Convert
2540    mov foo@GOT(%reg), %reg
2541    to
2542    lea foo@GOTOFF(%reg), %reg
2543    with the local symbol, foo.  */
2544
2545 static bfd_boolean
2546 elf_i386_convert_mov_to_lea (bfd *abfd, asection *sec,
2547                              struct bfd_link_info *link_info)
2548 {
2549   Elf_Internal_Shdr *symtab_hdr;
2550   Elf_Internal_Rela *internal_relocs;
2551   Elf_Internal_Rela *irel, *irelend;
2552   bfd_byte *contents;
2553   struct elf_i386_link_hash_table *htab;
2554   bfd_boolean changed_contents;
2555   bfd_boolean changed_relocs;
2556   bfd_signed_vma *local_got_refcounts;
2557
2558   /* Don't even try to convert non-ELF outputs.  */
2559   if (!is_elf_hash_table (link_info->hash))
2560     return FALSE;
2561
2562   /* Nothing to do if there are no codes or no relocations.  */
2563   if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2564       || sec->reloc_count == 0)
2565     return TRUE;
2566
2567   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2568
2569   /* Load the relocations for this section.  */
2570   internal_relocs = (_bfd_elf_link_read_relocs
2571                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2572                       link_info->keep_memory));
2573   if (internal_relocs == NULL)
2574     return FALSE;
2575
2576   htab = elf_i386_hash_table (link_info);
2577   changed_contents = FALSE;
2578   changed_relocs = FALSE;
2579   local_got_refcounts = elf_local_got_refcounts (abfd);
2580
2581   /* Get the section contents.  */
2582   if (elf_section_data (sec)->this_hdr.contents != NULL)
2583     contents = elf_section_data (sec)->this_hdr.contents;
2584   else
2585     {
2586       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2587         goto error_return;
2588     }
2589
2590   irelend = internal_relocs + sec->reloc_count;
2591   for (irel = internal_relocs; irel < irelend; irel++)
2592     {
2593       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2594       unsigned int r_symndx = ELF32_R_SYM (irel->r_info);
2595       unsigned int indx;
2596       struct elf_link_hash_entry *h;
2597
2598       if (r_type != R_386_GOT32)
2599         continue;
2600
2601       /* Get the symbol referred to by the reloc.  */
2602       if (r_symndx < symtab_hdr->sh_info)
2603         {
2604           Elf_Internal_Sym *isym;
2605
2606           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2607                                         abfd, r_symndx);
2608
2609           /* STT_GNU_IFUNC must keep R_386_GOT32 relocation.  */
2610           if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2611               && bfd_get_8 (input_bfd,
2612                             contents + irel->r_offset - 2) == 0x8b)
2613             {
2614               bfd_put_8 (output_bfd, 0x8d,
2615                          contents + irel->r_offset - 2);
2616               irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2617               if (local_got_refcounts != NULL
2618                   && local_got_refcounts[r_symndx] > 0)
2619                 local_got_refcounts[r_symndx] -= 1;
2620               changed_contents = TRUE;
2621               changed_relocs = TRUE;
2622             }
2623           continue;
2624         }
2625
2626       indx = r_symndx - symtab_hdr->sh_info;
2627       h = elf_sym_hashes (abfd)[indx];
2628       BFD_ASSERT (h != NULL);
2629
2630       while (h->root.type == bfd_link_hash_indirect
2631              || h->root.type == bfd_link_hash_warning)
2632         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2633
2634       /* STT_GNU_IFUNC must keep R_386_GOT32 relocation.  We also avoid
2635          optimizing _DYNAMIC since ld.so may use its link-time address.  */
2636       if (h->def_regular
2637           && h->type != STT_GNU_IFUNC
2638           && h != htab->elf.hdynamic
2639           && SYMBOL_REFERENCES_LOCAL (link_info, h)
2640           && bfd_get_8 (input_bfd,
2641                         contents + irel->r_offset - 2) == 0x8b)
2642         {
2643           bfd_put_8 (output_bfd, 0x8d,
2644                      contents + irel->r_offset - 2);
2645           irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2646           if (h->got.refcount > 0)
2647             h->got.refcount -= 1;
2648           changed_contents = TRUE;
2649           changed_relocs = TRUE;
2650         }
2651     }
2652
2653   if (contents != NULL
2654       && elf_section_data (sec)->this_hdr.contents != contents)
2655     {
2656       if (!changed_contents && !link_info->keep_memory)
2657         free (contents);
2658       else
2659         {
2660           /* Cache the section contents for elf_link_input_bfd.  */
2661           elf_section_data (sec)->this_hdr.contents = contents;
2662         }
2663     }
2664
2665   if (elf_section_data (sec)->relocs != internal_relocs)
2666     {
2667       if (!changed_relocs)
2668         free (internal_relocs);
2669       else
2670         elf_section_data (sec)->relocs = internal_relocs;
2671     }
2672
2673   return TRUE;
2674
2675  error_return:
2676   if (contents != NULL
2677       && elf_section_data (sec)->this_hdr.contents != contents)
2678     free (contents);
2679   if (internal_relocs != NULL
2680       && elf_section_data (sec)->relocs != internal_relocs)
2681     free (internal_relocs);
2682   return FALSE;
2683 }
2684
2685 /* Set the sizes of the dynamic sections.  */
2686
2687 static bfd_boolean
2688 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2689 {
2690   struct elf_i386_link_hash_table *htab;
2691   bfd *dynobj;
2692   asection *s;
2693   bfd_boolean relocs;
2694   bfd *ibfd;
2695
2696   htab = elf_i386_hash_table (info);
2697   if (htab == NULL)
2698     return FALSE;
2699   dynobj = htab->elf.dynobj;
2700   if (dynobj == NULL)
2701     abort ();
2702
2703   if (htab->elf.dynamic_sections_created)
2704     {
2705       /* Set the contents of the .interp section to the interpreter.  */
2706       if (info->executable)
2707         {
2708           s = bfd_get_linker_section (dynobj, ".interp");
2709           if (s == NULL)
2710             abort ();
2711           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2712           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2713         }
2714     }
2715
2716   /* Set up .got offsets for local syms, and space for local dynamic
2717      relocs.  */
2718   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2719     {
2720       bfd_signed_vma *local_got;
2721       bfd_signed_vma *end_local_got;
2722       char *local_tls_type;
2723       bfd_vma *local_tlsdesc_gotent;
2724       bfd_size_type locsymcount;
2725       Elf_Internal_Shdr *symtab_hdr;
2726       asection *srel;
2727
2728       if (! is_i386_elf (ibfd))
2729         continue;
2730
2731       for (s = ibfd->sections; s != NULL; s = s->next)
2732         {
2733           struct elf_dyn_relocs *p;
2734
2735           if (!elf_i386_convert_mov_to_lea (ibfd, s, info))
2736             return FALSE;
2737
2738           for (p = ((struct elf_dyn_relocs *)
2739                      elf_section_data (s)->local_dynrel);
2740                p != NULL;
2741                p = p->next)
2742             {
2743               if (!bfd_is_abs_section (p->sec)
2744                   && bfd_is_abs_section (p->sec->output_section))
2745                 {
2746                   /* Input section has been discarded, either because
2747                      it is a copy of a linkonce section or due to
2748                      linker script /DISCARD/, so we'll be discarding
2749                      the relocs too.  */
2750                 }
2751               else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2752                        && strcmp (p->sec->output_section->name,
2753                                   ".tls_vars") == 0)
2754                 {
2755                   /* Relocations in vxworks .tls_vars sections are
2756                      handled specially by the loader.  */
2757                 }
2758               else if (p->count != 0)
2759                 {
2760                   srel = elf_section_data (p->sec)->sreloc;
2761                   srel->size += p->count * sizeof (Elf32_External_Rel);
2762                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2763                       && (info->flags & DF_TEXTREL) == 0)
2764                     {
2765                       info->flags |= DF_TEXTREL;
2766                       if (info->warn_shared_textrel && info->shared)
2767                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2768                                                 p->sec->owner, p->sec);
2769                     }
2770                 }
2771             }
2772         }
2773
2774       local_got = elf_local_got_refcounts (ibfd);
2775       if (!local_got)
2776         continue;
2777
2778       symtab_hdr = &elf_symtab_hdr (ibfd);
2779       locsymcount = symtab_hdr->sh_info;
2780       end_local_got = local_got + locsymcount;
2781       local_tls_type = elf_i386_local_got_tls_type (ibfd);
2782       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
2783       s = htab->elf.sgot;
2784       srel = htab->elf.srelgot;
2785       for (; local_got < end_local_got;
2786            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2787         {
2788           *local_tlsdesc_gotent = (bfd_vma) -1;
2789           if (*local_got > 0)
2790             {
2791               if (GOT_TLS_GDESC_P (*local_tls_type))
2792                 {
2793                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2794                     - elf_i386_compute_jump_table_size (htab);
2795                   htab->elf.sgotplt->size += 8;
2796                   *local_got = (bfd_vma) -2;
2797                 }
2798               if (! GOT_TLS_GDESC_P (*local_tls_type)
2799                   || GOT_TLS_GD_P (*local_tls_type))
2800                 {
2801                   *local_got = s->size;
2802                   s->size += 4;
2803                   if (GOT_TLS_GD_P (*local_tls_type)
2804                       || *local_tls_type == GOT_TLS_IE_BOTH)
2805                     s->size += 4;
2806                 }
2807               if (info->shared
2808                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2809                   || (*local_tls_type & GOT_TLS_IE))
2810                 {
2811                   if (*local_tls_type == GOT_TLS_IE_BOTH)
2812                     srel->size += 2 * sizeof (Elf32_External_Rel);
2813                   else if (GOT_TLS_GD_P (*local_tls_type)
2814                            || ! GOT_TLS_GDESC_P (*local_tls_type))
2815                     srel->size += sizeof (Elf32_External_Rel);
2816                   if (GOT_TLS_GDESC_P (*local_tls_type))
2817                     htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2818                 }
2819             }
2820           else
2821             *local_got = (bfd_vma) -1;
2822         }
2823     }
2824
2825   if (htab->tls_ldm_got.refcount > 0)
2826     {
2827       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2828          relocs.  */
2829       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2830       htab->elf.sgot->size += 8;
2831       htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2832     }
2833   else
2834     htab->tls_ldm_got.offset = -1;
2835
2836   /* Allocate global sym .plt and .got entries, and space for global
2837      sym dynamic relocs.  */
2838   elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
2839
2840   /* Allocate .plt and .got entries, and space for local symbols.  */
2841   htab_traverse (htab->loc_hash_table,
2842                  elf_i386_allocate_local_dynrelocs,
2843                  info);
2844
2845   /* For every jump slot reserved in the sgotplt, reloc_count is
2846      incremented.  However, when we reserve space for TLS descriptors,
2847      it's not incremented, so in order to compute the space reserved
2848      for them, it suffices to multiply the reloc count by the jump
2849      slot size.
2850
2851      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2852      so that R_386_IRELATIVE entries come last.  */
2853   if (htab->elf.srelplt)
2854     {
2855       htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2856       htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2857       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2858     }
2859   else if (htab->elf.irelplt)
2860     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2861
2862
2863   if (htab->elf.sgotplt)
2864     {
2865       struct elf_link_hash_entry *got;
2866       got = elf_link_hash_lookup (elf_hash_table (info),
2867                                   "_GLOBAL_OFFSET_TABLE_",
2868                                   FALSE, FALSE, FALSE);
2869
2870       /* Don't allocate .got.plt section if there are no GOT nor PLT
2871          entries and there is no reference to _GLOBAL_OFFSET_TABLE_.  */
2872       if ((got == NULL
2873            || !got->ref_regular_nonweak)
2874           && (htab->elf.sgotplt->size
2875               == get_elf_backend_data (output_bfd)->got_header_size)
2876           && (htab->elf.splt == NULL
2877               || htab->elf.splt->size == 0)
2878           && (htab->elf.sgot == NULL
2879               || htab->elf.sgot->size == 0)
2880           && (htab->elf.iplt == NULL
2881               || htab->elf.iplt->size == 0)
2882           && (htab->elf.igotplt == NULL
2883               || htab->elf.igotplt->size == 0))
2884         htab->elf.sgotplt->size = 0;
2885     }
2886
2887
2888   if (htab->plt_eh_frame != NULL
2889       && htab->elf.splt != NULL
2890       && htab->elf.splt->size != 0
2891       && !bfd_is_abs_section (htab->elf.splt->output_section)
2892       && _bfd_elf_eh_frame_present (info))
2893     htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
2894
2895   /* We now have determined the sizes of the various dynamic sections.
2896      Allocate memory for them.  */
2897   relocs = FALSE;
2898   for (s = dynobj->sections; s != NULL; s = s->next)
2899     {
2900       bfd_boolean strip_section = TRUE;
2901
2902       if ((s->flags & SEC_LINKER_CREATED) == 0)
2903         continue;
2904
2905       if (s == htab->elf.splt
2906           || s == htab->elf.sgot)
2907         {
2908           /* Strip this section if we don't need it; see the
2909              comment below.  */
2910           /* We'd like to strip these sections if they aren't needed, but if
2911              we've exported dynamic symbols from them we must leave them.
2912              It's too late to tell BFD to get rid of the symbols.  */
2913
2914           if (htab->elf.hplt != NULL)
2915             strip_section = FALSE;
2916         }
2917       else if (s == htab->elf.sgotplt
2918                || s == htab->elf.iplt
2919                || s == htab->elf.igotplt
2920                || s == htab->plt_eh_frame
2921                || s == htab->sdynbss)
2922         {
2923           /* Strip these too.  */
2924         }
2925       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2926         {
2927           if (s->size != 0
2928               && s != htab->elf.srelplt
2929               && s != htab->srelplt2)
2930             relocs = TRUE;
2931
2932           /* We use the reloc_count field as a counter if we need
2933              to copy relocs into the output file.  */
2934           s->reloc_count = 0;
2935         }
2936       else
2937         {
2938           /* It's not one of our sections, so don't allocate space.  */
2939           continue;
2940         }
2941
2942       if (s->size == 0)
2943         {
2944           /* If we don't need this section, strip it from the
2945              output file.  This is mostly to handle .rel.bss and
2946              .rel.plt.  We must create both sections in
2947              create_dynamic_sections, because they must be created
2948              before the linker maps input sections to output
2949              sections.  The linker does that before
2950              adjust_dynamic_symbol is called, and it is that
2951              function which decides whether anything needs to go
2952              into these sections.  */
2953           if (strip_section)
2954             s->flags |= SEC_EXCLUDE;
2955           continue;
2956         }
2957
2958       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2959         continue;
2960
2961       /* Allocate memory for the section contents.  We use bfd_zalloc
2962          here in case unused entries are not reclaimed before the
2963          section's contents are written out.  This should not happen,
2964          but this way if it does, we get a R_386_NONE reloc instead
2965          of garbage.  */
2966       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2967       if (s->contents == NULL)
2968         return FALSE;
2969     }
2970
2971   if (htab->plt_eh_frame != NULL
2972       && htab->plt_eh_frame->contents != NULL)
2973     {
2974       memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
2975               sizeof (elf_i386_eh_frame_plt));
2976       bfd_put_32 (dynobj, htab->elf.splt->size,
2977                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2978     }
2979
2980   if (htab->elf.dynamic_sections_created)
2981     {
2982       /* Add some entries to the .dynamic section.  We fill in the
2983          values later, in elf_i386_finish_dynamic_sections, but we
2984          must add the entries now so that we get the correct size for
2985          the .dynamic section.  The DT_DEBUG entry is filled in by the
2986          dynamic linker and used by the debugger.  */
2987 #define add_dynamic_entry(TAG, VAL) \
2988   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2989
2990       if (info->executable)
2991         {
2992           if (!add_dynamic_entry (DT_DEBUG, 0))
2993             return FALSE;
2994         }
2995
2996       if (htab->elf.splt->size != 0)
2997         {
2998           if (!add_dynamic_entry (DT_PLTGOT, 0)
2999               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3000               || !add_dynamic_entry (DT_PLTREL, DT_REL)
3001               || !add_dynamic_entry (DT_JMPREL, 0))
3002             return FALSE;
3003         }
3004
3005       if (relocs)
3006         {
3007           if (!add_dynamic_entry (DT_REL, 0)
3008               || !add_dynamic_entry (DT_RELSZ, 0)
3009               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3010             return FALSE;
3011
3012           /* If any dynamic relocs apply to a read-only section,
3013              then we need a DT_TEXTREL entry.  */
3014           if ((info->flags & DF_TEXTREL) == 0)
3015             elf_link_hash_traverse (&htab->elf,
3016                                     elf_i386_readonly_dynrelocs, info);
3017
3018           if ((info->flags & DF_TEXTREL) != 0)
3019             {
3020               if (!add_dynamic_entry (DT_TEXTREL, 0))
3021                 return FALSE;
3022             }
3023         }
3024       if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3025           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3026         return FALSE;
3027     }
3028 #undef add_dynamic_entry
3029
3030   return TRUE;
3031 }
3032
3033 static bfd_boolean
3034 elf_i386_always_size_sections (bfd *output_bfd,
3035                                struct bfd_link_info *info)
3036 {
3037   asection *tls_sec = elf_hash_table (info)->tls_sec;
3038
3039   if (tls_sec)
3040     {
3041       struct elf_link_hash_entry *tlsbase;
3042
3043       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3044                                       "_TLS_MODULE_BASE_",
3045                                       FALSE, FALSE, FALSE);
3046
3047       if (tlsbase && tlsbase->type == STT_TLS)
3048         {
3049           struct elf_i386_link_hash_table *htab;
3050           struct bfd_link_hash_entry *bh = NULL;
3051           const struct elf_backend_data *bed
3052             = get_elf_backend_data (output_bfd);
3053
3054           htab = elf_i386_hash_table (info);
3055           if (htab == NULL)
3056             return FALSE;
3057
3058           if (!(_bfd_generic_link_add_one_symbol
3059                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3060                  tls_sec, 0, NULL, FALSE,
3061                  bed->collect, &bh)))
3062             return FALSE;
3063
3064           htab->tls_module_base = bh;
3065
3066           tlsbase = (struct elf_link_hash_entry *)bh;
3067           tlsbase->def_regular = 1;
3068           tlsbase->other = STV_HIDDEN;
3069           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3070         }
3071     }
3072
3073   return TRUE;
3074 }
3075
3076 /* Set the correct type for an x86 ELF section.  We do this by the
3077    section name, which is a hack, but ought to work.  */
3078
3079 static bfd_boolean
3080 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3081                         Elf_Internal_Shdr *hdr,
3082                         asection *sec)
3083 {
3084   const char *name;
3085
3086   name = bfd_get_section_name (abfd, sec);
3087
3088   /* This is an ugly, but unfortunately necessary hack that is
3089      needed when producing EFI binaries on x86. It tells
3090      elf.c:elf_fake_sections() not to consider ".reloc" as a section
3091      containing ELF relocation info.  We need this hack in order to
3092      be able to generate ELF binaries that can be translated into
3093      EFI applications (which are essentially COFF objects).  Those
3094      files contain a COFF ".reloc" section inside an ELFNN object,
3095      which would normally cause BFD to segfault because it would
3096      attempt to interpret this section as containing relocation
3097      entries for section "oc".  With this hack enabled, ".reloc"
3098      will be treated as a normal data section, which will avoid the
3099      segfault.  However, you won't be able to create an ELFNN binary
3100      with a section named "oc" that needs relocations, but that's
3101      the kind of ugly side-effects you get when detecting section
3102      types based on their names...  In practice, this limitation is
3103      unlikely to bite.  */
3104   if (strcmp (name, ".reloc") == 0)
3105     hdr->sh_type = SHT_PROGBITS;
3106
3107   return TRUE;
3108 }
3109
3110 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3111    executables.  Rather than setting it to the beginning of the TLS
3112    section, we have to set it to the end.    This function may be called
3113    multiple times, it is idempotent.  */
3114
3115 static void
3116 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3117 {
3118   struct elf_i386_link_hash_table *htab;
3119   struct bfd_link_hash_entry *base;
3120
3121   if (!info->executable)
3122     return;
3123
3124   htab = elf_i386_hash_table (info);
3125   if (htab == NULL)
3126     return;
3127
3128   base = htab->tls_module_base;
3129   if (base == NULL)
3130     return;
3131
3132   base->u.def.value = htab->elf.tls_size;
3133 }
3134
3135 /* Return the base VMA address which should be subtracted from real addresses
3136    when resolving @dtpoff relocation.
3137    This is PT_TLS segment p_vaddr.  */
3138
3139 static bfd_vma
3140 elf_i386_dtpoff_base (struct bfd_link_info *info)
3141 {
3142   /* If tls_sec is NULL, we should have signalled an error already.  */
3143   if (elf_hash_table (info)->tls_sec == NULL)
3144     return 0;
3145   return elf_hash_table (info)->tls_sec->vma;
3146 }
3147
3148 /* Return the relocation value for @tpoff relocation
3149    if STT_TLS virtual address is ADDRESS.  */
3150
3151 static bfd_vma
3152 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3153 {
3154   struct elf_link_hash_table *htab = elf_hash_table (info);
3155   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3156   bfd_vma static_tls_size;
3157
3158   /* If tls_sec is NULL, we should have signalled an error already.  */
3159   if (htab->tls_sec == NULL)
3160     return 0;
3161
3162   /* Consider special static TLS alignment requirements.  */
3163   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3164   return static_tls_size + htab->tls_sec->vma - address;
3165 }
3166
3167 /* Relocate an i386 ELF section.  */
3168
3169 static bfd_boolean
3170 elf_i386_relocate_section (bfd *output_bfd,
3171                            struct bfd_link_info *info,
3172                            bfd *input_bfd,
3173                            asection *input_section,
3174                            bfd_byte *contents,
3175                            Elf_Internal_Rela *relocs,
3176                            Elf_Internal_Sym *local_syms,
3177                            asection **local_sections)
3178 {
3179   struct elf_i386_link_hash_table *htab;
3180   Elf_Internal_Shdr *symtab_hdr;
3181   struct elf_link_hash_entry **sym_hashes;
3182   bfd_vma *local_got_offsets;
3183   bfd_vma *local_tlsdesc_gotents;
3184   Elf_Internal_Rela *rel;
3185   Elf_Internal_Rela *relend;
3186   bfd_boolean is_vxworks_tls;
3187   unsigned plt_entry_size;
3188
3189   BFD_ASSERT (is_i386_elf (input_bfd));
3190
3191   htab = elf_i386_hash_table (info);
3192   if (htab == NULL)
3193     return FALSE;
3194   symtab_hdr = &elf_symtab_hdr (input_bfd);
3195   sym_hashes = elf_sym_hashes (input_bfd);
3196   local_got_offsets = elf_local_got_offsets (input_bfd);
3197   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3198   /* We have to handle relocations in vxworks .tls_vars sections
3199      specially, because the dynamic loader is 'weird'.  */
3200   is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3201                     && info->shared
3202                     && !strcmp (input_section->output_section->name,
3203                                 ".tls_vars"));
3204
3205   elf_i386_set_tls_module_base (info);
3206
3207   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3208
3209   rel = relocs;
3210   relend = relocs + input_section->reloc_count;
3211   for (; rel < relend; rel++)
3212     {
3213       unsigned int r_type;
3214       reloc_howto_type *howto;
3215       unsigned long r_symndx;
3216       struct elf_link_hash_entry *h;
3217       Elf_Internal_Sym *sym;
3218       asection *sec;
3219       bfd_vma off, offplt;
3220       bfd_vma relocation;
3221       bfd_boolean unresolved_reloc;
3222       bfd_reloc_status_type r;
3223       unsigned int indx;
3224       int tls_type;
3225
3226       r_type = ELF32_R_TYPE (rel->r_info);
3227       if (r_type == R_386_GNU_VTINHERIT
3228           || r_type == R_386_GNU_VTENTRY)
3229         continue;
3230
3231       if ((indx = r_type) >= R_386_standard
3232           && ((indx = r_type - R_386_ext_offset) - R_386_standard
3233               >= R_386_ext - R_386_standard)
3234           && ((indx = r_type - R_386_tls_offset) - R_386_ext
3235               >= R_386_irelative - R_386_ext))
3236         {
3237           (*_bfd_error_handler)
3238             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3239              input_bfd, input_section, r_type);
3240           bfd_set_error (bfd_error_bad_value);
3241           return FALSE;
3242         }
3243       howto = elf_howto_table + indx;
3244
3245       r_symndx = ELF32_R_SYM (rel->r_info);
3246       h = NULL;
3247       sym = NULL;
3248       sec = NULL;
3249       unresolved_reloc = FALSE;
3250       if (r_symndx < symtab_hdr->sh_info)
3251         {
3252           sym = local_syms + r_symndx;
3253           sec = local_sections[r_symndx];
3254           relocation = (sec->output_section->vma
3255                         + sec->output_offset
3256                         + sym->st_value);
3257
3258           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3259               && ((sec->flags & SEC_MERGE) != 0
3260                   || (info->relocatable
3261                       && sec->output_offset != 0)))
3262             {
3263               bfd_vma addend;
3264               bfd_byte *where = contents + rel->r_offset;
3265
3266               switch (howto->size)
3267                 {
3268                 case 0:
3269                   addend = bfd_get_8 (input_bfd, where);
3270                   if (howto->pc_relative)
3271                     {
3272                       addend = (addend ^ 0x80) - 0x80;
3273                       addend += 1;
3274                     }
3275                   break;
3276                 case 1:
3277                   addend = bfd_get_16 (input_bfd, where);
3278                   if (howto->pc_relative)
3279                     {
3280                       addend = (addend ^ 0x8000) - 0x8000;
3281                       addend += 2;
3282                     }
3283                   break;
3284                 case 2:
3285                   addend = bfd_get_32 (input_bfd, where);
3286                   if (howto->pc_relative)
3287                     {
3288                       addend = (addend ^ 0x80000000) - 0x80000000;
3289                       addend += 4;
3290                     }
3291                   break;
3292                 default:
3293                   abort ();
3294                 }
3295
3296               if (info->relocatable)
3297                 addend += sec->output_offset;
3298               else
3299                 {
3300                   asection *msec = sec;
3301                   addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3302                                                    addend);
3303                   addend -= relocation;
3304                   addend += msec->output_section->vma + msec->output_offset;
3305                 }
3306
3307               switch (howto->size)
3308                 {
3309                 case 0:
3310                   /* FIXME: overflow checks.  */
3311                   if (howto->pc_relative)
3312                     addend -= 1;
3313                   bfd_put_8 (input_bfd, addend, where);
3314                   break;
3315                 case 1:
3316                   if (howto->pc_relative)
3317                     addend -= 2;
3318                   bfd_put_16 (input_bfd, addend, where);
3319                   break;
3320                 case 2:
3321                   if (howto->pc_relative)
3322                     addend -= 4;
3323                   bfd_put_32 (input_bfd, addend, where);
3324                   break;
3325                 }
3326             }
3327           else if (!info->relocatable
3328                    && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3329             {
3330               /* Relocate against local STT_GNU_IFUNC symbol.  */
3331               h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3332                                                FALSE);
3333               if (h == NULL)
3334                 abort ();
3335
3336               /* Set STT_GNU_IFUNC symbol value.  */
3337               h->root.u.def.value = sym->st_value;
3338               h->root.u.def.section = sec;
3339             }
3340         }
3341       else
3342         {
3343           bfd_boolean warned ATTRIBUTE_UNUSED;
3344
3345           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3346                                    r_symndx, symtab_hdr, sym_hashes,
3347                                    h, sec, relocation,
3348                                    unresolved_reloc, warned);
3349         }
3350
3351       if (sec != NULL && discarded_section (sec))
3352         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3353                                          rel, 1, relend, howto, 0, contents);
3354
3355       if (info->relocatable)
3356         continue;
3357
3358       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3359          it here if it is defined in a non-shared object.  */
3360       if (h != NULL
3361           && h->type == STT_GNU_IFUNC
3362           && h->def_regular)
3363         {
3364           asection *plt, *gotplt, *base_got;
3365           bfd_vma plt_index;
3366           const char *name;
3367
3368           if ((input_section->flags & SEC_ALLOC) == 0
3369               || h->plt.offset == (bfd_vma) -1)
3370             abort ();
3371
3372           /* STT_GNU_IFUNC symbol must go through PLT.  */
3373           if (htab->elf.splt != NULL)
3374             {
3375               plt = htab->elf.splt;
3376               gotplt = htab->elf.sgotplt;
3377             }
3378           else
3379             {
3380               plt = htab->elf.iplt;
3381               gotplt = htab->elf.igotplt;
3382             }
3383
3384           relocation = (plt->output_section->vma
3385                         + plt->output_offset + h->plt.offset);
3386
3387           switch (r_type)
3388             {
3389             default:
3390               if (h->root.root.string)
3391                 name = h->root.root.string;
3392               else
3393                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3394                                          NULL);
3395               (*_bfd_error_handler)
3396                 (_("%B: relocation %s against STT_GNU_IFUNC "
3397                    "symbol `%s' isn't handled by %s"), input_bfd,
3398                  elf_howto_table[r_type].name,
3399                  name, __FUNCTION__);
3400               bfd_set_error (bfd_error_bad_value);
3401               return FALSE;
3402
3403             case R_386_32:
3404               /* Generate dynamic relcoation only when there is a
3405                  non-GOT reference in a shared object.  */
3406               if (info->shared && h->non_got_ref)
3407                 {
3408                   Elf_Internal_Rela outrel;
3409                   bfd_byte *loc;
3410                   asection *sreloc;
3411                   bfd_vma offset;
3412
3413                   /* Need a dynamic relocation to get the real function
3414                      adddress.  */
3415                   offset = _bfd_elf_section_offset (output_bfd,
3416                                                     info,
3417                                                     input_section,
3418                                                     rel->r_offset);
3419                   if (offset == (bfd_vma) -1
3420                       || offset == (bfd_vma) -2)
3421                     abort ();
3422
3423                   outrel.r_offset = (input_section->output_section->vma
3424                                      + input_section->output_offset
3425                                      + offset);
3426
3427                   if (h->dynindx == -1
3428                       || h->forced_local
3429                       || info->executable)
3430                     {
3431                       /* This symbol is resolved locally.  */
3432                       outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3433                       bfd_put_32 (output_bfd,
3434                                   (h->root.u.def.value
3435                                    + h->root.u.def.section->output_section->vma
3436                                    + h->root.u.def.section->output_offset),
3437                                   contents + offset);
3438                     }
3439                   else
3440                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3441
3442                   sreloc = htab->elf.irelifunc;
3443                   loc = sreloc->contents;
3444                   loc += (sreloc->reloc_count++
3445                           * sizeof (Elf32_External_Rel));
3446                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3447
3448                   /* If this reloc is against an external symbol, we
3449                      do not want to fiddle with the addend.  Otherwise,
3450                      we need to include the symbol value so that it
3451                      becomes an addend for the dynamic reloc.  For an
3452                      internal symbol, we have updated addend.  */
3453                   continue;
3454                 }
3455               /* FALLTHROUGH */
3456             case R_386_PC32:
3457             case R_386_PLT32:
3458               goto do_relocation;
3459
3460             case R_386_GOT32:
3461               base_got = htab->elf.sgot;
3462               off = h->got.offset;
3463
3464               if (base_got == NULL)
3465                 abort ();
3466
3467               if (off == (bfd_vma) -1)
3468                 {
3469                   /* We can't use h->got.offset here to save state, or
3470                      even just remember the offset, as finish_dynamic_symbol
3471                      would use that as offset into .got.  */
3472
3473                   if (htab->elf.splt != NULL)
3474                     {
3475                       plt_index = h->plt.offset / plt_entry_size - 1;
3476                       off = (plt_index + 3) * 4;
3477                       base_got = htab->elf.sgotplt;
3478                     }
3479                   else
3480                     {
3481                       plt_index = h->plt.offset / plt_entry_size;
3482                       off = plt_index * 4;
3483                       base_got = htab->elf.igotplt;
3484                     }
3485
3486                   if (h->dynindx == -1
3487                       || h->forced_local
3488                       || info->symbolic)
3489                     {
3490                       /* This references the local defitionion.  We must
3491                          initialize this entry in the global offset table.
3492                          Since the offset must always be a multiple of 8,
3493                          we use the least significant bit to record
3494                          whether we have initialized it already.
3495
3496                          When doing a dynamic link, we create a .rela.got
3497                          relocation entry to initialize the value.  This
3498                          is done in the finish_dynamic_symbol routine.   */
3499                       if ((off & 1) != 0)
3500                         off &= ~1;
3501                       else
3502                         {
3503                           bfd_put_32 (output_bfd, relocation,
3504                                       base_got->contents + off);
3505                           h->got.offset |= 1;
3506                         }
3507                     }
3508
3509                   relocation = off;
3510
3511                   /* Adjust for static executables.  */
3512                   if (htab->elf.splt == NULL)
3513                     relocation += gotplt->output_offset;
3514                 }
3515               else
3516                 {
3517                   relocation = (base_got->output_section->vma
3518                                 + base_got->output_offset + off
3519                                 - gotplt->output_section->vma
3520                                 - gotplt->output_offset);
3521                   /* Adjust for static executables.  */
3522                   if (htab->elf.splt == NULL)
3523                     relocation += gotplt->output_offset;
3524                 }
3525
3526               goto do_relocation;
3527
3528             case R_386_GOTOFF:
3529               relocation -= (gotplt->output_section->vma
3530                              + gotplt->output_offset);
3531               goto do_relocation;
3532             }
3533         }
3534
3535       switch (r_type)
3536         {
3537         case R_386_GOT32:
3538           /* Relocation is to the entry for this symbol in the global
3539              offset table.  */
3540           if (htab->elf.sgot == NULL)
3541             abort ();
3542
3543           if (h != NULL)
3544             {
3545               bfd_boolean dyn;
3546
3547               off = h->got.offset;
3548               dyn = htab->elf.dynamic_sections_created;
3549               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3550                   || (info->shared
3551                       && SYMBOL_REFERENCES_LOCAL (info, h))
3552                   || (ELF_ST_VISIBILITY (h->other)
3553                       && h->root.type == bfd_link_hash_undefweak))
3554                 {
3555                   /* This is actually a static link, or it is a
3556                      -Bsymbolic link and the symbol is defined
3557                      locally, or the symbol was forced to be local
3558                      because of a version file.  We must initialize
3559                      this entry in the global offset table.  Since the
3560                      offset must always be a multiple of 4, we use the
3561                      least significant bit to record whether we have
3562                      initialized it already.
3563
3564                      When doing a dynamic link, we create a .rel.got
3565                      relocation entry to initialize the value.  This
3566                      is done in the finish_dynamic_symbol routine.  */
3567                   if ((off & 1) != 0)
3568                     off &= ~1;
3569                   else
3570                     {
3571                       bfd_put_32 (output_bfd, relocation,
3572                                   htab->elf.sgot->contents + off);
3573                       h->got.offset |= 1;
3574                     }
3575                 }
3576               else
3577                 unresolved_reloc = FALSE;
3578             }
3579           else
3580             {
3581               if (local_got_offsets == NULL)
3582                 abort ();
3583
3584               off = local_got_offsets[r_symndx];
3585
3586               /* The offset must always be a multiple of 4.  We use
3587                  the least significant bit to record whether we have
3588                  already generated the necessary reloc.  */
3589               if ((off & 1) != 0)
3590                 off &= ~1;
3591               else
3592                 {
3593                   bfd_put_32 (output_bfd, relocation,
3594                               htab->elf.sgot->contents + off);
3595
3596                   if (info->shared)
3597                     {
3598                       asection *s;
3599                       Elf_Internal_Rela outrel;
3600                       bfd_byte *loc;
3601
3602                       s = htab->elf.srelgot;
3603                       if (s == NULL)
3604                         abort ();
3605
3606                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3607                                          + htab->elf.sgot->output_offset
3608                                          + off);
3609                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3610                       loc = s->contents;
3611                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
3612                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3613                     }
3614
3615                   local_got_offsets[r_symndx] |= 1;
3616                 }
3617             }
3618
3619           if (off >= (bfd_vma) -2)
3620             abort ();
3621
3622           relocation = htab->elf.sgot->output_section->vma
3623                        + htab->elf.sgot->output_offset + off
3624                        - htab->elf.sgotplt->output_section->vma
3625                        - htab->elf.sgotplt->output_offset;
3626           break;
3627
3628         case R_386_GOTOFF:
3629           /* Relocation is relative to the start of the global offset
3630              table.  */
3631
3632           /* Check to make sure it isn't a protected function symbol
3633              for shared library since it may not be local when used
3634              as function address.  We also need to make sure that a
3635              symbol is defined locally.  */
3636           if (info->shared && h)
3637             {
3638               if (!h->def_regular)
3639                 {
3640                   const char *v;
3641
3642                   switch (ELF_ST_VISIBILITY (h->other))
3643                     {
3644                     case STV_HIDDEN:
3645                       v = _("hidden symbol");
3646                       break;
3647                     case STV_INTERNAL:
3648                       v = _("internal symbol");
3649                       break;
3650                     case STV_PROTECTED:
3651                       v = _("protected symbol");
3652                       break;
3653                     default:
3654                       v = _("symbol");
3655                       break;
3656                     }
3657
3658                   (*_bfd_error_handler)
3659                     (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3660                      input_bfd, v, h->root.root.string);
3661                   bfd_set_error (bfd_error_bad_value);
3662                   return FALSE;
3663                 }
3664               else if (!info->executable
3665                        && !SYMBOLIC_BIND (info, h)
3666                        && h->type == STT_FUNC
3667                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3668                 {
3669                   (*_bfd_error_handler)
3670                     (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3671                      input_bfd, h->root.root.string);
3672                   bfd_set_error (bfd_error_bad_value);
3673                   return FALSE;
3674                 }
3675             }
3676
3677           /* Note that sgot is not involved in this
3678              calculation.  We always want the start of .got.plt.  If we
3679              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3680              permitted by the ABI, we might have to change this
3681              calculation.  */
3682           relocation -= htab->elf.sgotplt->output_section->vma
3683                         + htab->elf.sgotplt->output_offset;
3684           break;
3685
3686         case R_386_GOTPC:
3687           /* Use global offset table as symbol value.  */
3688           relocation = htab->elf.sgotplt->output_section->vma
3689                        + htab->elf.sgotplt->output_offset;
3690           unresolved_reloc = FALSE;
3691           break;
3692
3693         case R_386_PLT32:
3694           /* Relocation is to the entry for this symbol in the
3695              procedure linkage table.  */
3696
3697           /* Resolve a PLT32 reloc against a local symbol directly,
3698              without using the procedure linkage table.  */
3699           if (h == NULL)
3700             break;
3701
3702           if (h->plt.offset == (bfd_vma) -1
3703               || htab->elf.splt == NULL)
3704             {
3705               /* We didn't make a PLT entry for this symbol.  This
3706                  happens when statically linking PIC code, or when
3707                  using -Bsymbolic.  */
3708               break;
3709             }
3710
3711           relocation = (htab->elf.splt->output_section->vma
3712                         + htab->elf.splt->output_offset
3713                         + h->plt.offset);
3714           unresolved_reloc = FALSE;
3715           break;
3716
3717         case R_386_32:
3718         case R_386_PC32:
3719           if ((input_section->flags & SEC_ALLOC) == 0
3720               || is_vxworks_tls)
3721             break;
3722
3723           if ((info->shared
3724                && (h == NULL
3725                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3726                    || h->root.type != bfd_link_hash_undefweak)
3727                && (r_type != R_386_PC32
3728                    || !SYMBOL_CALLS_LOCAL (info, h)))
3729               || (ELIMINATE_COPY_RELOCS
3730                   && !info->shared
3731                   && h != NULL
3732                   && h->dynindx != -1
3733                   && !h->non_got_ref
3734                   && ((h->def_dynamic
3735                        && !h->def_regular)
3736                       || h->root.type == bfd_link_hash_undefweak
3737                       || h->root.type == bfd_link_hash_undefined)))
3738             {
3739               Elf_Internal_Rela outrel;
3740               bfd_byte *loc;
3741               bfd_boolean skip, relocate;
3742               asection *sreloc;
3743
3744               /* When generating a shared object, these relocations
3745                  are copied into the output file to be resolved at run
3746                  time.  */
3747
3748               skip = FALSE;
3749               relocate = FALSE;
3750
3751               outrel.r_offset =
3752                 _bfd_elf_section_offset (output_bfd, info, input_section,
3753                                          rel->r_offset);
3754               if (outrel.r_offset == (bfd_vma) -1)
3755                 skip = TRUE;
3756               else if (outrel.r_offset == (bfd_vma) -2)
3757                 skip = TRUE, relocate = TRUE;
3758               outrel.r_offset += (input_section->output_section->vma
3759                                   + input_section->output_offset);
3760
3761               if (skip)
3762                 memset (&outrel, 0, sizeof outrel);
3763               else if (h != NULL
3764                        && h->dynindx != -1
3765                        && (r_type == R_386_PC32
3766                            || !info->shared
3767                            || !SYMBOLIC_BIND (info, h)
3768                            || !h->def_regular))
3769                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3770               else
3771                 {
3772                   /* This symbol is local, or marked to become local.  */
3773                   relocate = TRUE;
3774                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3775                 }
3776
3777               sreloc = elf_section_data (input_section)->sreloc;
3778
3779               if (sreloc == NULL || sreloc->contents == NULL)
3780                 {
3781                   r = bfd_reloc_notsupported;
3782                   goto check_relocation_error;
3783                 }
3784
3785               loc = sreloc->contents;
3786               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3787
3788               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3789
3790               /* If this reloc is against an external symbol, we do
3791                  not want to fiddle with the addend.  Otherwise, we
3792                  need to include the symbol value so that it becomes
3793                  an addend for the dynamic reloc.  */
3794               if (! relocate)
3795                 continue;
3796             }
3797           break;
3798
3799         case R_386_TLS_IE:
3800           if (!info->executable)
3801             {
3802               Elf_Internal_Rela outrel;
3803               bfd_byte *loc;
3804               asection *sreloc;
3805
3806               outrel.r_offset = rel->r_offset
3807                                 + input_section->output_section->vma
3808                                 + input_section->output_offset;
3809               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3810               sreloc = elf_section_data (input_section)->sreloc;
3811               if (sreloc == NULL)
3812                 abort ();
3813               loc = sreloc->contents;
3814               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3815               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3816             }
3817           /* Fall through */
3818
3819         case R_386_TLS_GD:
3820         case R_386_TLS_GOTDESC:
3821         case R_386_TLS_DESC_CALL:
3822         case R_386_TLS_IE_32:
3823         case R_386_TLS_GOTIE:
3824           tls_type = GOT_UNKNOWN;
3825           if (h == NULL && local_got_offsets)
3826             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3827           else if (h != NULL)
3828             tls_type = elf_i386_hash_entry(h)->tls_type;
3829           if (tls_type == GOT_TLS_IE)
3830             tls_type = GOT_TLS_IE_NEG;
3831
3832           if (! elf_i386_tls_transition (info, input_bfd,
3833                                          input_section, contents,
3834                                          symtab_hdr, sym_hashes,
3835                                          &r_type, tls_type, rel,
3836                                          relend, h, r_symndx))
3837             return FALSE;
3838
3839           if (r_type == R_386_TLS_LE_32)
3840             {
3841               BFD_ASSERT (! unresolved_reloc);
3842               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3843                 {
3844                   unsigned int type;
3845                   bfd_vma roff;
3846
3847                   /* GD->LE transition.  */
3848                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3849                   if (type == 0x04)
3850                     {
3851                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3852                          Change it into:
3853                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3854                          (6 byte form of subl).  */
3855                       memcpy (contents + rel->r_offset - 3,
3856                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3857                       roff = rel->r_offset + 5;
3858                     }
3859                   else
3860                     {
3861                       /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3862                          Change it into:
3863                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3864                          (6 byte form of subl).  */
3865                       memcpy (contents + rel->r_offset - 2,
3866                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3867                       roff = rel->r_offset + 6;
3868                     }
3869                   bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3870                               contents + roff);
3871                   /* Skip R_386_PC32/R_386_PLT32.  */
3872                   rel++;
3873                   continue;
3874                 }
3875               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3876                 {
3877                   /* GDesc -> LE transition.
3878                      It's originally something like:
3879                      leal x@tlsdesc(%ebx), %eax
3880
3881                      leal x@ntpoff, %eax
3882
3883                      Registers other than %eax may be set up here.  */
3884
3885                   unsigned int val;
3886                   bfd_vma roff;
3887
3888                   roff = rel->r_offset;
3889                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3890
3891                   /* Now modify the instruction as appropriate.  */
3892                   /* aoliva FIXME: remove the above and xor the byte
3893                      below with 0x86.  */
3894                   bfd_put_8 (output_bfd, val ^ 0x86,
3895                              contents + roff - 1);
3896                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3897                               contents + roff);
3898                   continue;
3899                 }
3900               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3901                 {
3902                   /* GDesc -> LE transition.
3903                      It's originally:
3904                      call *(%eax)
3905                      Turn it into:
3906                      xchg %ax,%ax  */
3907
3908                   bfd_vma roff;
3909
3910                   roff = rel->r_offset;
3911                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3912                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3913                   continue;
3914                 }
3915               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
3916                 {
3917                   unsigned int val;
3918
3919                   /* IE->LE transition:
3920                      Originally it can be one of:
3921                      movl foo, %eax
3922                      movl foo, %reg
3923                      addl foo, %reg
3924                      We change it into:
3925                      movl $foo, %eax
3926                      movl $foo, %reg
3927                      addl $foo, %reg.  */
3928                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3929                   if (val == 0xa1)
3930                     {
3931                       /* movl foo, %eax.  */
3932                       bfd_put_8 (output_bfd, 0xb8,
3933                                  contents + rel->r_offset - 1);
3934                     }
3935                   else
3936                     {
3937                       unsigned int type;
3938
3939                       type = bfd_get_8 (input_bfd,
3940                                         contents + rel->r_offset - 2);
3941                       switch (type)
3942                         {
3943                         case 0x8b:
3944                           /* movl */
3945                           bfd_put_8 (output_bfd, 0xc7,
3946                                      contents + rel->r_offset - 2);
3947                           bfd_put_8 (output_bfd,
3948                                      0xc0 | ((val >> 3) & 7),
3949                                      contents + rel->r_offset - 1);
3950                           break;
3951                         case 0x03:
3952                           /* addl */
3953                           bfd_put_8 (output_bfd, 0x81,
3954                                      contents + rel->r_offset - 2);
3955                           bfd_put_8 (output_bfd,
3956                                      0xc0 | ((val >> 3) & 7),
3957                                      contents + rel->r_offset - 1);
3958                           break;
3959                         default:
3960                           BFD_FAIL ();
3961                           break;
3962                         }
3963                     }
3964                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3965                               contents + rel->r_offset);
3966                   continue;
3967                 }
3968               else
3969                 {
3970                   unsigned int val, type;
3971
3972                   /* {IE_32,GOTIE}->LE transition:
3973                      Originally it can be one of:
3974                      subl foo(%reg1), %reg2
3975                      movl foo(%reg1), %reg2
3976                      addl foo(%reg1), %reg2
3977                      We change it into:
3978                      subl $foo, %reg2
3979                      movl $foo, %reg2 (6 byte form)
3980                      addl $foo, %reg2.  */
3981                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3982                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3983                   if (type == 0x8b)
3984                     {
3985                       /* movl */
3986                       bfd_put_8 (output_bfd, 0xc7,
3987                                  contents + rel->r_offset - 2);
3988                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3989                                  contents + rel->r_offset - 1);
3990                     }
3991                   else if (type == 0x2b)
3992                     {
3993                       /* subl */
3994                       bfd_put_8 (output_bfd, 0x81,
3995                                  contents + rel->r_offset - 2);
3996                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3997                                  contents + rel->r_offset - 1);
3998                     }
3999                   else if (type == 0x03)
4000                     {
4001                       /* addl */
4002                       bfd_put_8 (output_bfd, 0x81,
4003                                  contents + rel->r_offset - 2);
4004                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4005                                  contents + rel->r_offset - 1);
4006                     }
4007                   else
4008                     BFD_FAIL ();
4009                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4010                     bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4011                                 contents + rel->r_offset);
4012                   else
4013                     bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4014                                 contents + rel->r_offset);
4015                   continue;
4016                 }
4017             }
4018
4019           if (htab->elf.sgot == NULL)
4020             abort ();
4021
4022           if (h != NULL)
4023             {
4024               off = h->got.offset;
4025               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4026             }
4027           else
4028             {
4029               if (local_got_offsets == NULL)
4030                 abort ();
4031
4032               off = local_got_offsets[r_symndx];
4033               offplt = local_tlsdesc_gotents[r_symndx];
4034             }
4035
4036           if ((off & 1) != 0)
4037             off &= ~1;
4038           else
4039             {
4040               Elf_Internal_Rela outrel;
4041               bfd_byte *loc;
4042               int dr_type;
4043               asection *sreloc;
4044
4045               if (htab->elf.srelgot == NULL)
4046                 abort ();
4047
4048               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4049
4050               if (GOT_TLS_GDESC_P (tls_type))
4051                 {
4052                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4053                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4054                               <= htab->elf.sgotplt->size);
4055                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4056                                      + htab->elf.sgotplt->output_offset
4057                                      + offplt
4058                                      + htab->sgotplt_jump_table_size);
4059                   sreloc = htab->elf.srelplt;
4060                   loc = sreloc->contents;
4061                   loc += (htab->next_tls_desc_index++
4062                           * sizeof (Elf32_External_Rel));
4063                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4064                               <= sreloc->contents + sreloc->size);
4065                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4066                   if (indx == 0)
4067                     {
4068                       BFD_ASSERT (! unresolved_reloc);
4069                       bfd_put_32 (output_bfd,
4070                                   relocation - elf_i386_dtpoff_base (info),
4071                                   htab->elf.sgotplt->contents + offplt
4072                                   + htab->sgotplt_jump_table_size + 4);
4073                     }
4074                   else
4075                     {
4076                       bfd_put_32 (output_bfd, 0,
4077                                   htab->elf.sgotplt->contents + offplt
4078                                   + htab->sgotplt_jump_table_size + 4);
4079                     }
4080                 }
4081
4082               sreloc = htab->elf.srelgot;
4083
4084               outrel.r_offset = (htab->elf.sgot->output_section->vma
4085                                  + htab->elf.sgot->output_offset + off);
4086
4087               if (GOT_TLS_GD_P (tls_type))
4088                 dr_type = R_386_TLS_DTPMOD32;
4089               else if (GOT_TLS_GDESC_P (tls_type))
4090                 goto dr_done;
4091               else if (tls_type == GOT_TLS_IE_POS)
4092                 dr_type = R_386_TLS_TPOFF;
4093               else
4094                 dr_type = R_386_TLS_TPOFF32;
4095
4096               if (dr_type == R_386_TLS_TPOFF && indx == 0)
4097                 bfd_put_32 (output_bfd,
4098                             relocation - elf_i386_dtpoff_base (info),
4099                             htab->elf.sgot->contents + off);
4100               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4101                 bfd_put_32 (output_bfd,
4102                             elf_i386_dtpoff_base (info) - relocation,
4103                             htab->elf.sgot->contents + off);
4104               else if (dr_type != R_386_TLS_DESC)
4105                 bfd_put_32 (output_bfd, 0,
4106                             htab->elf.sgot->contents + off);
4107               outrel.r_info = ELF32_R_INFO (indx, dr_type);
4108
4109               loc = sreloc->contents;
4110               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
4111               BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4112                           <= sreloc->contents + sreloc->size);
4113               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4114
4115               if (GOT_TLS_GD_P (tls_type))
4116                 {
4117                   if (indx == 0)
4118                     {
4119                       BFD_ASSERT (! unresolved_reloc);
4120                       bfd_put_32 (output_bfd,
4121                                   relocation - elf_i386_dtpoff_base (info),
4122                                   htab->elf.sgot->contents + off + 4);
4123                     }
4124                   else
4125                     {
4126                       bfd_put_32 (output_bfd, 0,
4127                                   htab->elf.sgot->contents + off + 4);
4128                       outrel.r_info = ELF32_R_INFO (indx,
4129                                                     R_386_TLS_DTPOFF32);
4130                       outrel.r_offset += 4;
4131                       sreloc->reloc_count++;
4132                       loc += sizeof (Elf32_External_Rel);
4133                       BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4134                                   <= sreloc->contents + sreloc->size);
4135                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4136                     }
4137                 }
4138               else if (tls_type == GOT_TLS_IE_BOTH)
4139                 {
4140                   bfd_put_32 (output_bfd,
4141                               (indx == 0
4142                                ? relocation - elf_i386_dtpoff_base (info)
4143                                : 0),
4144                               htab->elf.sgot->contents + off + 4);
4145                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4146                   outrel.r_offset += 4;
4147                   sreloc->reloc_count++;
4148                   loc += sizeof (Elf32_External_Rel);
4149                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4150                 }
4151
4152             dr_done:
4153               if (h != NULL)
4154                 h->got.offset |= 1;
4155               else
4156                 local_got_offsets[r_symndx] |= 1;
4157             }
4158
4159           if (off >= (bfd_vma) -2
4160               && ! GOT_TLS_GDESC_P (tls_type))
4161             abort ();
4162           if (r_type == R_386_TLS_GOTDESC
4163               || r_type == R_386_TLS_DESC_CALL)
4164             {
4165               relocation = htab->sgotplt_jump_table_size + offplt;
4166               unresolved_reloc = FALSE;
4167             }
4168           else if (r_type == ELF32_R_TYPE (rel->r_info))
4169             {
4170               bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4171                               + htab->elf.sgotplt->output_offset;
4172               relocation = htab->elf.sgot->output_section->vma
4173                 + htab->elf.sgot->output_offset + off - g_o_t;
4174               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4175                   && tls_type == GOT_TLS_IE_BOTH)
4176                 relocation += 4;
4177               if (r_type == R_386_TLS_IE)
4178                 relocation += g_o_t;
4179               unresolved_reloc = FALSE;
4180             }
4181           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4182             {
4183               unsigned int val, type;
4184               bfd_vma roff;
4185
4186               /* GD->IE transition.  */
4187               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4188               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4189               if (type == 0x04)
4190                 {
4191                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4192                      Change it into:
4193                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4194                   val >>= 3;
4195                   roff = rel->r_offset - 3;
4196                 }
4197               else
4198                 {
4199                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4200                      Change it into:
4201                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
4202                   roff = rel->r_offset - 2;
4203                 }
4204               memcpy (contents + roff,
4205                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4206               contents[roff + 7] = 0x80 | (val & 7);
4207               /* If foo is used only with foo@gotntpoff(%reg) and
4208                  foo@indntpoff, but not with foo@gottpoff(%reg), change
4209                  subl $foo@gottpoff(%reg), %eax
4210                  into:
4211                  addl $foo@gotntpoff(%reg), %eax.  */
4212               if (tls_type == GOT_TLS_IE_POS)
4213                 contents[roff + 6] = 0x03;
4214               bfd_put_32 (output_bfd,
4215                           htab->elf.sgot->output_section->vma
4216                           + htab->elf.sgot->output_offset + off
4217                           - htab->elf.sgotplt->output_section->vma
4218                           - htab->elf.sgotplt->output_offset,
4219                           contents + roff + 8);
4220               /* Skip R_386_PLT32.  */
4221               rel++;
4222               continue;
4223             }
4224           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4225             {
4226               /* GDesc -> IE transition.
4227                  It's originally something like:
4228                  leal x@tlsdesc(%ebx), %eax
4229
4230                  Change it to:
4231                  movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4232                  or:
4233                  movl x@gottpoff(%ebx), %eax # before negl %eax
4234
4235                  Registers other than %eax may be set up here.  */
4236
4237               bfd_vma roff;
4238
4239               /* First, make sure it's a leal adding ebx to a 32-bit
4240                  offset into any register, although it's probably
4241                  almost always going to be eax.  */
4242               roff = rel->r_offset;
4243
4244               /* Now modify the instruction as appropriate.  */
4245               /* To turn a leal into a movl in the form we use it, it
4246                  suffices to change the first byte from 0x8d to 0x8b.
4247                  aoliva FIXME: should we decide to keep the leal, all
4248                  we have to do is remove the statement below, and
4249                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
4250               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4251
4252               if (tls_type == GOT_TLS_IE_BOTH)
4253                 off += 4;
4254
4255               bfd_put_32 (output_bfd,
4256                           htab->elf.sgot->output_section->vma
4257                           + htab->elf.sgot->output_offset + off
4258                           - htab->elf.sgotplt->output_section->vma
4259                           - htab->elf.sgotplt->output_offset,
4260                           contents + roff);
4261               continue;
4262             }
4263           else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4264             {
4265               /* GDesc -> IE transition.
4266                  It's originally:
4267                  call *(%eax)
4268
4269                  Change it to:
4270                  xchg %ax,%ax
4271                  or
4272                  negl %eax
4273                  depending on how we transformed the TLS_GOTDESC above.
4274               */
4275
4276               bfd_vma roff;
4277
4278               roff = rel->r_offset;
4279
4280               /* Now modify the instruction as appropriate.  */
4281               if (tls_type != GOT_TLS_IE_NEG)
4282                 {
4283                   /* xchg %ax,%ax */
4284                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4285                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4286                 }
4287               else
4288                 {
4289                   /* negl %eax */
4290                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
4291                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4292                 }
4293
4294               continue;
4295             }
4296           else
4297             BFD_ASSERT (FALSE);
4298           break;
4299
4300         case R_386_TLS_LDM:
4301           if (! elf_i386_tls_transition (info, input_bfd,
4302                                          input_section, contents,
4303                                          symtab_hdr, sym_hashes,
4304                                          &r_type, GOT_UNKNOWN, rel,
4305                                          relend, h, r_symndx))
4306             return FALSE;
4307
4308           if (r_type != R_386_TLS_LDM)
4309             {
4310               /* LD->LE transition:
4311                  leal foo(%reg), %eax; call ___tls_get_addr.
4312                  We change it into:
4313                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
4314               BFD_ASSERT (r_type == R_386_TLS_LE_32);
4315               memcpy (contents + rel->r_offset - 2,
4316                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4317               /* Skip R_386_PC32/R_386_PLT32.  */
4318               rel++;
4319               continue;
4320             }
4321
4322           if (htab->elf.sgot == NULL)
4323             abort ();
4324
4325           off = htab->tls_ldm_got.offset;
4326           if (off & 1)
4327             off &= ~1;
4328           else
4329             {
4330               Elf_Internal_Rela outrel;
4331               bfd_byte *loc;
4332
4333               if (htab->elf.srelgot == NULL)
4334                 abort ();
4335
4336               outrel.r_offset = (htab->elf.sgot->output_section->vma
4337                                  + htab->elf.sgot->output_offset + off);
4338
4339               bfd_put_32 (output_bfd, 0,
4340                           htab->elf.sgot->contents + off);
4341               bfd_put_32 (output_bfd, 0,
4342                           htab->elf.sgot->contents + off + 4);
4343               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4344               loc = htab->elf.srelgot->contents;
4345               loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
4346               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4347               htab->tls_ldm_got.offset |= 1;
4348             }
4349           relocation = htab->elf.sgot->output_section->vma
4350                        + htab->elf.sgot->output_offset + off
4351                        - htab->elf.sgotplt->output_section->vma
4352                        - htab->elf.sgotplt->output_offset;
4353           unresolved_reloc = FALSE;
4354           break;
4355
4356         case R_386_TLS_LDO_32:
4357           if (!info->executable || (input_section->flags & SEC_CODE) == 0)
4358             relocation -= elf_i386_dtpoff_base (info);
4359           else
4360             /* When converting LDO to LE, we must negate.  */
4361             relocation = -elf_i386_tpoff (info, relocation);
4362           break;
4363
4364         case R_386_TLS_LE_32:
4365         case R_386_TLS_LE:
4366           if (!info->executable)
4367             {
4368               Elf_Internal_Rela outrel;
4369               asection *sreloc;
4370               bfd_byte *loc;
4371
4372               outrel.r_offset = rel->r_offset
4373                                 + input_section->output_section->vma
4374                                 + input_section->output_offset;
4375               if (h != NULL && h->dynindx != -1)
4376                 indx = h->dynindx;
4377               else
4378                 indx = 0;
4379               if (r_type == R_386_TLS_LE_32)
4380                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4381               else
4382                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4383               sreloc = elf_section_data (input_section)->sreloc;
4384               if (sreloc == NULL)
4385                 abort ();
4386               loc = sreloc->contents;
4387               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
4388               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4389               if (indx)
4390                 continue;
4391               else if (r_type == R_386_TLS_LE_32)
4392                 relocation = elf_i386_dtpoff_base (info) - relocation;
4393               else
4394                 relocation -= elf_i386_dtpoff_base (info);
4395             }
4396           else if (r_type == R_386_TLS_LE_32)
4397             relocation = elf_i386_tpoff (info, relocation);
4398           else
4399             relocation = -elf_i386_tpoff (info, relocation);
4400           break;
4401
4402         default:
4403           break;
4404         }
4405
4406       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4407          because such sections are not SEC_ALLOC and thus ld.so will
4408          not process them.  */
4409       if (unresolved_reloc
4410           && !((input_section->flags & SEC_DEBUGGING) != 0
4411                && h->def_dynamic)
4412           && _bfd_elf_section_offset (output_bfd, info, input_section,
4413                                       rel->r_offset) != (bfd_vma) -1)
4414         {
4415           (*_bfd_error_handler)
4416             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4417              input_bfd,
4418              input_section,
4419              (long) rel->r_offset,
4420              howto->name,
4421              h->root.root.string);
4422           return FALSE;
4423         }
4424
4425 do_relocation:
4426       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4427                                     contents, rel->r_offset,
4428                                     relocation, 0);
4429
4430 check_relocation_error:
4431       if (r != bfd_reloc_ok)
4432         {
4433           const char *name;
4434
4435           if (h != NULL)
4436             name = h->root.root.string;
4437           else
4438             {
4439               name = bfd_elf_string_from_elf_section (input_bfd,
4440                                                       symtab_hdr->sh_link,
4441                                                       sym->st_name);
4442               if (name == NULL)
4443                 return FALSE;
4444               if (*name == '\0')
4445                 name = bfd_section_name (input_bfd, sec);
4446             }
4447
4448           if (r == bfd_reloc_overflow)
4449             {
4450               if (! ((*info->callbacks->reloc_overflow)
4451                      (info, (h ? &h->root : NULL), name, howto->name,
4452                       (bfd_vma) 0, input_bfd, input_section,
4453                       rel->r_offset)))
4454                 return FALSE;
4455             }
4456           else
4457             {
4458               (*_bfd_error_handler)
4459                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4460                  input_bfd, input_section,
4461                  (long) rel->r_offset, name, (int) r);
4462               return FALSE;
4463             }
4464         }
4465     }
4466
4467   return TRUE;
4468 }
4469
4470 /* Finish up dynamic symbol handling.  We set the contents of various
4471    dynamic sections here.  */
4472
4473 static bfd_boolean
4474 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4475                                 struct bfd_link_info *info,
4476                                 struct elf_link_hash_entry *h,
4477                                 Elf_Internal_Sym *sym)
4478 {
4479   struct elf_i386_link_hash_table *htab;
4480   unsigned plt_entry_size;
4481   const struct elf_i386_backend_data *abed;
4482
4483   htab = elf_i386_hash_table (info);
4484   if (htab == NULL)
4485     return FALSE;
4486
4487   abed = get_elf_i386_backend_data (output_bfd);
4488   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
4489
4490   if (h->plt.offset != (bfd_vma) -1)
4491     {
4492       bfd_vma plt_index;
4493       bfd_vma got_offset;
4494       Elf_Internal_Rela rel;
4495       bfd_byte *loc;
4496       asection *plt, *gotplt, *relplt;
4497
4498       /* When building a static executable, use .iplt, .igot.plt and
4499          .rel.iplt sections for STT_GNU_IFUNC symbols.  */
4500       if (htab->elf.splt != NULL)
4501         {
4502           plt = htab->elf.splt;
4503           gotplt = htab->elf.sgotplt;
4504           relplt = htab->elf.srelplt;
4505         }
4506       else
4507         {
4508           plt = htab->elf.iplt;
4509           gotplt = htab->elf.igotplt;
4510           relplt = htab->elf.irelplt;
4511         }
4512
4513       /* This symbol has an entry in the procedure linkage table.  Set
4514          it up.  */
4515
4516       if ((h->dynindx == -1
4517            && !((h->forced_local || info->executable)
4518                 && h->def_regular
4519                 && h->type == STT_GNU_IFUNC))
4520           || plt == NULL
4521           || gotplt == NULL
4522           || relplt == NULL)
4523         return FALSE;
4524
4525       /* Get the index in the procedure linkage table which
4526          corresponds to this symbol.  This is the index of this symbol
4527          in all the symbols for which we are making plt entries.  The
4528          first entry in the procedure linkage table is reserved.
4529
4530          Get the offset into the .got table of the entry that
4531          corresponds to this function.  Each .got entry is 4 bytes.
4532          The first three are reserved.
4533
4534          For static executables, we don't reserve anything.  */
4535
4536       if (plt == htab->elf.splt)
4537         {
4538           got_offset = h->plt.offset / plt_entry_size - 1;
4539           got_offset = (got_offset + 3) * 4;
4540         }
4541       else
4542         {
4543           got_offset = h->plt.offset / plt_entry_size;
4544           got_offset = got_offset * 4;
4545         }
4546
4547       /* Fill in the entry in the procedure linkage table.  */
4548       if (! info->shared)
4549         {
4550           memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
4551                   abed->plt->plt_entry_size);
4552           bfd_put_32 (output_bfd,
4553                       (gotplt->output_section->vma
4554                        + gotplt->output_offset
4555                        + got_offset),
4556                       plt->contents + h->plt.offset
4557                       + abed->plt->plt_got_offset);
4558
4559           if (abed->is_vxworks)
4560             {
4561               int s, k, reloc_index;
4562
4563               /* Create the R_386_32 relocation referencing the GOT
4564                  for this PLT entry.  */
4565
4566               /* S: Current slot number (zero-based).  */
4567               s = ((h->plt.offset - abed->plt->plt_entry_size)
4568                    / abed->plt->plt_entry_size);
4569               /* K: Number of relocations for PLTResolve. */
4570               if (info->shared)
4571                 k = PLTRESOLVE_RELOCS_SHLIB;
4572               else
4573                 k = PLTRESOLVE_RELOCS;
4574               /* Skip the PLTresolve relocations, and the relocations for
4575                  the other PLT slots. */
4576               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4577               loc = (htab->srelplt2->contents + reloc_index
4578                      * sizeof (Elf32_External_Rel));
4579
4580               rel.r_offset = (htab->elf.splt->output_section->vma
4581                               + htab->elf.splt->output_offset
4582                               + h->plt.offset + 2),
4583               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4584               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4585
4586               /* Create the R_386_32 relocation referencing the beginning of
4587                  the PLT for this GOT entry.  */
4588               rel.r_offset = (htab->elf.sgotplt->output_section->vma
4589                               + htab->elf.sgotplt->output_offset
4590                               + got_offset);
4591               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4592               bfd_elf32_swap_reloc_out (output_bfd, &rel,
4593               loc + sizeof (Elf32_External_Rel));
4594             }
4595         }
4596       else
4597         {
4598           memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
4599                   abed->plt->plt_entry_size);
4600           bfd_put_32 (output_bfd, got_offset,
4601                       plt->contents + h->plt.offset
4602                       + abed->plt->plt_got_offset);
4603         }
4604
4605       /* Fill in the entry in the global offset table.  */
4606       bfd_put_32 (output_bfd,
4607                   (plt->output_section->vma
4608                    + plt->output_offset
4609                    + h->plt.offset
4610                    + abed->plt->plt_lazy_offset),
4611                   gotplt->contents + got_offset);
4612
4613       /* Fill in the entry in the .rel.plt section.  */
4614       rel.r_offset = (gotplt->output_section->vma
4615                       + gotplt->output_offset
4616                       + got_offset);
4617       if (h->dynindx == -1
4618           || ((info->executable
4619                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4620               && h->def_regular
4621                && h->type == STT_GNU_IFUNC))
4622         {
4623           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4624              R_386_IRELATIVE instead of R_386_JUMP_SLOT.  Store addend
4625              in the .got.plt section.  */
4626           bfd_put_32 (output_bfd,
4627                       (h->root.u.def.value
4628                        + h->root.u.def.section->output_section->vma
4629                        + h->root.u.def.section->output_offset),
4630                       gotplt->contents + got_offset);
4631           rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4632           /* R_386_IRELATIVE comes last.  */
4633           plt_index = htab->next_irelative_index--;
4634         }
4635       else
4636         {
4637           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
4638           plt_index = htab->next_jump_slot_index++;
4639         }
4640       loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
4641       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4642
4643       /* Don't fill PLT entry for static executables.  */
4644       if (plt == htab->elf.splt)
4645         {
4646           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
4647                       plt->contents + h->plt.offset
4648                       + abed->plt->plt_reloc_offset);
4649           bfd_put_32 (output_bfd, - (h->plt.offset
4650                                      + abed->plt->plt_plt_offset + 4),
4651                       plt->contents + h->plt.offset
4652                       + abed->plt->plt_plt_offset);
4653         }
4654
4655       if (!h->def_regular)
4656         {
4657           /* Mark the symbol as undefined, rather than as defined in
4658              the .plt section.  Leave the value if there were any
4659              relocations where pointer equality matters (this is a clue
4660              for the dynamic linker, to make function pointer
4661              comparisons work between an application and shared
4662              library), otherwise set it to zero.  If a function is only
4663              called from a binary, there is no need to slow down
4664              shared libraries because of that.  */
4665           sym->st_shndx = SHN_UNDEF;
4666           if (!h->pointer_equality_needed)
4667             sym->st_value = 0;
4668         }
4669     }
4670
4671   if (h->got.offset != (bfd_vma) -1
4672       && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
4673       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
4674     {
4675       Elf_Internal_Rela rel;
4676       bfd_byte *loc;
4677
4678       /* This symbol has an entry in the global offset table.  Set it
4679          up.  */
4680
4681       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4682         abort ();
4683
4684       rel.r_offset = (htab->elf.sgot->output_section->vma
4685                       + htab->elf.sgot->output_offset
4686                       + (h->got.offset & ~(bfd_vma) 1));
4687
4688       /* If this is a static link, or it is a -Bsymbolic link and the
4689          symbol is defined locally or was forced to be local because
4690          of a version file, we just want to emit a RELATIVE reloc.
4691          The entry in the global offset table will already have been
4692          initialized in the relocate_section function.  */
4693       if (h->def_regular
4694           && h->type == STT_GNU_IFUNC)
4695         {
4696           if (info->shared)
4697             {
4698               /* Generate R_386_GLOB_DAT.  */
4699               goto do_glob_dat;
4700             }
4701           else
4702             {
4703               asection *plt;
4704
4705               if (!h->pointer_equality_needed)
4706                 abort ();
4707
4708               /* For non-shared object, we can't use .got.plt, which
4709                  contains the real function addres if we need pointer
4710                  equality.  We load the GOT entry with the PLT entry.  */
4711               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4712               bfd_put_32 (output_bfd,
4713                           (plt->output_section->vma
4714                            + plt->output_offset + h->plt.offset),
4715                           htab->elf.sgot->contents + h->got.offset);
4716               return TRUE;
4717             }
4718         }
4719       else if (info->shared
4720                && SYMBOL_REFERENCES_LOCAL (info, h))
4721         {
4722           BFD_ASSERT((h->got.offset & 1) != 0);
4723           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4724         }
4725       else
4726         {
4727           BFD_ASSERT((h->got.offset & 1) == 0);
4728 do_glob_dat:
4729           bfd_put_32 (output_bfd, (bfd_vma) 0,
4730                       htab->elf.sgot->contents + h->got.offset);
4731           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
4732         }
4733
4734       loc = htab->elf.srelgot->contents;
4735       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
4736       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4737     }
4738
4739   if (h->needs_copy)
4740     {
4741       Elf_Internal_Rela rel;
4742       bfd_byte *loc;
4743
4744       /* This symbol needs a copy reloc.  Set it up.  */
4745
4746       if (h->dynindx == -1
4747           || (h->root.type != bfd_link_hash_defined
4748               && h->root.type != bfd_link_hash_defweak)
4749           || htab->srelbss == NULL)
4750         abort ();
4751
4752       rel.r_offset = (h->root.u.def.value
4753                       + h->root.u.def.section->output_section->vma
4754                       + h->root.u.def.section->output_offset);
4755       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
4756       loc = htab->srelbss->contents;
4757       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
4758       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4759     }
4760
4761   return TRUE;
4762 }
4763
4764 /* Finish up local dynamic symbol handling.  We set the contents of
4765    various dynamic sections here.  */
4766
4767 static bfd_boolean
4768 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
4769 {
4770   struct elf_link_hash_entry *h
4771     = (struct elf_link_hash_entry *) *slot;
4772   struct bfd_link_info *info
4773     = (struct bfd_link_info *) inf;
4774
4775   return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
4776                                          h, NULL);
4777 }
4778
4779 /* Used to decide how to sort relocs in an optimal manner for the
4780    dynamic linker, before writing them out.  */
4781
4782 static enum elf_reloc_type_class
4783 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
4784 {
4785   switch (ELF32_R_TYPE (rela->r_info))
4786     {
4787     case R_386_RELATIVE:
4788       return reloc_class_relative;
4789     case R_386_JUMP_SLOT:
4790       return reloc_class_plt;
4791     case R_386_COPY:
4792       return reloc_class_copy;
4793     default:
4794       return reloc_class_normal;
4795     }
4796 }
4797
4798 /* Finish up the dynamic sections.  */
4799
4800 static bfd_boolean
4801 elf_i386_finish_dynamic_sections (bfd *output_bfd,
4802                                   struct bfd_link_info *info)
4803 {
4804   struct elf_i386_link_hash_table *htab;
4805   bfd *dynobj;
4806   asection *sdyn;
4807   const struct elf_i386_backend_data *abed;
4808
4809   htab = elf_i386_hash_table (info);
4810   if (htab == NULL)
4811     return FALSE;
4812
4813   dynobj = htab->elf.dynobj;
4814   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4815   abed = get_elf_i386_backend_data (output_bfd);
4816
4817   if (htab->elf.dynamic_sections_created)
4818     {
4819       Elf32_External_Dyn *dyncon, *dynconend;
4820
4821       if (sdyn == NULL || htab->elf.sgot == NULL)
4822         abort ();
4823
4824       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4825       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4826       for (; dyncon < dynconend; dyncon++)
4827         {
4828           Elf_Internal_Dyn dyn;
4829           asection *s;
4830
4831           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4832
4833           switch (dyn.d_tag)
4834             {
4835             default:
4836               if (abed->is_vxworks
4837                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4838                 break;
4839               continue;
4840
4841             case DT_PLTGOT:
4842               s = htab->elf.sgotplt;
4843               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4844               break;
4845
4846             case DT_JMPREL:
4847               s = htab->elf.srelplt;
4848               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4849               break;
4850
4851             case DT_PLTRELSZ:
4852               s = htab->elf.srelplt;
4853               dyn.d_un.d_val = s->size;
4854               break;
4855
4856             case DT_RELSZ:
4857               /* My reading of the SVR4 ABI indicates that the
4858                  procedure linkage table relocs (DT_JMPREL) should be
4859                  included in the overall relocs (DT_REL).  This is
4860                  what Solaris does.  However, UnixWare can not handle
4861                  that case.  Therefore, we override the DT_RELSZ entry
4862                  here to make it not include the JMPREL relocs.  */
4863               s = htab->elf.srelplt;
4864               if (s == NULL)
4865                 continue;
4866               dyn.d_un.d_val -= s->size;
4867               break;
4868
4869             case DT_REL:
4870               /* We may not be using the standard ELF linker script.
4871                  If .rel.plt is the first .rel section, we adjust
4872                  DT_REL to not include it.  */
4873               s = htab->elf.srelplt;
4874               if (s == NULL)
4875                 continue;
4876               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4877                 continue;
4878               dyn.d_un.d_ptr += s->size;
4879               break;
4880             }
4881
4882           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4883         }
4884
4885       /* Fill in the first entry in the procedure linkage table.  */
4886       if (htab->elf.splt && htab->elf.splt->size > 0)
4887         {
4888           if (info->shared)
4889             {
4890               memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
4891                       abed->plt->plt0_entry_size);
4892               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4893                       abed->plt0_pad_byte,
4894                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4895             }
4896           else
4897             {
4898               memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
4899                       abed->plt->plt0_entry_size);
4900               memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4901                       abed->plt0_pad_byte,
4902                       abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4903               bfd_put_32 (output_bfd,
4904                           (htab->elf.sgotplt->output_section->vma
4905                            + htab->elf.sgotplt->output_offset
4906                            + 4),
4907                           htab->elf.splt->contents
4908                           + abed->plt->plt0_got1_offset);
4909               bfd_put_32 (output_bfd,
4910                           (htab->elf.sgotplt->output_section->vma
4911                            + htab->elf.sgotplt->output_offset
4912                            + 8),
4913                           htab->elf.splt->contents
4914                           + abed->plt->plt0_got2_offset);
4915
4916               if (abed->is_vxworks)
4917                 {
4918                   Elf_Internal_Rela rel;
4919
4920                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4921                      On IA32 we use REL relocations so the addend goes in
4922                      the PLT directly.  */
4923                   rel.r_offset = (htab->elf.splt->output_section->vma
4924                                   + htab->elf.splt->output_offset
4925                                   + abed->plt->plt0_got1_offset);
4926                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4927                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4928                                             htab->srelplt2->contents);
4929                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
4930                   rel.r_offset = (htab->elf.splt->output_section->vma
4931                                   + htab->elf.splt->output_offset
4932                                   + abed->plt->plt0_got2_offset);
4933                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4934                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4935                                             htab->srelplt2->contents +
4936                                             sizeof (Elf32_External_Rel));
4937                 }
4938             }
4939
4940           /* UnixWare sets the entsize of .plt to 4, although that doesn't
4941              really seem like the right value.  */
4942           elf_section_data (htab->elf.splt->output_section)
4943             ->this_hdr.sh_entsize = 4;
4944
4945           /* Correct the .rel.plt.unloaded relocations.  */
4946           if (abed->is_vxworks && !info->shared)
4947             {
4948               int num_plts = (htab->elf.splt->size
4949                               / abed->plt->plt_entry_size) - 1;
4950               unsigned char *p;
4951
4952               p = htab->srelplt2->contents;
4953               if (info->shared)
4954                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4955               else
4956                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4957
4958               for (; num_plts; num_plts--)
4959                 {
4960                   Elf_Internal_Rela rel;
4961                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4962                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4963                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4964                   p += sizeof (Elf32_External_Rel);
4965
4966                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4967                   rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4968                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4969                   p += sizeof (Elf32_External_Rel);
4970                 }
4971             }
4972         }
4973     }
4974
4975   if (htab->elf.sgotplt)
4976     {
4977       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4978         {
4979           (*_bfd_error_handler)
4980             (_("discarded output section: `%A'"), htab->elf.sgotplt);
4981           return FALSE;
4982         }
4983
4984       /* Fill in the first three entries in the global offset table.  */
4985       if (htab->elf.sgotplt->size > 0)
4986         {
4987           bfd_put_32 (output_bfd,
4988                       (sdyn == NULL ? 0
4989                        : sdyn->output_section->vma + sdyn->output_offset),
4990                       htab->elf.sgotplt->contents);
4991           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
4992           bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
4993         }
4994
4995       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
4996     }
4997
4998   /* Adjust .eh_frame for .plt section.  */
4999   if (htab->plt_eh_frame != NULL
5000       && htab->plt_eh_frame->contents != NULL)
5001     {
5002       if (htab->elf.splt != NULL
5003           && htab->elf.splt->size != 0
5004           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5005           && htab->elf.splt->output_section != NULL
5006           && htab->plt_eh_frame->output_section != NULL)
5007         {
5008           bfd_vma plt_start = htab->elf.splt->output_section->vma;
5009           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5010                                    + htab->plt_eh_frame->output_offset
5011                                    + PLT_FDE_START_OFFSET;
5012           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5013                              htab->plt_eh_frame->contents
5014                              + PLT_FDE_START_OFFSET);
5015         }
5016       if (htab->plt_eh_frame->sec_info_type
5017           == SEC_INFO_TYPE_EH_FRAME)
5018         {
5019           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5020                                                  htab->plt_eh_frame,
5021                                                  htab->plt_eh_frame->contents))
5022             return FALSE;
5023         }
5024     }
5025
5026   if (htab->elf.sgot && htab->elf.sgot->size > 0)
5027     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5028
5029   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
5030   htab_traverse (htab->loc_hash_table,
5031                  elf_i386_finish_local_dynamic_symbol,
5032                  info);
5033
5034   return TRUE;
5035 }
5036
5037 /* Return address for Ith PLT stub in section PLT, for relocation REL
5038    or (bfd_vma) -1 if it should not be included.  */
5039
5040 static bfd_vma
5041 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
5042                       const arelent *rel ATTRIBUTE_UNUSED)
5043 {
5044   return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
5045 }
5046
5047 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5048
5049 static bfd_boolean
5050 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5051 {
5052   if (h->plt.offset != (bfd_vma) -1
5053       && !h->def_regular
5054       && !h->pointer_equality_needed)
5055     return FALSE;
5056
5057   return _bfd_elf_hash_symbol (h);
5058 }
5059
5060 /* Hook called by the linker routine which adds symbols from an object
5061    file.  */
5062
5063 static bfd_boolean
5064 elf_i386_add_symbol_hook (bfd * abfd,
5065                           struct bfd_link_info * info ATTRIBUTE_UNUSED,
5066                           Elf_Internal_Sym * sym,
5067                           const char ** namep ATTRIBUTE_UNUSED,
5068                           flagword * flagsp ATTRIBUTE_UNUSED,
5069                           asection ** secp ATTRIBUTE_UNUSED,
5070                           bfd_vma * valp ATTRIBUTE_UNUSED)
5071 {
5072   if ((abfd->flags & DYNAMIC) == 0
5073       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5074           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
5075     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5076
5077   return TRUE;
5078 }
5079
5080 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
5081 #define TARGET_LITTLE_NAME              "elf32-i386"
5082 #define ELF_ARCH                        bfd_arch_i386
5083 #define ELF_TARGET_ID                   I386_ELF_DATA
5084 #define ELF_MACHINE_CODE                EM_386
5085 #define ELF_MAXPAGESIZE                 0x1000
5086
5087 #define elf_backend_can_gc_sections     1
5088 #define elf_backend_can_refcount        1
5089 #define elf_backend_want_got_plt        1
5090 #define elf_backend_plt_readonly        1
5091 #define elf_backend_want_plt_sym        0
5092 #define elf_backend_got_header_size     12
5093 #define elf_backend_plt_alignment       4
5094
5095 /* Support RELA for objdump of prelink objects.  */
5096 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
5097 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
5098
5099 #define bfd_elf32_mkobject                    elf_i386_mkobject
5100
5101 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
5102 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
5103 #define bfd_elf32_bfd_link_hash_table_free    elf_i386_link_hash_table_free
5104 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
5105 #define bfd_elf32_bfd_reloc_name_lookup       elf_i386_reloc_name_lookup
5106
5107 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
5108 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
5109 #define elf_backend_check_relocs              elf_i386_check_relocs
5110 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
5111 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
5112 #define elf_backend_fake_sections             elf_i386_fake_sections
5113 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
5114 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
5115 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
5116 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
5117 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
5118 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
5119 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
5120 #define elf_backend_relocate_section          elf_i386_relocate_section
5121 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
5122 #define elf_backend_always_size_sections      elf_i386_always_size_sections
5123 #define elf_backend_omit_section_dynsym \
5124   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5125 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
5126 #define elf_backend_hash_symbol               elf_i386_hash_symbol
5127 #define elf_backend_add_symbol_hook           elf_i386_add_symbol_hook
5128 #undef  elf_backend_post_process_headers
5129 #define elf_backend_post_process_headers        _bfd_elf_set_osabi
5130
5131 #include "elf32-target.h"
5132
5133 /* FreeBSD support.  */
5134
5135 #undef  TARGET_LITTLE_SYM
5136 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
5137 #undef  TARGET_LITTLE_NAME
5138 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
5139 #undef  ELF_OSABI
5140 #define ELF_OSABI                       ELFOSABI_FREEBSD
5141
5142 /* The kernel recognizes executables as valid only if they carry a
5143    "FreeBSD" label in the ELF header.  So we put this label on all
5144    executables and (for simplicity) also all other object files.  */
5145
5146 static void
5147 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5148 {
5149   _bfd_elf_set_osabi (abfd, info);
5150
5151 #ifdef OLD_FREEBSD_ABI_LABEL
5152   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
5153   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5154 #endif
5155 }
5156
5157 #undef  elf_backend_post_process_headers
5158 #define elf_backend_post_process_headers        elf_i386_fbsd_post_process_headers
5159 #undef  elf32_bed
5160 #define elf32_bed                               elf32_i386_fbsd_bed
5161
5162 #undef elf_backend_add_symbol_hook
5163
5164 #include "elf32-target.h"
5165
5166 /* Solaris 2.  */
5167
5168 #undef  TARGET_LITTLE_SYM
5169 #define TARGET_LITTLE_SYM               bfd_elf32_i386_sol2_vec
5170 #undef  TARGET_LITTLE_NAME
5171 #define TARGET_LITTLE_NAME              "elf32-i386-sol2"
5172
5173 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5174    objects won't be recognized.  */
5175 #undef ELF_OSABI
5176
5177 #undef  elf32_bed
5178 #define elf32_bed                       elf32_i386_sol2_bed
5179
5180 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5181    boundary.  */
5182 #undef elf_backend_static_tls_alignment
5183 #define elf_backend_static_tls_alignment 8
5184
5185 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5186
5187    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5188    File, p.63.  */
5189 #undef elf_backend_want_plt_sym
5190 #define elf_backend_want_plt_sym        1
5191
5192 #include "elf32-target.h"
5193
5194 /* Native Client support.  */
5195
5196 #undef  TARGET_LITTLE_SYM
5197 #define TARGET_LITTLE_SYM               bfd_elf32_i386_nacl_vec
5198 #undef  TARGET_LITTLE_NAME
5199 #define TARGET_LITTLE_NAME              "elf32-i386-nacl"
5200 #undef  elf32_bed
5201 #define elf32_bed                       elf32_i386_nacl_bed
5202
5203 #undef  ELF_MAXPAGESIZE
5204 #define ELF_MAXPAGESIZE                 0x10000
5205
5206 /* Restore defaults.  */
5207 #undef  ELF_OSABI
5208 #undef  elf_backend_want_plt_sym
5209 #define elf_backend_want_plt_sym        0
5210 #undef  elf_backend_post_process_headers
5211 #define elf_backend_post_process_headers        _bfd_elf_set_osabi
5212 #undef  elf_backend_static_tls_alignment
5213
5214 /* NaCl uses substantially different PLT entries for the same effects.  */
5215
5216 #undef  elf_backend_plt_alignment
5217 #define elf_backend_plt_alignment       5
5218 #define NACL_PLT_ENTRY_SIZE             64
5219 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5220
5221 static const bfd_byte elf_i386_nacl_plt0_entry[] =
5222   {
5223     0xff, 0x35,                   /* pushl contents of address */
5224     0, 0, 0, 0,                   /* replaced with address of .got + 4.  */
5225     0x8b, 0x0d,                   /* movl contents of address, %ecx */
5226     0, 0, 0, 0,                   /* replaced with address of .got + 8.  */
5227     0x83, 0xe1, NACLMASK,         /* andl $NACLMASK, %ecx */
5228     0xff, 0xe1                    /* jmp *%ecx */
5229   };
5230
5231 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5232   {
5233     0x8b, 0x0d,                         /* movl contents of address, %ecx */
5234     0, 0, 0, 0,                         /* replaced with GOT slot address.  */
5235     0x83, 0xe1, NACLMASK,               /* andl $NACLMASK, %ecx */
5236     0xff, 0xe1,                         /* jmp *%ecx */
5237
5238     /* Pad to the next 32-byte boundary with nop instructions.  */
5239     0x90,
5240     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5241     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5242
5243     /* Lazy GOT entries point here (32-byte aligned).  */
5244     0x68,                              /* pushl immediate */
5245     0, 0, 0, 0,                        /* replaced with reloc offset.  */
5246     0xe9,                              /* jmp relative */
5247     0, 0, 0, 0,                        /* replaced with offset to .plt.  */
5248
5249     /* Pad to the next 32-byte boundary with nop instructions.  */
5250     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5251     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5252     0x90, 0x90
5253   };
5254
5255 static const bfd_byte
5256 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
5257   {
5258     0xff, 0x73, 0x04,           /* pushl 4(%ebx) */
5259     0x8b, 0x4b, 0x08,           /* mov 0x8(%ebx), %ecx */
5260     0x83, 0xe1, 0xe0,           /* and $NACLMASK, %ecx */
5261     0xff, 0xe1,                 /* jmp *%ecx */
5262
5263     /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5264        so pad to that size with nop instructions.  */
5265     0x90, 0x90, 0x90, 0x90, 0x90, 0x90
5266   };
5267
5268 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
5269   {
5270     0x8b, 0x8b,          /* movl offset(%ebx), %ecx */
5271     0, 0, 0, 0,          /* replaced with offset of this symbol in .got.  */
5272     0x83, 0xe1, 0xe0,    /* andl $NACLMASK, %ecx */
5273     0xff, 0xe1,          /* jmp *%ecx */
5274
5275     /* Pad to the next 32-byte boundary with nop instructions.  */
5276     0x90,
5277     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5278     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5279
5280     /* Lazy GOT entries point here (32-byte aligned).  */
5281     0x68,                /* pushl immediate */
5282     0, 0, 0, 0,          /* replaced with offset into relocation table.  */
5283     0xe9,                /* jmp relative */
5284     0, 0, 0, 0,          /* replaced with offset to start of .plt.  */
5285
5286     /* Pad to the next 32-byte boundary with nop instructions.  */
5287     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5288     0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5289     0x90, 0x90
5290   };
5291
5292 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
5293   {
5294 #if (PLT_CIE_LENGTH != 20                               \
5295      || PLT_FDE_LENGTH != 36                            \
5296      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5297      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5298 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
5299 #endif
5300     PLT_CIE_LENGTH, 0, 0, 0,            /* CIE length */
5301     0, 0, 0, 0,                         /* CIE ID */
5302     1,                                  /* CIE version */
5303     'z', 'R', 0,                        /* Augmentation string */
5304     1,                                  /* Code alignment factor */
5305     0x7c,                               /* Data alignment factor: -4 */
5306     8,                                  /* Return address column */
5307     1,                                  /* Augmentation size */
5308     DW_EH_PE_pcrel | DW_EH_PE_sdata4,   /* FDE encoding */
5309     DW_CFA_def_cfa, 4, 4,               /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
5310     DW_CFA_offset + 8, 1,               /* DW_CFA_offset: r8 (eip) at cfa-4 */
5311     DW_CFA_nop, DW_CFA_nop,
5312
5313     PLT_FDE_LENGTH, 0, 0, 0,     /* FDE length */
5314     PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
5315     0, 0, 0, 0,                  /* R_386_PC32 .plt goes here */
5316     0, 0, 0, 0,                  /* .plt size goes here */
5317     0,                           /* Augmentation size */
5318     DW_CFA_def_cfa_offset, 8,    /* DW_CFA_def_cfa_offset: 8 */
5319     DW_CFA_advance_loc + 6,      /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5320     DW_CFA_def_cfa_offset, 12,   /* DW_CFA_def_cfa_offset: 12 */
5321     DW_CFA_advance_loc + 58,     /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5322     DW_CFA_def_cfa_expression,   /* DW_CFA_def_cfa_expression */
5323     13,                          /* Block length */
5324     DW_OP_breg4, 4,              /* DW_OP_breg4 (esp): 4 */
5325     DW_OP_breg8, 0,              /* DW_OP_breg8 (eip): 0 */
5326     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5327     DW_OP_lit2, DW_OP_shl, DW_OP_plus,
5328     DW_CFA_nop, DW_CFA_nop
5329   };
5330
5331 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
5332   {
5333     elf_i386_nacl_plt0_entry,           /* plt0_entry */
5334     sizeof (elf_i386_nacl_plt0_entry),  /* plt0_entry_size */
5335     2,                                  /* plt0_got1_offset */
5336     8,                                  /* plt0_got2_offset */
5337     elf_i386_nacl_plt_entry,            /* plt_entry */
5338     NACL_PLT_ENTRY_SIZE,                /* plt_entry_size */
5339     2,                                  /* plt_got_offset */
5340     33,                                 /* plt_reloc_offset */
5341     38,                                 /* plt_plt_offset */
5342     32,                                 /* plt_lazy_offset */
5343     elf_i386_nacl_pic_plt0_entry,       /* pic_plt0_entry */
5344     elf_i386_nacl_pic_plt_entry,        /* pic_plt_entry */
5345     elf_i386_nacl_eh_frame_plt,         /* eh_frame_plt */
5346     sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
5347   };
5348
5349 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
5350   {
5351     &elf_i386_nacl_plt,                      /* plt */
5352     0x90,                               /* plt0_pad_byte: nop insn */
5353     0,                                  /* is_vxworks */
5354   };
5355
5356 #undef  elf_backend_arch_data
5357 #define elf_backend_arch_data   &elf_i386_nacl_arch_bed
5358
5359 #undef  elf_backend_modify_segment_map
5360 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5361 #undef  elf_backend_modify_program_headers
5362 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5363
5364 #include "elf32-target.h"
5365
5366 /* Restore defaults.  */
5367 #undef  elf_backend_modify_segment_map
5368 #undef  elf_backend_modify_program_headers
5369
5370 /* VxWorks support.  */
5371
5372 #undef  TARGET_LITTLE_SYM
5373 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
5374 #undef  TARGET_LITTLE_NAME
5375 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
5376 #undef  ELF_OSABI
5377 #undef  elf_backend_plt_alignment
5378 #define elf_backend_plt_alignment       4
5379
5380 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
5381   {
5382     &elf_i386_plt,                      /* plt */
5383     0x90,                               /* plt0_pad_byte */
5384     1,                                  /* is_vxworks */
5385   };
5386
5387 #undef  elf_backend_arch_data
5388 #define elf_backend_arch_data   &elf_i386_vxworks_arch_bed
5389
5390 #undef elf_backend_relocs_compatible
5391 #undef elf_backend_post_process_headers
5392 #undef elf_backend_add_symbol_hook
5393 #define elf_backend_add_symbol_hook \
5394   elf_vxworks_add_symbol_hook
5395 #undef elf_backend_link_output_symbol_hook
5396 #define elf_backend_link_output_symbol_hook \
5397   elf_vxworks_link_output_symbol_hook
5398 #undef elf_backend_emit_relocs
5399 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
5400 #undef elf_backend_final_write_processing
5401 #define elf_backend_final_write_processing \
5402   elf_vxworks_final_write_processing
5403 #undef elf_backend_static_tls_alignment
5404
5405 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
5406    define it.  */
5407 #undef elf_backend_want_plt_sym
5408 #define elf_backend_want_plt_sym        1
5409
5410 #undef  elf32_bed
5411 #define elf32_bed                               elf32_i386_vxworks_bed
5412
5413 #include "elf32-target.h"