contrib/binutils-2.25/bfd/elf32-i386.c

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