bfd/elf32-i386.c

   1 /* Intel 80386/80486-specific support for 32-bit ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf-vxworks.h"
  27
  28 /* 386 uses REL relocations instead of RELA.  */
  29 #define USE_REL 1
  30
  31 #include "elf/i386.h"
  32
  33 static reloc_howto_type elf_howto_table[]=
  34 {
  35   HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
  36         bfd_elf_generic_reloc, "R_386_NONE",
  37         TRUE, 0x00000000, 0x00000000, FALSE),
  38   HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  39         bfd_elf_generic_reloc, "R_386_32",
  40         TRUE, 0xffffffff, 0xffffffff, FALSE),
  41   HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  42         bfd_elf_generic_reloc, "R_386_PC32",
  43         TRUE, 0xffffffff, 0xffffffff, TRUE),
  44   HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  45         bfd_elf_generic_reloc, "R_386_GOT32",
  46         TRUE, 0xffffffff, 0xffffffff, FALSE),
  47   HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  48         bfd_elf_generic_reloc, "R_386_PLT32",
  49         TRUE, 0xffffffff, 0xffffffff, TRUE),
  50   HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  51         bfd_elf_generic_reloc, "R_386_COPY",
  52         TRUE, 0xffffffff, 0xffffffff, FALSE),
  53   HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  54         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
  55         TRUE, 0xffffffff, 0xffffffff, FALSE),
  56   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  57         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
  58         TRUE, 0xffffffff, 0xffffffff, FALSE),
  59   HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  60         bfd_elf_generic_reloc, "R_386_RELATIVE",
  61         TRUE, 0xffffffff, 0xffffffff, FALSE),
  62   HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  63         bfd_elf_generic_reloc, "R_386_GOTOFF",
  64         TRUE, 0xffffffff, 0xffffffff, FALSE),
  65   HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  66         bfd_elf_generic_reloc, "R_386_GOTPC",
  67         TRUE, 0xffffffff, 0xffffffff, TRUE),
  68
  69   /* We have a gap in the reloc numbers here.
  70      R_386_standard counts the number up to this point, and
  71      R_386_ext_offset is the value to subtract from a reloc type of
  72      R_386_16 thru R_386_PC8 to form an index into this table.  */
  73 #define R_386_standard (R_386_GOTPC + 1)
  74 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
  75
  76   /* These relocs are a GNU extension.  */
  77   HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  78         bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
  79         TRUE, 0xffffffff, 0xffffffff, FALSE),
  80   HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  81         bfd_elf_generic_reloc, "R_386_TLS_IE",
  82         TRUE, 0xffffffff, 0xffffffff, FALSE),
  83   HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  84         bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
  85         TRUE, 0xffffffff, 0xffffffff, FALSE),
  86   HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  87         bfd_elf_generic_reloc, "R_386_TLS_LE",
  88         TRUE, 0xffffffff, 0xffffffff, FALSE),
  89   HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  90         bfd_elf_generic_reloc, "R_386_TLS_GD",
  91         TRUE, 0xffffffff, 0xffffffff, FALSE),
  92   HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  93         bfd_elf_generic_reloc, "R_386_TLS_LDM",
  94         TRUE, 0xffffffff, 0xffffffff, FALSE),
  95   HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  96         bfd_elf_generic_reloc, "R_386_16",
  97         TRUE, 0xffff, 0xffff, FALSE),
  98   HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  99         bfd_elf_generic_reloc, "R_386_PC16",
 100         TRUE, 0xffff, 0xffff, TRUE),
 101   HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
 102         bfd_elf_generic_reloc, "R_386_8",
 103         TRUE, 0xff, 0xff, FALSE),
 104   HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
 105         bfd_elf_generic_reloc, "R_386_PC8",
 106         TRUE, 0xff, 0xff, TRUE),
 107
 108 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
 109 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
 110   /* These are common with Solaris TLS implementation.  */
 111   HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 112         bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
 113         TRUE, 0xffffffff, 0xffffffff, FALSE),
 114   HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 115         bfd_elf_generic_reloc, "R_386_TLS_IE_32",
 116         TRUE, 0xffffffff, 0xffffffff, FALSE),
 117   HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 118         bfd_elf_generic_reloc, "R_386_TLS_LE_32",
 119         TRUE, 0xffffffff, 0xffffffff, FALSE),
 120   HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 121         bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
 122         TRUE, 0xffffffff, 0xffffffff, FALSE),
 123   HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 124         bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
 125         TRUE, 0xffffffff, 0xffffffff, FALSE),
 126   HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 127         bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
 128         TRUE, 0xffffffff, 0xffffffff, FALSE),
 129
 130   /* Another gap.  */
 131 #define R_386_tls (R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
 132 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_tls)
 133
 134 /* GNU extension to record C++ vtable hierarchy.  */
 135   HOWTO (R_386_GNU_VTINHERIT,   /* type */
 136          0,                     /* rightshift */
 137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 138          0,                     /* bitsize */
 139          FALSE,                 /* pc_relative */
 140          0,                     /* bitpos */
 141          complain_overflow_dont, /* complain_on_overflow */
 142          NULL,                  /* special_function */
 143          "R_386_GNU_VTINHERIT", /* name */
 144          FALSE,                 /* partial_inplace */
 145          0,                     /* src_mask */
 146          0,                     /* dst_mask */
 147          FALSE),                /* pcrel_offset */
 148
 149 /* GNU extension to record C++ vtable member usage.  */
 150   HOWTO (R_386_GNU_VTENTRY,     /* type */
 151          0,                     /* rightshift */
 152          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 153          0,                     /* bitsize */
 154          FALSE,                 /* pc_relative */
 155          0,                     /* bitpos */
 156          complain_overflow_dont, /* complain_on_overflow */
 157          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 158          "R_386_GNU_VTENTRY",   /* name */
 159          FALSE,                 /* partial_inplace */
 160          0,                     /* src_mask */
 161          0,                     /* dst_mask */
 162          FALSE)                 /* pcrel_offset */
 163
 164 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
 165
 166 };
 167
 168 #ifdef DEBUG_GEN_RELOC
 169 #define TRACE(str) \
 170   fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 171 #else
 172 #define TRACE(str)
 173 #endif
 174
 175 static reloc_howto_type *
 176 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 177                             bfd_reloc_code_real_type code)
 178 {
 179   switch (code)
 180     {
 181     case BFD_RELOC_NONE:
 182       TRACE ("BFD_RELOC_NONE");
 183       return &elf_howto_table[R_386_NONE];
 184
 185     case BFD_RELOC_32:
 186       TRACE ("BFD_RELOC_32");
 187       return &elf_howto_table[R_386_32];
 188
 189     case BFD_RELOC_CTOR:
 190       TRACE ("BFD_RELOC_CTOR");
 191       return &elf_howto_table[R_386_32];
 192
 193     case BFD_RELOC_32_PCREL:
 194       TRACE ("BFD_RELOC_PC32");
 195       return &elf_howto_table[R_386_PC32];
 196
 197     case BFD_RELOC_386_GOT32:
 198       TRACE ("BFD_RELOC_386_GOT32");
 199       return &elf_howto_table[R_386_GOT32];
 200
 201     case BFD_RELOC_386_PLT32:
 202       TRACE ("BFD_RELOC_386_PLT32");
 203       return &elf_howto_table[R_386_PLT32];
 204
 205     case BFD_RELOC_386_COPY:
 206       TRACE ("BFD_RELOC_386_COPY");
 207       return &elf_howto_table[R_386_COPY];
 208
 209     case BFD_RELOC_386_GLOB_DAT:
 210       TRACE ("BFD_RELOC_386_GLOB_DAT");
 211       return &elf_howto_table[R_386_GLOB_DAT];
 212
 213     case BFD_RELOC_386_JUMP_SLOT:
 214       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 215       return &elf_howto_table[R_386_JUMP_SLOT];
 216
 217     case BFD_RELOC_386_RELATIVE:
 218       TRACE ("BFD_RELOC_386_RELATIVE");
 219       return &elf_howto_table[R_386_RELATIVE];
 220
 221     case BFD_RELOC_386_GOTOFF:
 222       TRACE ("BFD_RELOC_386_GOTOFF");
 223       return &elf_howto_table[R_386_GOTOFF];
 224
 225     case BFD_RELOC_386_GOTPC:
 226       TRACE ("BFD_RELOC_386_GOTPC");
 227       return &elf_howto_table[R_386_GOTPC];
 228
 229       /* These relocs are a GNU extension.  */
 230     case BFD_RELOC_386_TLS_TPOFF:
 231       TRACE ("BFD_RELOC_386_TLS_TPOFF");
 232       return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
 233
 234     case BFD_RELOC_386_TLS_IE:
 235       TRACE ("BFD_RELOC_386_TLS_IE");
 236       return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
 237
 238     case BFD_RELOC_386_TLS_GOTIE:
 239       TRACE ("BFD_RELOC_386_TLS_GOTIE");
 240       return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
 241
 242     case BFD_RELOC_386_TLS_LE:
 243       TRACE ("BFD_RELOC_386_TLS_LE");
 244       return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
 245
 246     case BFD_RELOC_386_TLS_GD:
 247       TRACE ("BFD_RELOC_386_TLS_GD");
 248       return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
 249
 250     case BFD_RELOC_386_TLS_LDM:
 251       TRACE ("BFD_RELOC_386_TLS_LDM");
 252       return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
 253
 254     case BFD_RELOC_16:
 255       TRACE ("BFD_RELOC_16");
 256       return &elf_howto_table[R_386_16 - R_386_ext_offset];
 257
 258     case BFD_RELOC_16_PCREL:
 259       TRACE ("BFD_RELOC_16_PCREL");
 260       return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
 261
 262     case BFD_RELOC_8:
 263       TRACE ("BFD_RELOC_8");
 264       return &elf_howto_table[R_386_8 - R_386_ext_offset];
 265
 266     case BFD_RELOC_8_PCREL:
 267       TRACE ("BFD_RELOC_8_PCREL");
 268       return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
 269
 270     /* Common with Sun TLS implementation.  */
 271     case BFD_RELOC_386_TLS_LDO_32:
 272       TRACE ("BFD_RELOC_386_TLS_LDO_32");
 273       return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
 274
 275     case BFD_RELOC_386_TLS_IE_32:
 276       TRACE ("BFD_RELOC_386_TLS_IE_32");
 277       return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
 278
 279     case BFD_RELOC_386_TLS_LE_32:
 280       TRACE ("BFD_RELOC_386_TLS_LE_32");
 281       return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
 282
 283     case BFD_RELOC_386_TLS_DTPMOD32:
 284       TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
 285       return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
 286
 287     case BFD_RELOC_386_TLS_DTPOFF32:
 288       TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
 289       return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
 290
 291     case BFD_RELOC_386_TLS_TPOFF32:
 292       TRACE ("BFD_RELOC_386_TLS_TPOFF32");
 293       return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
 294
 295     case BFD_RELOC_VTABLE_INHERIT:
 296       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 297       return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
 298
 299     case BFD_RELOC_VTABLE_ENTRY:
 300       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 301       return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
 302
 303     default:
 304       break;
 305     }
 306
 307   TRACE ("Unknown");
 308   return 0;
 309 }
 310
 311 static void
 312 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
 313                             arelent *cache_ptr,
 314                             Elf_Internal_Rela *dst)
 315 {
 316   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 317   unsigned int indx;
 318
 319   if ((indx = r_type) >= R_386_standard
 320       && ((indx = r_type - R_386_ext_offset) - R_386_standard
 321           >= R_386_ext - R_386_standard)
 322       && ((indx = r_type - R_386_tls_offset) - R_386_ext
 323           >= R_386_tls - R_386_ext)
 324       && ((indx = r_type - R_386_vt_offset) - R_386_tls
 325           >= R_386_vt - R_386_tls))
 326     {
 327       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 328                              abfd, (int) r_type);
 329       indx = R_386_NONE;
 330     }
 331   cache_ptr->howto = &elf_howto_table[indx];
 332 }
 333
 334 /* Return whether a symbol name implies a local label.  The UnixWare
 335    2.1 cc generates temporary symbols that start with .X, so we
 336    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
 337    If so, we should move the .X recognition into
 338    _bfd_elf_is_local_label_name.  */
 339
 340 static bfd_boolean
 341 elf_i386_is_local_label_name (bfd *abfd, const char *name)
 342 {
 343   if (name[0] == '.' && name[1] == 'X')
 344     return TRUE;
 345
 346   return _bfd_elf_is_local_label_name (abfd, name);
 347 }
 348 \f
 349 /* Support for core dump NOTE sections.  */
 350
 351 static bfd_boolean
 352 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 353 {
 354   int offset;
 355   size_t size;
 356
 357   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
 358     {
 359       int pr_version = bfd_get_32 (abfd, note->descdata);
 360
 361       if (pr_version != 1)
 362         return FALSE;
 363
 364       /* pr_cursig */
 365       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 20);
 366
 367       /* pr_pid */
 368       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
 369
 370       /* pr_reg */
 371       offset = 28;
 372       size = bfd_get_32 (abfd, note->descdata + 8);
 373     }
 374   else
 375     {
 376       switch (note->descsz)
 377         {
 378         default:
 379           return FALSE;
 380
 381         case 144:               /* Linux/i386 */
 382           /* pr_cursig */
 383           elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
 384
 385           /* pr_pid */
 386           elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
 387
 388           /* pr_reg */
 389           offset = 72;
 390           size = 68;
 391
 392           break;
 393         }
 394     }
 395
 396   /* Make a ".reg/999" section.  */
 397   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 398                                           size, note->descpos + offset);
 399 }
 400
 401 static bfd_boolean
 402 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 403 {
 404   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
 405     {
 406       int pr_version = bfd_get_32 (abfd, note->descdata);
 407
 408       if (pr_version != 1)
 409         return FALSE;
 410
 411       elf_tdata (abfd)->core_program
 412         = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
 413       elf_tdata (abfd)->core_command
 414         = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
 415     }
 416   else
 417     {
 418       switch (note->descsz)
 419         {
 420         default:
 421           return FALSE;
 422
 423         case 124:               /* Linux/i386 elf_prpsinfo.  */
 424           elf_tdata (abfd)->core_program
 425             = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 426           elf_tdata (abfd)->core_command
 427             = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 428         }
 429     }
 430
 431   /* Note that for some reason, a spurious space is tacked
 432      onto the end of the args in some (at least one anyway)
 433      implementations, so strip it off if it exists.  */
 434   {
 435     char *command = elf_tdata (abfd)->core_command;
 436     int n = strlen (command);
 437
 438     if (0 < n && command[n - 1] == ' ')
 439       command[n - 1] = '\0';
 440   }
 441
 442   return TRUE;
 443 }
 444 \f
 445 /* Functions for the i386 ELF linker.
 446
 447    In order to gain some understanding of code in this file without
 448    knowing all the intricate details of the linker, note the
 449    following:
 450
 451    Functions named elf_i386_* are called by external routines, other
 452    functions are only called locally.  elf_i386_* functions appear
 453    in this file more or less in the order in which they are called
 454    from external routines.  eg. elf_i386_check_relocs is called
 455    early in the link process, elf_i386_finish_dynamic_sections is
 456    one of the last functions.  */
 457
 458
 459 /* The name of the dynamic interpreter.  This is put in the .interp
 460    section.  */
 461
 462 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 463
 464 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 465    copying dynamic variables from a shared lib into an app's dynbss
 466    section, and instead use a dynamic relocation to point into the
 467    shared lib.  */
 468 #define ELIMINATE_COPY_RELOCS 1
 469
 470 /* The size in bytes of an entry in the procedure linkage table.  */
 471
 472 #define PLT_ENTRY_SIZE 16
 473
 474 /* The first entry in an absolute procedure linkage table looks like
 475    this.  See the SVR4 ABI i386 supplement to see how this works.
 476    Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte.  */
 477
 478 static const bfd_byte elf_i386_plt0_entry[12] =
 479 {
 480   0xff, 0x35,   /* pushl contents of address */
 481   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 482   0xff, 0x25,   /* jmp indirect */
 483   0, 0, 0, 0    /* replaced with address of .got + 8.  */
 484 };
 485
 486 /* Subsequent entries in an absolute procedure linkage table look like
 487    this.  */
 488
 489 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
 490 {
 491   0xff, 0x25,   /* jmp indirect */
 492   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 493   0x68,         /* pushl immediate */
 494   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 495   0xe9,         /* jmp relative */
 496   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 497 };
 498
 499 /* The first entry in a PIC procedure linkage table look like this.
 500    Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte.  */
 501
 502 static const bfd_byte elf_i386_pic_plt0_entry[12] =
 503 {
 504   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 505   0xff, 0xa3, 8, 0, 0, 0        /* jmp *8(%ebx) */
 506 };
 507
 508 /* Subsequent entries in a PIC procedure linkage table look like this.  */
 509
 510 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
 511 {
 512   0xff, 0xa3,   /* jmp *offset(%ebx) */
 513   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 514   0x68,         /* pushl immediate */
 515   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 516   0xe9,         /* jmp relative */
 517   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 518 };
 519
 520 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
 521    for the PLTResolve stub and then for each PLT entry.  */
 522 #define PLTRESOLVE_RELOCS_SHLIB 0
 523 #define PLTRESOLVE_RELOCS 2
 524 #define PLT_NON_JUMP_SLOT_RELOCS 2
 525
 526 /* The i386 linker needs to keep track of the number of relocs that it
 527    decides to copy as dynamic relocs in check_relocs for each symbol.
 528    This is so that it can later discard them if they are found to be
 529    unnecessary.  We store the information in a field extending the
 530    regular ELF linker hash table.  */
 531
 532 struct elf_i386_dyn_relocs
 533 {
 534   struct elf_i386_dyn_relocs *next;
 535
 536   /* The input section of the reloc.  */
 537   asection *sec;
 538
 539   /* Total number of relocs copied for the input section.  */
 540   bfd_size_type count;
 541
 542   /* Number of pc-relative relocs copied for the input section.  */
 543   bfd_size_type pc_count;
 544 };
 545
 546 /* i386 ELF linker hash entry.  */
 547
 548 struct elf_i386_link_hash_entry
 549 {
 550   struct elf_link_hash_entry elf;
 551
 552   /* Track dynamic relocs copied for this symbol.  */
 553   struct elf_i386_dyn_relocs *dyn_relocs;
 554
 555 #define GOT_UNKNOWN     0
 556 #define GOT_NORMAL      1
 557 #define GOT_TLS_GD      2
 558 #define GOT_TLS_IE      4
 559 #define GOT_TLS_IE_POS  5
 560 #define GOT_TLS_IE_NEG  6
 561 #define GOT_TLS_IE_BOTH 7
 562   unsigned char tls_type;
 563 };
 564
 565 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
 566
 567 struct elf_i386_obj_tdata
 568 {
 569   struct elf_obj_tdata root;
 570
 571   /* tls_type for each local got entry.  */
 572   char *local_got_tls_type;
 573 };
 574
 575 #define elf_i386_tdata(abfd) \
 576   ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
 577
 578 #define elf_i386_local_got_tls_type(abfd) \
 579   (elf_i386_tdata (abfd)->local_got_tls_type)
 580
 581 static bfd_boolean
 582 elf_i386_mkobject (bfd *abfd)
 583 {
 584   bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
 585   abfd->tdata.any = bfd_zalloc (abfd, amt);
 586   if (abfd->tdata.any == NULL)
 587     return FALSE;
 588   return TRUE;
 589 }
 590
 591 /* i386 ELF linker hash table.  */
 592
 593 struct elf_i386_link_hash_table
 594 {
 595   struct elf_link_hash_table elf;
 596
 597   /* Short-cuts to get to dynamic linker sections.  */
 598   asection *sgot;
 599   asection *sgotplt;
 600   asection *srelgot;
 601   asection *splt;
 602   asection *srelplt;
 603   asection *sdynbss;
 604   asection *srelbss;
 605
 606   /* The (unloaded but important) .rel.plt.unloaded section on VxWorks.  */
 607   asection *srelplt2;
 608
 609   /* Short-cuts to frequently used symbols for VxWorks targets.  */
 610   struct elf_link_hash_entry *hgot, *hplt;
 611
 612   /* True if the target system is VxWorks.  */
 613   int is_vxworks;
 614
 615   /* Value used to fill the last word of the first plt entry.  */
 616   bfd_byte plt0_pad_byte;
 617
 618   union {
 619     bfd_signed_vma refcount;
 620     bfd_vma offset;
 621   } tls_ldm_got;
 622
 623   /* Small local sym to section mapping cache.  */
 624   struct sym_sec_cache sym_sec;
 625 };
 626
 627 /* Get the i386 ELF linker hash table from a link_info structure.  */
 628
 629 #define elf_i386_hash_table(p) \
 630   ((struct elf_i386_link_hash_table *) ((p)->hash))
 631
 632 /* Create an entry in an i386 ELF linker hash table.  */
 633
 634 static struct bfd_hash_entry *
 635 link_hash_newfunc (struct bfd_hash_entry *entry,
 636                    struct bfd_hash_table *table,
 637                    const char *string)
 638 {
 639   /* Allocate the structure if it has not already been allocated by a
 640      subclass.  */
 641   if (entry == NULL)
 642     {
 643       entry = bfd_hash_allocate (table,
 644                                  sizeof (struct elf_i386_link_hash_entry));
 645       if (entry == NULL)
 646         return entry;
 647     }
 648
 649   /* Call the allocation method of the superclass.  */
 650   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 651   if (entry != NULL)
 652     {
 653       struct elf_i386_link_hash_entry *eh;
 654
 655       eh = (struct elf_i386_link_hash_entry *) entry;
 656       eh->dyn_relocs = NULL;
 657       eh->tls_type = GOT_UNKNOWN;
 658     }
 659
 660   return entry;
 661 }
 662
 663 /* Create an i386 ELF linker hash table.  */
 664
 665 static struct bfd_link_hash_table *
 666 elf_i386_link_hash_table_create (bfd *abfd)
 667 {
 668   struct elf_i386_link_hash_table *ret;
 669   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
 670
 671   ret = bfd_malloc (amt);
 672   if (ret == NULL)
 673     return NULL;
 674
 675   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
 676     {
 677       free (ret);
 678       return NULL;
 679     }
 680
 681   ret->sgot = NULL;
 682   ret->sgotplt = NULL;
 683   ret->srelgot = NULL;
 684   ret->splt = NULL;
 685   ret->srelplt = NULL;
 686   ret->sdynbss = NULL;
 687   ret->srelbss = NULL;
 688   ret->tls_ldm_got.refcount = 0;
 689   ret->sym_sec.abfd = NULL;
 690   ret->is_vxworks = 0;
 691   ret->srelplt2 = NULL;
 692   ret->hgot = NULL;
 693   ret->hplt = NULL;
 694   ret->plt0_pad_byte = 0;
 695
 696   return &ret->elf.root;
 697 }
 698
 699 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
 700    shortcuts to them in our hash table.  */
 701
 702 static bfd_boolean
 703 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 704 {
 705   struct elf_i386_link_hash_table *htab;
 706
 707   if (! _bfd_elf_create_got_section (dynobj, info))
 708     return FALSE;
 709
 710   htab = elf_i386_hash_table (info);
 711   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 712   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 713   if (!htab->sgot || !htab->sgotplt)
 714     abort ();
 715
 716   htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
 717                                                (SEC_ALLOC | SEC_LOAD
 718                                                 | SEC_HAS_CONTENTS
 719                                                 | SEC_IN_MEMORY
 720                                                 | SEC_LINKER_CREATED
 721                                                 | SEC_READONLY));
 722   if (htab->srelgot == NULL
 723       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 724     return FALSE;
 725   return TRUE;
 726 }
 727
 728 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 729    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 730    hash table.  */
 731
 732 static bfd_boolean
 733 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 734 {
 735   struct elf_i386_link_hash_table *htab;
 736   asection * s;
 737   int flags;
 738   const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
 739
 740   htab = elf_i386_hash_table (info);
 741   if (!htab->sgot && !create_got_section (dynobj, info))
 742     return FALSE;
 743
 744   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 745     return FALSE;
 746
 747   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 748   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
 749   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 750   if (!info->shared)
 751     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
 752
 753   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 754       || (!info->shared && !htab->srelbss))
 755     abort ();
 756
 757   if (htab->is_vxworks && !info->shared)
 758     {
 759       s = bfd_make_section (dynobj, ".rel.plt.unloaded");
 760       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_READONLY
 761               | SEC_LINKER_CREATED);
 762       if (s == NULL
 763          || ! bfd_set_section_flags (dynobj, s, flags)
 764          || ! bfd_set_section_alignment (dynobj, s, bed->s->log_file_align))
 765        return FALSE;
 766       htab->srelplt2 = s;
 767     }
 768
 769   return TRUE;
 770 }
 771
 772 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 773
 774 static void
 775 elf_i386_copy_indirect_symbol (const struct elf_backend_data *bed,
 776                                struct elf_link_hash_entry *dir,
 777                                struct elf_link_hash_entry *ind)
 778 {
 779   struct elf_i386_link_hash_entry *edir, *eind;
 780
 781   edir = (struct elf_i386_link_hash_entry *) dir;
 782   eind = (struct elf_i386_link_hash_entry *) ind;
 783
 784   if (eind->dyn_relocs != NULL)
 785     {
 786       if (edir->dyn_relocs != NULL)
 787         {
 788           struct elf_i386_dyn_relocs **pp;
 789           struct elf_i386_dyn_relocs *p;
 790
 791           if (ind->root.type == bfd_link_hash_indirect)
 792             abort ();
 793
 794           /* Add reloc counts against the weak sym to the strong sym
 795              list.  Merge any entries against the same section.  */
 796           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 797             {
 798               struct elf_i386_dyn_relocs *q;
 799
 800               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 801                 if (q->sec == p->sec)
 802                   {
 803                     q->pc_count += p->pc_count;
 804                     q->count += p->count;
 805                     *pp = p->next;
 806                     break;
 807                   }
 808               if (q == NULL)
 809                 pp = &p->next;
 810             }
 811           *pp = edir->dyn_relocs;
 812         }
 813
 814       edir->dyn_relocs = eind->dyn_relocs;
 815       eind->dyn_relocs = NULL;
 816     }
 817
 818   if (ind->root.type == bfd_link_hash_indirect
 819       && dir->got.refcount <= 0)
 820     {
 821       edir->tls_type = eind->tls_type;
 822       eind->tls_type = GOT_UNKNOWN;
 823     }
 824
 825   if (ELIMINATE_COPY_RELOCS
 826       && ind->root.type != bfd_link_hash_indirect
 827       && dir->dynamic_adjusted)
 828     {
 829       /* If called to transfer flags for a weakdef during processing
 830          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 831          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 832       dir->ref_dynamic |= ind->ref_dynamic;
 833       dir->ref_regular |= ind->ref_regular;
 834       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 835       dir->needs_plt |= ind->needs_plt;
 836       dir->pointer_equality_needed |= ind->pointer_equality_needed;
 837     }
 838   else
 839     _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 840 }
 841
 842 static int
 843 elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
 844 {
 845   if (info->shared)
 846     return r_type;
 847
 848   switch (r_type)
 849     {
 850     case R_386_TLS_GD:
 851     case R_386_TLS_IE_32:
 852       if (is_local)
 853         return R_386_TLS_LE_32;
 854       return R_386_TLS_IE_32;
 855     case R_386_TLS_IE:
 856     case R_386_TLS_GOTIE:
 857       if (is_local)
 858         return R_386_TLS_LE_32;
 859       return r_type;
 860     case R_386_TLS_LDM:
 861       return R_386_TLS_LE_32;
 862     }
 863
 864   return r_type;
 865 }
 866
 867 /* Look through the relocs for a section during the first phase, and
 868    calculate needed space in the global offset table, procedure linkage
 869    table, and dynamic reloc sections.  */
 870
 871 static bfd_boolean
 872 elf_i386_check_relocs (bfd *abfd,
 873                        struct bfd_link_info *info,
 874                        asection *sec,
 875                        const Elf_Internal_Rela *relocs)
 876 {
 877   struct elf_i386_link_hash_table *htab;
 878   Elf_Internal_Shdr *symtab_hdr;
 879   struct elf_link_hash_entry **sym_hashes;
 880   const Elf_Internal_Rela *rel;
 881   const Elf_Internal_Rela *rel_end;
 882   asection *sreloc;
 883
 884   if (info->relocatable)
 885     return TRUE;
 886
 887   htab = elf_i386_hash_table (info);
 888   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 889   sym_hashes = elf_sym_hashes (abfd);
 890
 891   sreloc = NULL;
 892
 893   rel_end = relocs + sec->reloc_count;
 894   for (rel = relocs; rel < rel_end; rel++)
 895     {
 896       unsigned int r_type;
 897       unsigned long r_symndx;
 898       struct elf_link_hash_entry *h;
 899
 900       r_symndx = ELF32_R_SYM (rel->r_info);
 901       r_type = ELF32_R_TYPE (rel->r_info);
 902
 903       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 904         {
 905           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
 906                                  abfd,
 907                                  r_symndx);
 908           return FALSE;
 909         }
 910
 911       if (r_symndx < symtab_hdr->sh_info)
 912         h = NULL;
 913       else
 914         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 915
 916       r_type = elf_i386_tls_transition (info, r_type, h == NULL);
 917
 918       switch (r_type)
 919         {
 920         case R_386_TLS_LDM:
 921           htab->tls_ldm_got.refcount += 1;
 922           goto create_got;
 923
 924         case R_386_PLT32:
 925           /* This symbol requires a procedure linkage table entry.  We
 926              actually build the entry in adjust_dynamic_symbol,
 927              because this might be a case of linking PIC code which is
 928              never referenced by a dynamic object, in which case we
 929              don't need to generate a procedure linkage table entry
 930              after all.  */
 931
 932           /* If this is a local symbol, we resolve it directly without
 933              creating a procedure linkage table entry.  */
 934           if (h == NULL)
 935             continue;
 936
 937           h->needs_plt = 1;
 938           h->plt.refcount += 1;
 939           break;
 940
 941         case R_386_TLS_IE_32:
 942         case R_386_TLS_IE:
 943         case R_386_TLS_GOTIE:
 944           if (info->shared)
 945             info->flags |= DF_STATIC_TLS;
 946           /* Fall through */
 947
 948         case R_386_GOT32:
 949         case R_386_TLS_GD:
 950           /* This symbol requires a global offset table entry.  */
 951           {
 952             int tls_type, old_tls_type;
 953
 954             switch (r_type)
 955               {
 956               default:
 957               case R_386_GOT32: tls_type = GOT_NORMAL; break;
 958               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
 959               case R_386_TLS_IE_32:
 960                 if (ELF32_R_TYPE (rel->r_info) == r_type)
 961                   tls_type = GOT_TLS_IE_NEG;
 962                 else
 963                   /* If this is a GD->IE transition, we may use either of
 964                      R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  */
 965                   tls_type = GOT_TLS_IE;
 966                 break;
 967               case R_386_TLS_IE:
 968               case R_386_TLS_GOTIE:
 969                 tls_type = GOT_TLS_IE_POS; break;
 970               }
 971
 972             if (h != NULL)
 973               {
 974                 h->got.refcount += 1;
 975                 old_tls_type = elf_i386_hash_entry(h)->tls_type;
 976               }
 977             else
 978               {
 979                 bfd_signed_vma *local_got_refcounts;
 980
 981                 /* This is a global offset table entry for a local symbol.  */
 982                 local_got_refcounts = elf_local_got_refcounts (abfd);
 983                 if (local_got_refcounts == NULL)
 984                   {
 985                     bfd_size_type size;
 986
 987                     size = symtab_hdr->sh_info;
 988                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
 989                     local_got_refcounts = bfd_zalloc (abfd, size);
 990                     if (local_got_refcounts == NULL)
 991                       return FALSE;
 992                     elf_local_got_refcounts (abfd) = local_got_refcounts;
 993                     elf_i386_local_got_tls_type (abfd)
 994                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
 995                   }
 996                 local_got_refcounts[r_symndx] += 1;
 997                 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
 998               }
 999
1000             if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1001               tls_type |= old_tls_type;
1002             /* If a TLS symbol is accessed using IE at least once,
1003                there is no point to use dynamic model for it.  */
1004             else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1005                      && (old_tls_type != GOT_TLS_GD
1006                          || (tls_type & GOT_TLS_IE) == 0))
1007               {
1008                 if ((old_tls_type & GOT_TLS_IE) && tls_type == GOT_TLS_GD)
1009                   tls_type = old_tls_type;
1010                 else
1011                   {
1012                     (*_bfd_error_handler)
1013                       (_("%B: `%s' accessed both as normal and "
1014                          "thread local symbol"),
1015                        abfd,
1016                        h ? h->root.root.string : "<local>");
1017                     return FALSE;
1018                   }
1019               }
1020
1021             if (old_tls_type != tls_type)
1022               {
1023                 if (h != NULL)
1024                   elf_i386_hash_entry (h)->tls_type = tls_type;
1025                 else
1026                   elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1027               }
1028           }
1029           /* Fall through */
1030
1031         case R_386_GOTOFF:
1032         case R_386_GOTPC:
1033         create_got:
1034           if (htab->sgot == NULL)
1035             {
1036               if (htab->elf.dynobj == NULL)
1037                 htab->elf.dynobj = abfd;
1038               if (!create_got_section (htab->elf.dynobj, info))
1039                 return FALSE;
1040             }
1041           if (r_type != R_386_TLS_IE)
1042             break;
1043           /* Fall through */
1044
1045         case R_386_TLS_LE_32:
1046         case R_386_TLS_LE:
1047           if (!info->shared)
1048             break;
1049           info->flags |= DF_STATIC_TLS;
1050           /* Fall through */
1051
1052         case R_386_32:
1053         case R_386_PC32:
1054           if (h != NULL && !info->shared)
1055             {
1056               /* If this reloc is in a read-only section, we might
1057                  need a copy reloc.  We can't check reliably at this
1058                  stage whether the section is read-only, as input
1059                  sections have not yet been mapped to output sections.
1060                  Tentatively set the flag for now, and correct in
1061                  adjust_dynamic_symbol.  */
1062               h->non_got_ref = 1;
1063
1064               /* We may need a .plt entry if the function this reloc
1065                  refers to is in a shared lib.  */
1066               h->plt.refcount += 1;
1067               if (r_type != R_386_PC32)
1068                 h->pointer_equality_needed = 1;
1069             }
1070
1071           /* If we are creating a shared library, and this is a reloc
1072              against a global symbol, or a non PC relative reloc
1073              against a local symbol, then we need to copy the reloc
1074              into the shared library.  However, if we are linking with
1075              -Bsymbolic, we do not need to copy a reloc against a
1076              global symbol which is defined in an object we are
1077              including in the link (i.e., DEF_REGULAR is set).  At
1078              this point we have not seen all the input files, so it is
1079              possible that DEF_REGULAR is not set now but will be set
1080              later (it is never cleared).  In case of a weak definition,
1081              DEF_REGULAR may be cleared later by a strong definition in
1082              a shared library.  We account for that possibility below by
1083              storing information in the relocs_copied field of the hash
1084              table entry.  A similar situation occurs when creating
1085              shared libraries and symbol visibility changes render the
1086              symbol local.
1087
1088              If on the other hand, we are creating an executable, we
1089              may need to keep relocations for symbols satisfied by a
1090              dynamic library if we manage to avoid copy relocs for the
1091              symbol.  */
1092           if ((info->shared
1093                && (sec->flags & SEC_ALLOC) != 0
1094                && (r_type != R_386_PC32
1095                    || (h != NULL
1096                        && (! info->symbolic
1097                            || h->root.type == bfd_link_hash_defweak
1098                            || !h->def_regular))))
1099               || (ELIMINATE_COPY_RELOCS
1100                   && !info->shared
1101                   && (sec->flags & SEC_ALLOC) != 0
1102                   && h != NULL
1103                   && (h->root.type == bfd_link_hash_defweak
1104                       || !h->def_regular)))
1105             {
1106               struct elf_i386_dyn_relocs *p;
1107               struct elf_i386_dyn_relocs **head;
1108
1109               /* We must copy these reloc types into the output file.
1110                  Create a reloc section in dynobj and make room for
1111                  this reloc.  */
1112               if (sreloc == NULL)
1113                 {
1114                   const char *name;
1115                   bfd *dynobj;
1116                   unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1117                   unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1118
1119                   name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1120                   if (name == NULL)
1121                     return FALSE;
1122
1123                   if (strncmp (name, ".rel", 4) != 0
1124                       || strcmp (bfd_get_section_name (abfd, sec),
1125                                  name + 4) != 0)
1126                     {
1127                       (*_bfd_error_handler)
1128                         (_("%B: bad relocation section name `%s\'"),
1129                          abfd, name);
1130                     }
1131
1132                   if (htab->elf.dynobj == NULL)
1133                     htab->elf.dynobj = abfd;
1134
1135                   dynobj = htab->elf.dynobj;
1136                   sreloc = bfd_get_section_by_name (dynobj, name);
1137                   if (sreloc == NULL)
1138                     {
1139                       flagword flags;
1140
1141                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1142                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1143                       if ((sec->flags & SEC_ALLOC) != 0)
1144                         flags |= SEC_ALLOC | SEC_LOAD;
1145                       sreloc = bfd_make_section_with_flags (dynobj,
1146                                                             name,
1147                                                             flags);
1148                       if (sreloc == NULL
1149                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1150                         return FALSE;
1151                     }
1152                   elf_section_data (sec)->sreloc = sreloc;
1153                 }
1154
1155               /* If this is a global symbol, we count the number of
1156                  relocations we need for this symbol.  */
1157               if (h != NULL)
1158                 {
1159                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1160                 }
1161               else
1162                 {
1163                   /* Track dynamic relocs needed for local syms too.
1164                      We really need local syms available to do this
1165                      easily.  Oh well.  */
1166
1167                   asection *s;
1168                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1169                                                  sec, r_symndx);
1170                   if (s == NULL)
1171                     return FALSE;
1172
1173                   head = ((struct elf_i386_dyn_relocs **)
1174                           &elf_section_data (s)->local_dynrel);
1175                 }
1176
1177               p = *head;
1178               if (p == NULL || p->sec != sec)
1179                 {
1180                   bfd_size_type amt = sizeof *p;
1181                   p = bfd_alloc (htab->elf.dynobj, amt);
1182                   if (p == NULL)
1183                     return FALSE;
1184                   p->next = *head;
1185                   *head = p;
1186                   p->sec = sec;
1187                   p->count = 0;
1188                   p->pc_count = 0;
1189                 }
1190
1191               p->count += 1;
1192               if (r_type == R_386_PC32)
1193                 p->pc_count += 1;
1194             }
1195           break;
1196
1197           /* This relocation describes the C++ object vtable hierarchy.
1198              Reconstruct it for later use during GC.  */
1199         case R_386_GNU_VTINHERIT:
1200           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1201             return FALSE;
1202           break;
1203
1204           /* This relocation describes which C++ vtable entries are actually
1205              used.  Record for later use during GC.  */
1206         case R_386_GNU_VTENTRY:
1207           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1208             return FALSE;
1209           break;
1210
1211         default:
1212           break;
1213         }
1214     }
1215
1216   return TRUE;
1217 }
1218
1219 /* Return the section that should be marked against GC for a given
1220    relocation.  */
1221
1222 static asection *
1223 elf_i386_gc_mark_hook (asection *sec,
1224                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
1225                        Elf_Internal_Rela *rel,
1226                        struct elf_link_hash_entry *h,
1227                        Elf_Internal_Sym *sym)
1228 {
1229   if (h != NULL)
1230     {
1231       switch (ELF32_R_TYPE (rel->r_info))
1232         {
1233         case R_386_GNU_VTINHERIT:
1234         case R_386_GNU_VTENTRY:
1235           break;
1236
1237         default:
1238           switch (h->root.type)
1239             {
1240             case bfd_link_hash_defined:
1241             case bfd_link_hash_defweak:
1242               return h->root.u.def.section;
1243
1244             case bfd_link_hash_common:
1245               return h->root.u.c.p->section;
1246
1247             default:
1248               break;
1249             }
1250         }
1251     }
1252   else
1253     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1254
1255   return NULL;
1256 }
1257
1258 /* Update the got entry reference counts for the section being removed.  */
1259
1260 static bfd_boolean
1261 elf_i386_gc_sweep_hook (bfd *abfd,
1262                         struct bfd_link_info *info,
1263                         asection *sec,
1264                         const Elf_Internal_Rela *relocs)
1265 {
1266   Elf_Internal_Shdr *symtab_hdr;
1267   struct elf_link_hash_entry **sym_hashes;
1268   bfd_signed_vma *local_got_refcounts;
1269   const Elf_Internal_Rela *rel, *relend;
1270
1271   elf_section_data (sec)->local_dynrel = NULL;
1272
1273   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1274   sym_hashes = elf_sym_hashes (abfd);
1275   local_got_refcounts = elf_local_got_refcounts (abfd);
1276
1277   relend = relocs + sec->reloc_count;
1278   for (rel = relocs; rel < relend; rel++)
1279     {
1280       unsigned long r_symndx;
1281       unsigned int r_type;
1282       struct elf_link_hash_entry *h = NULL;
1283
1284       r_symndx = ELF32_R_SYM (rel->r_info);
1285       if (r_symndx >= symtab_hdr->sh_info)
1286         {
1287           struct elf_i386_link_hash_entry *eh;
1288           struct elf_i386_dyn_relocs **pp;
1289           struct elf_i386_dyn_relocs *p;
1290
1291           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1292           while (h->root.type == bfd_link_hash_indirect
1293                  || h->root.type == bfd_link_hash_warning)
1294             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1295           eh = (struct elf_i386_link_hash_entry *) h;
1296
1297           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1298             if (p->sec == sec)
1299               {
1300                 /* Everything must go for SEC.  */
1301                 *pp = p->next;
1302                 break;
1303               }
1304         }
1305
1306       r_type = ELF32_R_TYPE (rel->r_info);
1307       r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1308       switch (r_type)
1309         {
1310         case R_386_TLS_LDM:
1311           if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1312             elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1313           break;
1314
1315         case R_386_TLS_GD:
1316         case R_386_TLS_IE_32:
1317         case R_386_TLS_IE:
1318         case R_386_TLS_GOTIE:
1319         case R_386_GOT32:
1320           if (h != NULL)
1321             {
1322               if (h->got.refcount > 0)
1323                 h->got.refcount -= 1;
1324             }
1325           else if (local_got_refcounts != NULL)
1326             {
1327               if (local_got_refcounts[r_symndx] > 0)
1328                 local_got_refcounts[r_symndx] -= 1;
1329             }
1330           break;
1331
1332         case R_386_32:
1333         case R_386_PC32:
1334           if (info->shared)
1335             break;
1336           /* Fall through */
1337
1338         case R_386_PLT32:
1339           if (h != NULL)
1340             {
1341               if (h->plt.refcount > 0)
1342                 h->plt.refcount -= 1;
1343             }
1344           break;
1345
1346         default:
1347           break;
1348         }
1349     }
1350
1351   return TRUE;
1352 }
1353
1354 /* Adjust a symbol defined by a dynamic object and referenced by a
1355    regular object.  The current definition is in some section of the
1356    dynamic object, but we're not including those sections.  We have to
1357    change the definition to something the rest of the link can
1358    understand.  */
1359
1360 static bfd_boolean
1361 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1362                                 struct elf_link_hash_entry *h)
1363 {
1364   struct elf_i386_link_hash_table *htab;
1365   asection *s;
1366   unsigned int power_of_two;
1367
1368   /* If this is a function, put it in the procedure linkage table.  We
1369      will fill in the contents of the procedure linkage table later,
1370      when we know the address of the .got section.  */
1371   if (h->type == STT_FUNC
1372       || h->needs_plt)
1373     {
1374       if (h->plt.refcount <= 0
1375           || SYMBOL_CALLS_LOCAL (info, h)
1376           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1377               && h->root.type == bfd_link_hash_undefweak))
1378         {
1379           /* This case can occur if we saw a PLT32 reloc in an input
1380              file, but the symbol was never referred to by a dynamic
1381              object, or if all references were garbage collected.  In
1382              such a case, we don't actually need to build a procedure
1383              linkage table, and we can just do a PC32 reloc instead.  */
1384           h->plt.offset = (bfd_vma) -1;
1385           h->needs_plt = 0;
1386         }
1387
1388       return TRUE;
1389     }
1390   else
1391     /* It's possible that we incorrectly decided a .plt reloc was
1392        needed for an R_386_PC32 reloc to a non-function sym in
1393        check_relocs.  We can't decide accurately between function and
1394        non-function syms in check-relocs;  Objects loaded later in
1395        the link may change h->type.  So fix it now.  */
1396     h->plt.offset = (bfd_vma) -1;
1397
1398   /* If this is a weak symbol, and there is a real definition, the
1399      processor independent code will have arranged for us to see the
1400      real definition first, and we can just use the same value.  */
1401   if (h->u.weakdef != NULL)
1402     {
1403       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1404                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1405       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1406       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1407       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1408         h->non_got_ref = h->u.weakdef->non_got_ref;
1409       return TRUE;
1410     }
1411
1412   /* This is a reference to a symbol defined by a dynamic object which
1413      is not a function.  */
1414
1415   /* If we are creating a shared library, we must presume that the
1416      only references to the symbol are via the global offset table.
1417      For such cases we need not do anything here; the relocations will
1418      be handled correctly by relocate_section.  */
1419   if (info->shared)
1420     return TRUE;
1421
1422   /* If there are no references to this symbol that do not use the
1423      GOT, we don't need to generate a copy reloc.  */
1424   if (!h->non_got_ref)
1425     return TRUE;
1426
1427   /* If -z nocopyreloc was given, we won't generate them either.  */
1428   if (info->nocopyreloc)
1429     {
1430       h->non_got_ref = 0;
1431       return TRUE;
1432     }
1433
1434   htab = elf_i386_hash_table (info);
1435
1436   /* If there aren't any dynamic relocs in read-only sections, then
1437      we can keep the dynamic relocs and avoid the copy reloc.  This
1438      doesn't work on VxWorks, where we can not have dynamic relocations
1439      (other than copy and jump slot relocations) in an executable.  */
1440   if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
1441     {
1442       struct elf_i386_link_hash_entry * eh;
1443       struct elf_i386_dyn_relocs *p;
1444
1445       eh = (struct elf_i386_link_hash_entry *) h;
1446       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1447         {
1448           s = p->sec->output_section;
1449           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1450             break;
1451         }
1452
1453       if (p == NULL)
1454         {
1455           h->non_got_ref = 0;
1456           return TRUE;
1457         }
1458     }
1459
1460   /* We must allocate the symbol in our .dynbss section, which will
1461      become part of the .bss section of the executable.  There will be
1462      an entry for this symbol in the .dynsym section.  The dynamic
1463      object will contain position independent code, so all references
1464      from the dynamic object to this symbol will go through the global
1465      offset table.  The dynamic linker will use the .dynsym entry to
1466      determine the address it must put in the global offset table, so
1467      both the dynamic object and the regular object will refer to the
1468      same memory location for the variable.  */
1469
1470   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1471      copy the initial value out of the dynamic object and into the
1472      runtime process image.  */
1473   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1474     {
1475       htab->srelbss->size += sizeof (Elf32_External_Rel);
1476       h->needs_copy = 1;
1477     }
1478
1479   /* We need to figure out the alignment required for this symbol.  I
1480      have no idea how ELF linkers handle this.  */
1481   power_of_two = bfd_log2 (h->size);
1482   if (power_of_two > 3)
1483     power_of_two = 3;
1484
1485   /* Apply the required alignment.  */
1486   s = htab->sdynbss;
1487   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1488   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1489     {
1490       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1491         return FALSE;
1492     }
1493
1494   /* Define the symbol as being at this point in the section.  */
1495   h->root.u.def.section = s;
1496   h->root.u.def.value = s->size;
1497
1498   /* Increment the section size to make room for the symbol.  */
1499   s->size += h->size;
1500
1501   return TRUE;
1502 }
1503
1504 /* Allocate space in .plt, .got and associated reloc sections for
1505    dynamic relocs.  */
1506
1507 static bfd_boolean
1508 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1509 {
1510   struct bfd_link_info *info;
1511   struct elf_i386_link_hash_table *htab;
1512   struct elf_i386_link_hash_entry *eh;
1513   struct elf_i386_dyn_relocs *p;
1514
1515   if (h->root.type == bfd_link_hash_indirect)
1516     return TRUE;
1517
1518   if (h->root.type == bfd_link_hash_warning)
1519     /* When warning symbols are created, they **replace** the "real"
1520        entry in the hash table, thus we never get to see the real
1521        symbol in a hash traversal.  So look at it now.  */
1522     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1523
1524   info = (struct bfd_link_info *) inf;
1525   htab = elf_i386_hash_table (info);
1526
1527   if (htab->elf.dynamic_sections_created
1528       && h->plt.refcount > 0)
1529     {
1530       /* Make sure this symbol is output as a dynamic symbol.
1531          Undefined weak syms won't yet be marked as dynamic.  */
1532       if (h->dynindx == -1
1533           && !h->forced_local)
1534         {
1535           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1536             return FALSE;
1537         }
1538
1539       if (info->shared
1540           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1541         {
1542           asection *s = htab->splt;
1543
1544           /* If this is the first .plt entry, make room for the special
1545              first entry.  */
1546           if (s->size == 0)
1547             s->size += PLT_ENTRY_SIZE;
1548
1549           h->plt.offset = s->size;
1550
1551           /* If this symbol is not defined in a regular file, and we are
1552              not generating a shared library, then set the symbol to this
1553              location in the .plt.  This is required to make function
1554              pointers compare as equal between the normal executable and
1555              the shared library.  */
1556           if (! info->shared
1557               && !h->def_regular)
1558             {
1559               h->root.u.def.section = s;
1560               h->root.u.def.value = h->plt.offset;
1561             }
1562
1563           /* Make room for this entry.  */
1564           s->size += PLT_ENTRY_SIZE;
1565
1566           /* We also need to make an entry in the .got.plt section, which
1567              will be placed in the .got section by the linker script.  */
1568           htab->sgotplt->size += 4;
1569
1570           /* We also need to make an entry in the .rel.plt section.  */
1571           htab->srelplt->size += sizeof (Elf32_External_Rel);
1572
1573           if (htab->is_vxworks && !info->shared)
1574             {
1575               /* VxWorks has a second set of relocations for each PLT entry
1576                  in executables.  They go in a separate relocation section,
1577                  which is processed by the kernel loader.  */
1578
1579               /* There are two relocations for the initial PLT entry: an
1580                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1581                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
1582
1583               if (h->plt.offset == PLT_ENTRY_SIZE)
1584                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1585
1586               /* There are two extra relocations for each subsequent PLT entry:
1587                  an R_386_32 relocation for the GOT entry, and an R_386_32
1588                  relocation for the PLT entry.  */
1589
1590               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1591             }
1592         }
1593       else
1594         {
1595           h->plt.offset = (bfd_vma) -1;
1596           h->needs_plt = 0;
1597         }
1598     }
1599   else
1600     {
1601       h->plt.offset = (bfd_vma) -1;
1602       h->needs_plt = 0;
1603     }
1604
1605   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1606      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
1607   if (h->got.refcount > 0
1608       && !info->shared
1609       && h->dynindx == -1
1610       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1611     h->got.offset = (bfd_vma) -1;
1612   else if (h->got.refcount > 0)
1613     {
1614       asection *s;
1615       bfd_boolean dyn;
1616       int tls_type = elf_i386_hash_entry(h)->tls_type;
1617
1618       /* Make sure this symbol is output as a dynamic symbol.
1619          Undefined weak syms won't yet be marked as dynamic.  */
1620       if (h->dynindx == -1
1621           && !h->forced_local)
1622         {
1623           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1624             return FALSE;
1625         }
1626
1627       s = htab->sgot;
1628       h->got.offset = s->size;
1629       s->size += 4;
1630       /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
1631       if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE_BOTH)
1632         s->size += 4;
1633       dyn = htab->elf.dynamic_sections_created;
1634       /* R_386_TLS_IE_32 needs one dynamic relocation,
1635          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1636          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1637          need two), R_386_TLS_GD needs one if local symbol and two if
1638          global.  */
1639       if (tls_type == GOT_TLS_IE_BOTH)
1640         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1641       else if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1642                || (tls_type & GOT_TLS_IE))
1643         htab->srelgot->size += sizeof (Elf32_External_Rel);
1644       else if (tls_type == GOT_TLS_GD)
1645         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1646       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1647                 || h->root.type != bfd_link_hash_undefweak)
1648                && (info->shared
1649                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1650         htab->srelgot->size += sizeof (Elf32_External_Rel);
1651     }
1652   else
1653     h->got.offset = (bfd_vma) -1;
1654
1655   eh = (struct elf_i386_link_hash_entry *) h;
1656   if (eh->dyn_relocs == NULL)
1657     return TRUE;
1658
1659   /* In the shared -Bsymbolic case, discard space allocated for
1660      dynamic pc-relative relocs against symbols which turn out to be
1661      defined in regular objects.  For the normal shared case, discard
1662      space for pc-relative relocs that have become local due to symbol
1663      visibility changes.  */
1664
1665   if (info->shared)
1666     {
1667       /* The only reloc that uses pc_count is R_386_PC32, which will
1668          appear on a call or on something like ".long foo - .".  We
1669          want calls to protected symbols to resolve directly to the
1670          function rather than going via the plt.  If people want
1671          function pointer comparisons to work as expected then they
1672          should avoid writing assembly like ".long foo - .".  */
1673       if (SYMBOL_CALLS_LOCAL (info, h))
1674         {
1675           struct elf_i386_dyn_relocs **pp;
1676
1677           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1678             {
1679               p->count -= p->pc_count;
1680               p->pc_count = 0;
1681               if (p->count == 0)
1682                 *pp = p->next;
1683               else
1684                 pp = &p->next;
1685             }
1686         }
1687
1688       /* Also discard relocs on undefined weak syms with non-default
1689          visibility.  */
1690       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1691           && h->root.type == bfd_link_hash_undefweak)
1692         eh->dyn_relocs = NULL;
1693     }
1694   else if (ELIMINATE_COPY_RELOCS)
1695     {
1696       /* For the non-shared case, discard space for relocs against
1697          symbols which turn out to need copy relocs or are not
1698          dynamic.  */
1699
1700       if (!h->non_got_ref
1701           && ((h->def_dynamic
1702                && !h->def_regular)
1703               || (htab->elf.dynamic_sections_created
1704                   && (h->root.type == bfd_link_hash_undefweak
1705                       || h->root.type == bfd_link_hash_undefined))))
1706         {
1707           /* Make sure this symbol is output as a dynamic symbol.
1708              Undefined weak syms won't yet be marked as dynamic.  */
1709           if (h->dynindx == -1
1710               && !h->forced_local)
1711             {
1712               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1713                 return FALSE;
1714             }
1715
1716           /* If that succeeded, we know we'll be keeping all the
1717              relocs.  */
1718           if (h->dynindx != -1)
1719             goto keep;
1720         }
1721
1722       eh->dyn_relocs = NULL;
1723
1724     keep: ;
1725     }
1726
1727   /* Finally, allocate space.  */
1728   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1729     {
1730       asection *sreloc = elf_section_data (p->sec)->sreloc;
1731       sreloc->size += p->count * sizeof (Elf32_External_Rel);
1732     }
1733
1734   return TRUE;
1735 }
1736
1737 /* Find any dynamic relocs that apply to read-only sections.  */
1738
1739 static bfd_boolean
1740 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1741 {
1742   struct elf_i386_link_hash_entry *eh;
1743   struct elf_i386_dyn_relocs *p;
1744
1745   if (h->root.type == bfd_link_hash_warning)
1746     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1747
1748   eh = (struct elf_i386_link_hash_entry *) h;
1749   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1750     {
1751       asection *s = p->sec->output_section;
1752
1753       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1754         {
1755           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1756
1757           info->flags |= DF_TEXTREL;
1758
1759           /* Not an error, just cut short the traversal.  */
1760           return FALSE;
1761         }
1762     }
1763   return TRUE;
1764 }
1765
1766 /* Set the sizes of the dynamic sections.  */
1767
1768 static bfd_boolean
1769 elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1770                                 struct bfd_link_info *info)
1771 {
1772   struct elf_i386_link_hash_table *htab;
1773   bfd *dynobj;
1774   asection *s;
1775   bfd_boolean relocs;
1776   bfd *ibfd;
1777
1778   htab = elf_i386_hash_table (info);
1779   dynobj = htab->elf.dynobj;
1780   if (dynobj == NULL)
1781     abort ();
1782
1783   if (htab->elf.dynamic_sections_created)
1784     {
1785       /* Set the contents of the .interp section to the interpreter.  */
1786       if (info->executable)
1787         {
1788           s = bfd_get_section_by_name (dynobj, ".interp");
1789           if (s == NULL)
1790             abort ();
1791           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1792           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1793         }
1794     }
1795
1796   /* Set up .got offsets for local syms, and space for local dynamic
1797      relocs.  */
1798   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1799     {
1800       bfd_signed_vma *local_got;
1801       bfd_signed_vma *end_local_got;
1802       char *local_tls_type;
1803       bfd_size_type locsymcount;
1804       Elf_Internal_Shdr *symtab_hdr;
1805       asection *srel;
1806
1807       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1808         continue;
1809
1810       for (s = ibfd->sections; s != NULL; s = s->next)
1811         {
1812           struct elf_i386_dyn_relocs *p;
1813
1814           for (p = *((struct elf_i386_dyn_relocs **)
1815                      &elf_section_data (s)->local_dynrel);
1816                p != NULL;
1817                p = p->next)
1818             {
1819               if (!bfd_is_abs_section (p->sec)
1820                   && bfd_is_abs_section (p->sec->output_section))
1821                 {
1822                   /* Input section has been discarded, either because
1823                      it is a copy of a linkonce section or due to
1824                      linker script /DISCARD/, so we'll be discarding
1825                      the relocs too.  */
1826                 }
1827               else if (p->count != 0)
1828                 {
1829                   srel = elf_section_data (p->sec)->sreloc;
1830                   srel->size += p->count * sizeof (Elf32_External_Rel);
1831                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1832                     info->flags |= DF_TEXTREL;
1833                 }
1834             }
1835         }
1836
1837       local_got = elf_local_got_refcounts (ibfd);
1838       if (!local_got)
1839         continue;
1840
1841       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1842       locsymcount = symtab_hdr->sh_info;
1843       end_local_got = local_got + locsymcount;
1844       local_tls_type = elf_i386_local_got_tls_type (ibfd);
1845       s = htab->sgot;
1846       srel = htab->srelgot;
1847       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1848         {
1849           if (*local_got > 0)
1850             {
1851               *local_got = s->size;
1852               s->size += 4;
1853               if (*local_tls_type == GOT_TLS_GD
1854                   || *local_tls_type == GOT_TLS_IE_BOTH)
1855                 s->size += 4;
1856               if (info->shared
1857                   || *local_tls_type == GOT_TLS_GD
1858                   || (*local_tls_type & GOT_TLS_IE))
1859                 {
1860                   if (*local_tls_type == GOT_TLS_IE_BOTH)
1861                     srel->size += 2 * sizeof (Elf32_External_Rel);
1862                   else
1863                     srel->size += sizeof (Elf32_External_Rel);
1864                 }
1865             }
1866           else
1867             *local_got = (bfd_vma) -1;
1868         }
1869     }
1870
1871   if (htab->tls_ldm_got.refcount > 0)
1872     {
1873       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1874          relocs.  */
1875       htab->tls_ldm_got.offset = htab->sgot->size;
1876       htab->sgot->size += 8;
1877       htab->srelgot->size += sizeof (Elf32_External_Rel);
1878     }
1879   else
1880     htab->tls_ldm_got.offset = -1;
1881
1882   if (htab->is_vxworks)
1883     {
1884       /* Save the GOT and PLT symbols in the hash table for easy access.
1885          Mark them as having relocations; they might not, but we won't
1886          know for sure until we build the GOT in finish_dynamic_symbol.  */
1887
1888       htab->hgot = elf_link_hash_lookup (elf_hash_table (info),
1889                                         "_GLOBAL_OFFSET_TABLE_",
1890                                         FALSE, FALSE, FALSE);
1891       if (htab->hgot)
1892         htab->hgot->indx = -2;
1893       htab->hplt = elf_link_hash_lookup (elf_hash_table (info),
1894                                         "_PROCEDURE_LINKAGE_TABLE_",
1895                                         FALSE, FALSE, FALSE);
1896       if (htab->hplt)
1897         htab->hplt->indx = -2;
1898
1899       if (htab->is_vxworks && htab->hplt && htab->splt->flags & SEC_CODE)
1900         htab->hplt->type = STT_FUNC;
1901     }
1902
1903   /* Allocate global sym .plt and .got entries, and space for global
1904      sym dynamic relocs.  */
1905   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1906
1907   /* We now have determined the sizes of the various dynamic sections.
1908      Allocate memory for them.  */
1909   relocs = FALSE;
1910   for (s = dynobj->sections; s != NULL; s = s->next)
1911     {
1912       bfd_boolean strip_section = TRUE;
1913
1914       if ((s->flags & SEC_LINKER_CREATED) == 0)
1915         continue;
1916
1917       if (s == htab->splt
1918           || s == htab->sgot
1919           || s == htab->sgotplt
1920           || s == htab->sdynbss)
1921         {
1922           /* Strip this section if we don't need it; see the
1923              comment below.  */
1924           /* We'd like to strip these sections if they aren't needed, but if
1925              we've exported dynamic symbols from them we must leave them.
1926              It's too late to tell BFD to get rid of the symbols.  */
1927
1928           if (htab->hplt != NULL)
1929             strip_section = FALSE;
1930         }
1931       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1932         {
1933           if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
1934             relocs = TRUE;
1935
1936           /* We use the reloc_count field as a counter if we need
1937              to copy relocs into the output file.  */
1938           s->reloc_count = 0;
1939         }
1940       else
1941         {
1942           /* It's not one of our sections, so don't allocate space.  */
1943           continue;
1944         }
1945
1946       if (s->size == 0 && strip_section)
1947         {
1948           /* If we don't need this section, strip it from the
1949              output file.  This is mostly to handle .rel.bss and
1950              .rel.plt.  We must create both sections in
1951              create_dynamic_sections, because they must be created
1952              before the linker maps input sections to output
1953              sections.  The linker does that before
1954              adjust_dynamic_symbol is called, and it is that
1955              function which decides whether anything needs to go
1956              into these sections.  */
1957
1958           s->flags |= SEC_EXCLUDE;
1959           continue;
1960         }
1961
1962       /* Allocate memory for the section contents.  We use bfd_zalloc
1963          here in case unused entries are not reclaimed before the
1964          section's contents are written out.  This should not happen,
1965          but this way if it does, we get a R_386_NONE reloc instead
1966          of garbage.  */
1967       s->contents = bfd_zalloc (dynobj, s->size);
1968       if (s->contents == NULL)
1969         return FALSE;
1970     }
1971
1972   if (htab->elf.dynamic_sections_created)
1973     {
1974       /* Add some entries to the .dynamic section.  We fill in the
1975          values later, in elf_i386_finish_dynamic_sections, but we
1976          must add the entries now so that we get the correct size for
1977          the .dynamic section.  The DT_DEBUG entry is filled in by the
1978          dynamic linker and used by the debugger.  */
1979 #define add_dynamic_entry(TAG, VAL) \
1980   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1981
1982       if (info->executable)
1983         {
1984           if (!add_dynamic_entry (DT_DEBUG, 0))
1985             return FALSE;
1986         }
1987
1988       if (htab->splt->size != 0)
1989         {
1990           if (!add_dynamic_entry (DT_PLTGOT, 0)
1991               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1992               || !add_dynamic_entry (DT_PLTREL, DT_REL)
1993               || !add_dynamic_entry (DT_JMPREL, 0))
1994             return FALSE;
1995         }
1996
1997       if (relocs)
1998         {
1999           if (!add_dynamic_entry (DT_REL, 0)
2000               || !add_dynamic_entry (DT_RELSZ, 0)
2001               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2002             return FALSE;
2003
2004           /* If any dynamic relocs apply to a read-only section,
2005              then we need a DT_TEXTREL entry.  */
2006           if ((info->flags & DF_TEXTREL) == 0)
2007             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2008                                     (PTR) info);
2009
2010           if ((info->flags & DF_TEXTREL) != 0)
2011             {
2012               if (!add_dynamic_entry (DT_TEXTREL, 0))
2013                 return FALSE;
2014             }
2015         }
2016     }
2017 #undef add_dynamic_entry
2018
2019   return TRUE;
2020 }
2021
2022 /* Set the correct type for an x86 ELF section.  We do this by the
2023    section name, which is a hack, but ought to work.  */
2024
2025 static bfd_boolean
2026 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2027                         Elf_Internal_Shdr *hdr,
2028                         asection *sec)
2029 {
2030   register const char *name;
2031
2032   name = bfd_get_section_name (abfd, sec);
2033
2034   /* This is an ugly, but unfortunately necessary hack that is
2035      needed when producing EFI binaries on x86. It tells
2036      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2037      containing ELF relocation info.  We need this hack in order to
2038      be able to generate ELF binaries that can be translated into
2039      EFI applications (which are essentially COFF objects).  Those
2040      files contain a COFF ".reloc" section inside an ELFNN object,
2041      which would normally cause BFD to segfault because it would
2042      attempt to interpret this section as containing relocation
2043      entries for section "oc".  With this hack enabled, ".reloc"
2044      will be treated as a normal data section, which will avoid the
2045      segfault.  However, you won't be able to create an ELFNN binary
2046      with a section named "oc" that needs relocations, but that's
2047      the kind of ugly side-effects you get when detecting section
2048      types based on their names...  In practice, this limitation is
2049      unlikely to bite.  */
2050   if (strcmp (name, ".reloc") == 0)
2051     hdr->sh_type = SHT_PROGBITS;
2052
2053   return TRUE;
2054 }
2055
2056 /* Return the base VMA address which should be subtracted from real addresses
2057    when resolving @dtpoff relocation.
2058    This is PT_TLS segment p_vaddr.  */
2059
2060 static bfd_vma
2061 dtpoff_base (struct bfd_link_info *info)
2062 {
2063   /* If tls_sec is NULL, we should have signalled an error already.  */
2064   if (elf_hash_table (info)->tls_sec == NULL)
2065     return 0;
2066   return elf_hash_table (info)->tls_sec->vma;
2067 }
2068
2069 /* Return the relocation value for @tpoff relocation
2070    if STT_TLS virtual address is ADDRESS.  */
2071
2072 static bfd_vma
2073 tpoff (struct bfd_link_info *info, bfd_vma address)
2074 {
2075   struct elf_link_hash_table *htab = elf_hash_table (info);
2076
2077   /* If tls_sec is NULL, we should have signalled an error already.  */
2078   if (htab->tls_sec == NULL)
2079     return 0;
2080   return htab->tls_size + htab->tls_sec->vma - address;
2081 }
2082
2083 /* Relocate an i386 ELF section.  */
2084
2085 static bfd_boolean
2086 elf_i386_relocate_section (bfd *output_bfd,
2087                            struct bfd_link_info *info,
2088                            bfd *input_bfd,
2089                            asection *input_section,
2090                            bfd_byte *contents,
2091                            Elf_Internal_Rela *relocs,
2092                            Elf_Internal_Sym *local_syms,
2093                            asection **local_sections)
2094 {
2095   struct elf_i386_link_hash_table *htab;
2096   Elf_Internal_Shdr *symtab_hdr;
2097   struct elf_link_hash_entry **sym_hashes;
2098   bfd_vma *local_got_offsets;
2099   Elf_Internal_Rela *rel;
2100   Elf_Internal_Rela *relend;
2101
2102   htab = elf_i386_hash_table (info);
2103   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2104   sym_hashes = elf_sym_hashes (input_bfd);
2105   local_got_offsets = elf_local_got_offsets (input_bfd);
2106
2107   rel = relocs;
2108   relend = relocs + input_section->reloc_count;
2109   for (; rel < relend; rel++)
2110     {
2111       unsigned int r_type;
2112       reloc_howto_type *howto;
2113       unsigned long r_symndx;
2114       struct elf_link_hash_entry *h;
2115       Elf_Internal_Sym *sym;
2116       asection *sec;
2117       bfd_vma off;
2118       bfd_vma relocation;
2119       bfd_boolean unresolved_reloc;
2120       bfd_reloc_status_type r;
2121       unsigned int indx;
2122       int tls_type;
2123
2124       r_type = ELF32_R_TYPE (rel->r_info);
2125       if (r_type == R_386_GNU_VTINHERIT
2126           || r_type == R_386_GNU_VTENTRY)
2127         continue;
2128
2129       if ((indx = r_type) >= R_386_standard
2130           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2131               >= R_386_ext - R_386_standard)
2132           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2133               >= R_386_tls - R_386_ext))
2134         {
2135           (*_bfd_error_handler)
2136             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2137              input_bfd, input_section, r_type);
2138           bfd_set_error (bfd_error_bad_value);
2139           return FALSE;
2140         }
2141       howto = elf_howto_table + indx;
2142
2143       r_symndx = ELF32_R_SYM (rel->r_info);
2144
2145       if (info->relocatable)
2146         {
2147           bfd_vma val;
2148           bfd_byte *where;
2149
2150           /* This is a relocatable link.  We don't have to change
2151              anything, unless the reloc is against a section symbol,
2152              in which case we have to adjust according to where the
2153              section symbol winds up in the output section.  */
2154           if (r_symndx >= symtab_hdr->sh_info)
2155             continue;
2156
2157           sym = local_syms + r_symndx;
2158           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2159             continue;
2160
2161           sec = local_sections[r_symndx];
2162           val = sec->output_offset;
2163           if (val == 0)
2164             continue;
2165
2166           where = contents + rel->r_offset;
2167           switch (howto->size)
2168             {
2169               /* FIXME: overflow checks.  */
2170             case 0:
2171               val += bfd_get_8 (input_bfd, where);
2172               bfd_put_8 (input_bfd, val, where);
2173               break;
2174             case 1:
2175               val += bfd_get_16 (input_bfd, where);
2176               bfd_put_16 (input_bfd, val, where);
2177               break;
2178             case 2:
2179               val += bfd_get_32 (input_bfd, where);
2180               bfd_put_32 (input_bfd, val, where);
2181               break;
2182             default:
2183               abort ();
2184             }
2185           continue;
2186         }
2187
2188       /* This is a final link.  */
2189       h = NULL;
2190       sym = NULL;
2191       sec = NULL;
2192       unresolved_reloc = FALSE;
2193       if (r_symndx < symtab_hdr->sh_info)
2194         {
2195           sym = local_syms + r_symndx;
2196           sec = local_sections[r_symndx];
2197           relocation = (sec->output_section->vma
2198                         + sec->output_offset
2199                         + sym->st_value);
2200           if ((sec->flags & SEC_MERGE)
2201               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2202             {
2203               asection *msec;
2204               bfd_vma addend;
2205               bfd_byte *where = contents + rel->r_offset;
2206
2207               switch (howto->size)
2208                 {
2209                 case 0:
2210                   addend = bfd_get_8 (input_bfd, where);
2211                   if (howto->pc_relative)
2212                     {
2213                       addend = (addend ^ 0x80) - 0x80;
2214                       addend += 1;
2215                     }
2216                   break;
2217                 case 1:
2218                   addend = bfd_get_16 (input_bfd, where);
2219                   if (howto->pc_relative)
2220                     {
2221                       addend = (addend ^ 0x8000) - 0x8000;
2222                       addend += 2;
2223                     }
2224                   break;
2225                 case 2:
2226                   addend = bfd_get_32 (input_bfd, where);
2227                   if (howto->pc_relative)
2228                     {
2229                       addend = (addend ^ 0x80000000) - 0x80000000;
2230                       addend += 4;
2231                     }
2232                   break;
2233                 default:
2234                   abort ();
2235                 }
2236
2237               msec = sec;
2238               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2239               addend -= relocation;
2240               addend += msec->output_section->vma + msec->output_offset;
2241
2242               switch (howto->size)
2243                 {
2244                 case 0:
2245                   /* FIXME: overflow checks.  */
2246                   if (howto->pc_relative)
2247                     addend -= 1;
2248                   bfd_put_8 (input_bfd, addend, where);
2249                   break;
2250                 case 1:
2251                   if (howto->pc_relative)
2252                     addend -= 2;
2253                   bfd_put_16 (input_bfd, addend, where);
2254                   break;
2255                 case 2:
2256                   if (howto->pc_relative)
2257                     addend -= 4;
2258                   bfd_put_32 (input_bfd, addend, where);
2259                   break;
2260                 }
2261             }
2262         }
2263       else
2264         {
2265           bfd_boolean warned;
2266
2267           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2268                                    r_symndx, symtab_hdr, sym_hashes,
2269                                    h, sec, relocation,
2270                                    unresolved_reloc, warned);
2271         }
2272
2273       switch (r_type)
2274         {
2275         case R_386_GOT32:
2276           /* Relocation is to the entry for this symbol in the global
2277              offset table.  */
2278           if (htab->sgot == NULL)
2279             abort ();
2280
2281           if (h != NULL)
2282             {
2283               bfd_boolean dyn;
2284
2285               off = h->got.offset;
2286               dyn = htab->elf.dynamic_sections_created;
2287               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2288                   || (info->shared
2289                       && SYMBOL_REFERENCES_LOCAL (info, h))
2290                   || (ELF_ST_VISIBILITY (h->other)
2291                       && h->root.type == bfd_link_hash_undefweak))
2292                 {
2293                   /* This is actually a static link, or it is a
2294                      -Bsymbolic link and the symbol is defined
2295                      locally, or the symbol was forced to be local
2296                      because of a version file.  We must initialize
2297                      this entry in the global offset table.  Since the
2298                      offset must always be a multiple of 4, we use the
2299                      least significant bit to record whether we have
2300                      initialized it already.
2301
2302                      When doing a dynamic link, we create a .rel.got
2303                      relocation entry to initialize the value.  This
2304                      is done in the finish_dynamic_symbol routine.  */
2305                   if ((off & 1) != 0)
2306                     off &= ~1;
2307                   else
2308                     {
2309                       bfd_put_32 (output_bfd, relocation,
2310                                   htab->sgot->contents + off);
2311                       h->got.offset |= 1;
2312                     }
2313                 }
2314               else
2315                 unresolved_reloc = FALSE;
2316             }
2317           else
2318             {
2319               if (local_got_offsets == NULL)
2320                 abort ();
2321
2322               off = local_got_offsets[r_symndx];
2323
2324               /* The offset must always be a multiple of 4.  We use
2325                  the least significant bit to record whether we have
2326                  already generated the necessary reloc.  */
2327               if ((off & 1) != 0)
2328                 off &= ~1;
2329               else
2330                 {
2331                   bfd_put_32 (output_bfd, relocation,
2332                               htab->sgot->contents + off);
2333
2334                   if (info->shared)
2335                     {
2336                       asection *s;
2337                       Elf_Internal_Rela outrel;
2338                       bfd_byte *loc;
2339
2340                       s = htab->srelgot;
2341                       if (s == NULL)
2342                         abort ();
2343
2344                       outrel.r_offset = (htab->sgot->output_section->vma
2345                                          + htab->sgot->output_offset
2346                                          + off);
2347                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2348                       loc = s->contents;
2349                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2350                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2351                     }
2352
2353                   local_got_offsets[r_symndx] |= 1;
2354                 }
2355             }
2356
2357           if (off >= (bfd_vma) -2)
2358             abort ();
2359
2360           relocation = htab->sgot->output_section->vma
2361                        + htab->sgot->output_offset + off
2362                        - htab->sgotplt->output_section->vma
2363                        - htab->sgotplt->output_offset;
2364           break;
2365
2366         case R_386_GOTOFF:
2367           /* Relocation is relative to the start of the global offset
2368              table.  */
2369
2370           /* Check to make sure it isn't a protected function symbol
2371              for shared library since it may not be local when used
2372              as function address.  */
2373           if (info->shared
2374               && !info->executable
2375               && h
2376               && h->def_regular
2377               && h->type == STT_FUNC
2378               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2379             {
2380               (*_bfd_error_handler)
2381                 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2382                  input_bfd, h->root.root.string);
2383               bfd_set_error (bfd_error_bad_value);
2384               return FALSE;
2385             }
2386
2387           /* Note that sgot is not involved in this
2388              calculation.  We always want the start of .got.plt.  If we
2389              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2390              permitted by the ABI, we might have to change this
2391              calculation.  */
2392           relocation -= htab->sgotplt->output_section->vma
2393                         + htab->sgotplt->output_offset;
2394           break;
2395
2396         case R_386_GOTPC:
2397           /* Use global offset table as symbol value.  */
2398           relocation = htab->sgotplt->output_section->vma
2399                        + htab->sgotplt->output_offset;
2400           unresolved_reloc = FALSE;
2401           break;
2402
2403         case R_386_PLT32:
2404           /* Relocation is to the entry for this symbol in the
2405              procedure linkage table.  */
2406
2407           /* Resolve a PLT32 reloc against a local symbol directly,
2408              without using the procedure linkage table.  */
2409           if (h == NULL)
2410             break;
2411
2412           if (h->plt.offset == (bfd_vma) -1
2413               || htab->splt == NULL)
2414             {
2415               /* We didn't make a PLT entry for this symbol.  This
2416                  happens when statically linking PIC code, or when
2417                  using -Bsymbolic.  */
2418               break;
2419             }
2420
2421           relocation = (htab->splt->output_section->vma
2422                         + htab->splt->output_offset
2423                         + h->plt.offset);
2424           unresolved_reloc = FALSE;
2425           break;
2426
2427         case R_386_32:
2428         case R_386_PC32:
2429           /* r_symndx will be zero only for relocs against symbols
2430              from removed linkonce sections, or sections discarded by
2431              a linker script.  */
2432           if (r_symndx == 0)
2433             {
2434               /* Zero the section contents.  eh_frame generated by old
2435                  versions of gcc isn't edited by elf-eh-frame.c, so
2436                  FDEs for discarded linkonce functions might remain.
2437                  Putting zeros here will zero such FDE's address range.
2438                  This is a hint to unwinders and other consumers of
2439                  exception handling info that the FDE is invalid.  */
2440               bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2441               break;
2442             }
2443
2444           if ((input_section->flags & SEC_ALLOC) == 0)
2445             break;
2446
2447           if ((info->shared
2448                && (h == NULL
2449                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2450                    || h->root.type != bfd_link_hash_undefweak)
2451                && (r_type != R_386_PC32
2452                    || !SYMBOL_CALLS_LOCAL (info, h)))
2453               || (ELIMINATE_COPY_RELOCS
2454                   && !info->shared
2455                   && h != NULL
2456                   && h->dynindx != -1
2457                   && !h->non_got_ref
2458                   && ((h->def_dynamic
2459                        && !h->def_regular)
2460                       || h->root.type == bfd_link_hash_undefweak
2461                       || h->root.type == bfd_link_hash_undefined)))
2462             {
2463               Elf_Internal_Rela outrel;
2464               bfd_byte *loc;
2465               bfd_boolean skip, relocate;
2466               asection *sreloc;
2467
2468               /* When generating a shared object, these relocations
2469                  are copied into the output file to be resolved at run
2470                  time.  */
2471
2472               skip = FALSE;
2473               relocate = FALSE;
2474
2475               outrel.r_offset =
2476                 _bfd_elf_section_offset (output_bfd, info, input_section,
2477                                          rel->r_offset);
2478               if (outrel.r_offset == (bfd_vma) -1)
2479                 skip = TRUE;
2480               else if (outrel.r_offset == (bfd_vma) -2)
2481                 skip = TRUE, relocate = TRUE;
2482               outrel.r_offset += (input_section->output_section->vma
2483                                   + input_section->output_offset);
2484
2485               if (skip)
2486                 memset (&outrel, 0, sizeof outrel);
2487               else if (h != NULL
2488                        && h->dynindx != -1
2489                        && (r_type == R_386_PC32
2490                            || !info->shared
2491                            || !info->symbolic
2492                            || !h->def_regular))
2493                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2494               else
2495                 {
2496                   /* This symbol is local, or marked to become local.  */
2497                   relocate = TRUE;
2498                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2499                 }
2500
2501               sreloc = elf_section_data (input_section)->sreloc;
2502               if (sreloc == NULL)
2503                 abort ();
2504
2505               loc = sreloc->contents;
2506               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2507               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2508
2509               /* If this reloc is against an external symbol, we do
2510                  not want to fiddle with the addend.  Otherwise, we
2511                  need to include the symbol value so that it becomes
2512                  an addend for the dynamic reloc.  */
2513               if (! relocate)
2514                 continue;
2515             }
2516           break;
2517
2518         case R_386_TLS_IE:
2519           if (info->shared)
2520             {
2521               Elf_Internal_Rela outrel;
2522               bfd_byte *loc;
2523               asection *sreloc;
2524
2525               outrel.r_offset = rel->r_offset
2526                                 + input_section->output_section->vma
2527                                 + input_section->output_offset;
2528               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2529               sreloc = elf_section_data (input_section)->sreloc;
2530               if (sreloc == NULL)
2531                 abort ();
2532               loc = sreloc->contents;
2533               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2534               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2535             }
2536           /* Fall through */
2537
2538         case R_386_TLS_GD:
2539         case R_386_TLS_IE_32:
2540         case R_386_TLS_GOTIE:
2541           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2542           tls_type = GOT_UNKNOWN;
2543           if (h == NULL && local_got_offsets)
2544             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2545           else if (h != NULL)
2546             {
2547               tls_type = elf_i386_hash_entry(h)->tls_type;
2548               if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2549                 r_type = R_386_TLS_LE_32;
2550             }
2551           if (tls_type == GOT_TLS_IE)
2552             tls_type = GOT_TLS_IE_NEG;
2553           if (r_type == R_386_TLS_GD)
2554             {
2555               if (tls_type == GOT_TLS_IE_POS)
2556                 r_type = R_386_TLS_GOTIE;
2557               else if (tls_type & GOT_TLS_IE)
2558                 r_type = R_386_TLS_IE_32;
2559             }
2560
2561           if (r_type == R_386_TLS_LE_32)
2562             {
2563               BFD_ASSERT (! unresolved_reloc);
2564               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2565                 {
2566                   unsigned int val, type;
2567                   bfd_vma roff;
2568
2569                   /* GD->LE transition.  */
2570                   BFD_ASSERT (rel->r_offset >= 2);
2571                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2572                   BFD_ASSERT (type == 0x8d || type == 0x04);
2573                   BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2574                   BFD_ASSERT (bfd_get_8 (input_bfd,
2575                                          contents + rel->r_offset + 4)
2576                               == 0xe8);
2577                   BFD_ASSERT (rel + 1 < relend);
2578                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2579                   roff = rel->r_offset + 5;
2580                   val = bfd_get_8 (input_bfd,
2581                                    contents + rel->r_offset - 1);
2582                   if (type == 0x04)
2583                     {
2584                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2585                          Change it into:
2586                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2587                          (6 byte form of subl).  */
2588                       BFD_ASSERT (rel->r_offset >= 3);
2589                       BFD_ASSERT (bfd_get_8 (input_bfd,
2590                                              contents + rel->r_offset - 3)
2591                                   == 0x8d);
2592                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2593                       memcpy (contents + rel->r_offset - 3,
2594                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2595                     }
2596                   else
2597                     {
2598                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2599                       if (rel->r_offset + 10 <= input_section->size
2600                           && bfd_get_8 (input_bfd,
2601                                         contents + rel->r_offset + 9) == 0x90)
2602                         {
2603                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2604                              Change it into:
2605                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2606                              (6 byte form of subl).  */
2607                           memcpy (contents + rel->r_offset - 2,
2608                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2609                           roff = rel->r_offset + 6;
2610                         }
2611                       else
2612                         {
2613                           /* leal foo(%reg), %eax; call ___tls_get_addr
2614                              Change it into:
2615                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2616                              (5 byte form of subl).  */
2617                           memcpy (contents + rel->r_offset - 2,
2618                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2619                         }
2620                     }
2621                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2622                               contents + roff);
2623                   /* Skip R_386_PLT32.  */
2624                   rel++;
2625                   continue;
2626                 }
2627               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2628                 {
2629                   unsigned int val, type;
2630
2631                   /* IE->LE transition:
2632                      Originally it can be one of:
2633                      movl foo, %eax
2634                      movl foo, %reg
2635                      addl foo, %reg
2636                      We change it into:
2637                      movl $foo, %eax
2638                      movl $foo, %reg
2639                      addl $foo, %reg.  */
2640                   BFD_ASSERT (rel->r_offset >= 1);
2641                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2642                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2643                   if (val == 0xa1)
2644                     {
2645                       /* movl foo, %eax.  */
2646                       bfd_put_8 (output_bfd, 0xb8,
2647                                  contents + rel->r_offset - 1);
2648                     }
2649                   else
2650                     {
2651                       BFD_ASSERT (rel->r_offset >= 2);
2652                       type = bfd_get_8 (input_bfd,
2653                                         contents + rel->r_offset - 2);
2654                       switch (type)
2655                         {
2656                         case 0x8b:
2657                           /* movl */
2658                           BFD_ASSERT ((val & 0xc7) == 0x05);
2659                           bfd_put_8 (output_bfd, 0xc7,
2660                                      contents + rel->r_offset - 2);
2661                           bfd_put_8 (output_bfd,
2662                                      0xc0 | ((val >> 3) & 7),
2663                                      contents + rel->r_offset - 1);
2664                           break;
2665                         case 0x03:
2666                           /* addl */
2667                           BFD_ASSERT ((val & 0xc7) == 0x05);
2668                           bfd_put_8 (output_bfd, 0x81,
2669                                      contents + rel->r_offset - 2);
2670                           bfd_put_8 (output_bfd,
2671                                      0xc0 | ((val >> 3) & 7),
2672                                      contents + rel->r_offset - 1);
2673                           break;
2674                         default:
2675                           BFD_FAIL ();
2676                           break;
2677                         }
2678                     }
2679                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2680                               contents + rel->r_offset);
2681                   continue;
2682                 }
2683               else
2684                 {
2685                   unsigned int val, type;
2686
2687                   /* {IE_32,GOTIE}->LE transition:
2688                      Originally it can be one of:
2689                      subl foo(%reg1), %reg2
2690                      movl foo(%reg1), %reg2
2691                      addl foo(%reg1), %reg2
2692                      We change it into:
2693                      subl $foo, %reg2
2694                      movl $foo, %reg2 (6 byte form)
2695                      addl $foo, %reg2.  */
2696                   BFD_ASSERT (rel->r_offset >= 2);
2697                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2698                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2699                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2700                   BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2701                   if (type == 0x8b)
2702                     {
2703                       /* movl */
2704                       bfd_put_8 (output_bfd, 0xc7,
2705                                  contents + rel->r_offset - 2);
2706                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2707                                  contents + rel->r_offset - 1);
2708                     }
2709                   else if (type == 0x2b)
2710                     {
2711                       /* subl */
2712                       bfd_put_8 (output_bfd, 0x81,
2713                                  contents + rel->r_offset - 2);
2714                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2715                                  contents + rel->r_offset - 1);
2716                     }
2717                   else if (type == 0x03)
2718                     {
2719                       /* addl */
2720                       bfd_put_8 (output_bfd, 0x81,
2721                                  contents + rel->r_offset - 2);
2722                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2723                                  contents + rel->r_offset - 1);
2724                     }
2725                   else
2726                     BFD_FAIL ();
2727                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2728                     bfd_put_32 (output_bfd, -tpoff (info, relocation),
2729                                 contents + rel->r_offset);
2730                   else
2731                     bfd_put_32 (output_bfd, tpoff (info, relocation),
2732                                 contents + rel->r_offset);
2733                   continue;
2734                 }
2735             }
2736
2737           if (htab->sgot == NULL)
2738             abort ();
2739
2740           if (h != NULL)
2741             off = h->got.offset;
2742           else
2743             {
2744               if (local_got_offsets == NULL)
2745                 abort ();
2746
2747               off = local_got_offsets[r_symndx];
2748             }
2749
2750           if ((off & 1) != 0)
2751             off &= ~1;
2752           else
2753             {
2754               Elf_Internal_Rela outrel;
2755               bfd_byte *loc;
2756               int dr_type, indx;
2757
2758               if (htab->srelgot == NULL)
2759                 abort ();
2760
2761               outrel.r_offset = (htab->sgot->output_section->vma
2762                                  + htab->sgot->output_offset + off);
2763
2764               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2765               if (r_type == R_386_TLS_GD)
2766                 dr_type = R_386_TLS_DTPMOD32;
2767               else if (tls_type == GOT_TLS_IE_POS)
2768                 dr_type = R_386_TLS_TPOFF;
2769               else
2770                 dr_type = R_386_TLS_TPOFF32;
2771               if (dr_type == R_386_TLS_TPOFF && indx == 0)
2772                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2773                             htab->sgot->contents + off);
2774               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2775                 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
2776                             htab->sgot->contents + off);
2777               else
2778                 bfd_put_32 (output_bfd, 0,
2779                             htab->sgot->contents + off);
2780               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2781               loc = htab->srelgot->contents;
2782               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2783               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2784
2785               if (r_type == R_386_TLS_GD)
2786                 {
2787                   if (indx == 0)
2788                     {
2789                       BFD_ASSERT (! unresolved_reloc);
2790                       bfd_put_32 (output_bfd,
2791                                   relocation - dtpoff_base (info),
2792                                   htab->sgot->contents + off + 4);
2793                     }
2794                   else
2795                     {
2796                       bfd_put_32 (output_bfd, 0,
2797                                   htab->sgot->contents + off + 4);
2798                       outrel.r_info = ELF32_R_INFO (indx,
2799                                                     R_386_TLS_DTPOFF32);
2800                       outrel.r_offset += 4;
2801                       htab->srelgot->reloc_count++;
2802                       loc += sizeof (Elf32_External_Rel);
2803                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2804                     }
2805                 }
2806               else if (tls_type == GOT_TLS_IE_BOTH)
2807                 {
2808                   bfd_put_32 (output_bfd,
2809                               indx == 0 ? relocation - dtpoff_base (info) : 0,
2810                               htab->sgot->contents + off + 4);
2811                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2812                   outrel.r_offset += 4;
2813                   htab->srelgot->reloc_count++;
2814                   loc += sizeof (Elf32_External_Rel);
2815                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2816                 }
2817
2818               if (h != NULL)
2819                 h->got.offset |= 1;
2820               else
2821                 local_got_offsets[r_symndx] |= 1;
2822             }
2823
2824           if (off >= (bfd_vma) -2)
2825             abort ();
2826           if (r_type == ELF32_R_TYPE (rel->r_info))
2827             {
2828               bfd_vma g_o_t = htab->sgotplt->output_section->vma
2829                               + htab->sgotplt->output_offset;
2830               relocation = htab->sgot->output_section->vma
2831                            + htab->sgot->output_offset + off - g_o_t;
2832               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2833                   && tls_type == GOT_TLS_IE_BOTH)
2834                 relocation += 4;
2835               if (r_type == R_386_TLS_IE)
2836                 relocation += g_o_t;
2837               unresolved_reloc = FALSE;
2838             }
2839           else
2840             {
2841               unsigned int val, type;
2842               bfd_vma roff;
2843
2844               /* GD->IE transition.  */
2845               BFD_ASSERT (rel->r_offset >= 2);
2846               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2847               BFD_ASSERT (type == 0x8d || type == 0x04);
2848               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2849               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2850                           == 0xe8);
2851               BFD_ASSERT (rel + 1 < relend);
2852               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2853               roff = rel->r_offset - 3;
2854               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2855               if (type == 0x04)
2856                 {
2857                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2858                      Change it into:
2859                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2860                   BFD_ASSERT (rel->r_offset >= 3);
2861                   BFD_ASSERT (bfd_get_8 (input_bfd,
2862                                          contents + rel->r_offset - 3)
2863                               == 0x8d);
2864                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2865                   val >>= 3;
2866                 }
2867               else
2868                 {
2869                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2870                      Change it into:
2871                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2872                   BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
2873                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2874                   BFD_ASSERT (bfd_get_8 (input_bfd,
2875                                          contents + rel->r_offset + 9)
2876                               == 0x90);
2877                   roff = rel->r_offset - 2;
2878                 }
2879               memcpy (contents + roff,
2880                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2881               contents[roff + 7] = 0x80 | (val & 7);
2882               /* If foo is used only with foo@gotntpoff(%reg) and
2883                  foo@indntpoff, but not with foo@gottpoff(%reg), change
2884                  subl $foo@gottpoff(%reg), %eax
2885                  into:
2886                  addl $foo@gotntpoff(%reg), %eax.  */
2887               if (r_type == R_386_TLS_GOTIE)
2888                 {
2889                   contents[roff + 6] = 0x03;
2890                   if (tls_type == GOT_TLS_IE_BOTH)
2891                     off += 4;
2892                 }
2893               bfd_put_32 (output_bfd,
2894                           htab->sgot->output_section->vma
2895                           + htab->sgot->output_offset + off
2896                           - htab->sgotplt->output_section->vma
2897                           - htab->sgotplt->output_offset,
2898                           contents + roff + 8);
2899               /* Skip R_386_PLT32.  */
2900               rel++;
2901               continue;
2902             }
2903           break;
2904
2905         case R_386_TLS_LDM:
2906           if (! info->shared)
2907             {
2908               unsigned int val;
2909
2910               /* LD->LE transition:
2911                  Ensure it is:
2912                  leal foo(%reg), %eax; call ___tls_get_addr.
2913                  We change it into:
2914                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
2915               BFD_ASSERT (rel->r_offset >= 2);
2916               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2917                           == 0x8d);
2918               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2919               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2920               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2921               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2922                           == 0xe8);
2923               BFD_ASSERT (rel + 1 < relend);
2924               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2925               memcpy (contents + rel->r_offset - 2,
2926                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2927               /* Skip R_386_PLT32.  */
2928               rel++;
2929               continue;
2930             }
2931
2932           if (htab->sgot == NULL)
2933             abort ();
2934
2935           off = htab->tls_ldm_got.offset;
2936           if (off & 1)
2937             off &= ~1;
2938           else
2939             {
2940               Elf_Internal_Rela outrel;
2941               bfd_byte *loc;
2942
2943               if (htab->srelgot == NULL)
2944                 abort ();
2945
2946               outrel.r_offset = (htab->sgot->output_section->vma
2947                                  + htab->sgot->output_offset + off);
2948
2949               bfd_put_32 (output_bfd, 0,
2950                           htab->sgot->contents + off);
2951               bfd_put_32 (output_bfd, 0,
2952                           htab->sgot->contents + off + 4);
2953               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2954               loc = htab->srelgot->contents;
2955               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2956               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2957               htab->tls_ldm_got.offset |= 1;
2958             }
2959           relocation = htab->sgot->output_section->vma
2960                        + htab->sgot->output_offset + off
2961                        - htab->sgotplt->output_section->vma
2962                        - htab->sgotplt->output_offset;
2963           unresolved_reloc = FALSE;
2964           break;
2965
2966         case R_386_TLS_LDO_32:
2967           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2968             relocation -= dtpoff_base (info);
2969           else
2970             /* When converting LDO to LE, we must negate.  */
2971             relocation = -tpoff (info, relocation);
2972           break;
2973
2974         case R_386_TLS_LE_32:
2975         case R_386_TLS_LE:
2976           if (info->shared)
2977             {
2978               Elf_Internal_Rela outrel;
2979               asection *sreloc;
2980               bfd_byte *loc;
2981               int indx;
2982
2983               outrel.r_offset = rel->r_offset
2984                                 + input_section->output_section->vma
2985                                 + input_section->output_offset;
2986               if (h != NULL && h->dynindx != -1)
2987                 indx = h->dynindx;
2988               else
2989                 indx = 0;
2990               if (r_type == R_386_TLS_LE_32)
2991                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2992               else
2993                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2994               sreloc = elf_section_data (input_section)->sreloc;
2995               if (sreloc == NULL)
2996                 abort ();
2997               loc = sreloc->contents;
2998               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2999               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3000               if (indx)
3001                 continue;
3002               else if (r_type == R_386_TLS_LE_32)
3003                 relocation = dtpoff_base (info) - relocation;
3004               else
3005                 relocation -= dtpoff_base (info);
3006             }
3007           else if (r_type == R_386_TLS_LE_32)
3008             relocation = tpoff (info, relocation);
3009           else
3010             relocation = -tpoff (info, relocation);
3011           break;
3012
3013         default:
3014           break;
3015         }
3016
3017       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3018          because such sections are not SEC_ALLOC and thus ld.so will
3019          not process them.  */
3020       if (unresolved_reloc
3021           && !((input_section->flags & SEC_DEBUGGING) != 0
3022                && h->def_dynamic))
3023         {
3024           (*_bfd_error_handler)
3025             (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3026              input_bfd,
3027              input_section,
3028              (long) rel->r_offset,
3029              h->root.root.string);
3030           return FALSE;
3031         }
3032
3033       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3034                                     contents, rel->r_offset,
3035                                     relocation, 0);
3036
3037       if (r != bfd_reloc_ok)
3038         {
3039           const char *name;
3040
3041           if (h != NULL)
3042             name = h->root.root.string;
3043           else
3044             {
3045               name = bfd_elf_string_from_elf_section (input_bfd,
3046                                                       symtab_hdr->sh_link,
3047                                                       sym->st_name);
3048               if (name == NULL)
3049                 return FALSE;
3050               if (*name == '\0')
3051                 name = bfd_section_name (input_bfd, sec);
3052             }
3053
3054           if (r == bfd_reloc_overflow)
3055             {
3056               if (! ((*info->callbacks->reloc_overflow)
3057                      (info, (h ? &h->root : NULL), name, howto->name,
3058                       (bfd_vma) 0, input_bfd, input_section,
3059                       rel->r_offset)))
3060                 return FALSE;
3061             }
3062           else
3063             {
3064               (*_bfd_error_handler)
3065                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3066                  input_bfd, input_section,
3067                  (long) rel->r_offset, name, (int) r);
3068               return FALSE;
3069             }
3070         }
3071     }
3072
3073   return TRUE;
3074 }
3075
3076 /* Finish up dynamic symbol handling.  We set the contents of various
3077    dynamic sections here.  */
3078
3079 static bfd_boolean
3080 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3081                                 struct bfd_link_info *info,
3082                                 struct elf_link_hash_entry *h,
3083                                 Elf_Internal_Sym *sym)
3084 {
3085   struct elf_i386_link_hash_table *htab;
3086
3087   htab = elf_i386_hash_table (info);
3088
3089   if (h->plt.offset != (bfd_vma) -1)
3090     {
3091       bfd_vma plt_index;
3092       bfd_vma got_offset;
3093       Elf_Internal_Rela rel;
3094       bfd_byte *loc;
3095
3096       /* This symbol has an entry in the procedure linkage table.  Set
3097          it up.  */
3098
3099       if (h->dynindx == -1
3100           || htab->splt == NULL
3101           || htab->sgotplt == NULL
3102           || htab->srelplt == NULL)
3103         abort ();
3104
3105       /* Get the index in the procedure linkage table which
3106          corresponds to this symbol.  This is the index of this symbol
3107          in all the symbols for which we are making plt entries.  The
3108          first entry in the procedure linkage table is reserved.  */
3109       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3110
3111       /* Get the offset into the .got table of the entry that
3112          corresponds to this function.  Each .got entry is 4 bytes.
3113          The first three are reserved.  */
3114       got_offset = (plt_index + 3) * 4;
3115
3116       /* Fill in the entry in the procedure linkage table.  */
3117       if (! info->shared)
3118         {
3119           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3120                   PLT_ENTRY_SIZE);
3121           bfd_put_32 (output_bfd,
3122                       (htab->sgotplt->output_section->vma
3123                        + htab->sgotplt->output_offset
3124                        + got_offset),
3125                       htab->splt->contents + h->plt.offset + 2);
3126
3127           if (htab->is_vxworks)
3128             {
3129               int s, k, reloc_index;
3130
3131               /* Create the R_386_32 relocation referencing the GOT
3132                  for this PLT entry.  */
3133
3134               /* S: Current slot number (zero-based).  */
3135               s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3136               /* K: Number of relocations for PLTResolve. */
3137               if (info->shared)
3138                 k = PLTRESOLVE_RELOCS_SHLIB;
3139               else
3140                 k = PLTRESOLVE_RELOCS;
3141               /* Skip the PLTresolve relocations, and the relocations for
3142                  the other PLT slots. */
3143               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3144               loc = (htab->srelplt2->contents + reloc_index
3145                      * sizeof (Elf32_External_Rel));
3146
3147               rel.r_offset = (htab->splt->output_section->vma
3148                               + htab->splt->output_offset
3149                               + h->plt.offset + 2),
3150               rel.r_info = ELF32_R_INFO (htab->hgot->indx, R_386_32);
3151               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3152
3153               /* Create the R_386_32 relocation referencing the beginning of
3154                  the PLT for this GOT entry.  */
3155               rel.r_offset = (htab->sgotplt->output_section->vma
3156                               + htab->sgotplt->output_offset
3157                               + got_offset);
3158               rel.r_info = ELF32_R_INFO (htab->hplt->indx, R_386_32);
3159               bfd_elf32_swap_reloc_out (output_bfd, &rel,
3160               loc + sizeof (Elf32_External_Rel));
3161             }
3162
3163         }
3164       else
3165         {
3166           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3167                   PLT_ENTRY_SIZE);
3168           bfd_put_32 (output_bfd, got_offset,
3169                       htab->splt->contents + h->plt.offset + 2);
3170         }
3171
3172       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3173                   htab->splt->contents + h->plt.offset + 7);
3174       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3175                   htab->splt->contents + h->plt.offset + 12);
3176
3177       /* Fill in the entry in the global offset table.  */
3178       bfd_put_32 (output_bfd,
3179                   (htab->splt->output_section->vma
3180                    + htab->splt->output_offset
3181                    + h->plt.offset
3182                    + 6),
3183                   htab->sgotplt->contents + got_offset);
3184
3185       /* Fill in the entry in the .rel.plt section.  */
3186       rel.r_offset = (htab->sgotplt->output_section->vma
3187                       + htab->sgotplt->output_offset
3188                       + got_offset);
3189       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3190       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3191       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3192
3193       if (!h->def_regular)
3194         {
3195           /* Mark the symbol as undefined, rather than as defined in
3196              the .plt section.  Leave the value if there were any
3197              relocations where pointer equality matters (this is a clue
3198              for the dynamic linker, to make function pointer
3199              comparisons work between an application and shared
3200              library), otherwise set it to zero.  If a function is only
3201              called from a binary, there is no need to slow down
3202              shared libraries because of that.  */
3203           sym->st_shndx = SHN_UNDEF;
3204           if (!h->pointer_equality_needed)
3205             sym->st_value = 0;
3206         }
3207     }
3208
3209   if (h->got.offset != (bfd_vma) -1
3210       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
3211       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3212     {
3213       Elf_Internal_Rela rel;
3214       bfd_byte *loc;
3215
3216       /* This symbol has an entry in the global offset table.  Set it
3217          up.  */
3218
3219       if (htab->sgot == NULL || htab->srelgot == NULL)
3220         abort ();
3221
3222       rel.r_offset = (htab->sgot->output_section->vma
3223                       + htab->sgot->output_offset
3224                       + (h->got.offset & ~(bfd_vma) 1));
3225
3226       /* If this is a static link, or it is a -Bsymbolic link and the
3227          symbol is defined locally or was forced to be local because
3228          of a version file, we just want to emit a RELATIVE reloc.
3229          The entry in the global offset table will already have been
3230          initialized in the relocate_section function.  */
3231       if (info->shared
3232           && SYMBOL_REFERENCES_LOCAL (info, h))
3233         {
3234           BFD_ASSERT((h->got.offset & 1) != 0);
3235           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3236         }
3237       else
3238         {
3239           BFD_ASSERT((h->got.offset & 1) == 0);
3240           bfd_put_32 (output_bfd, (bfd_vma) 0,
3241                       htab->sgot->contents + h->got.offset);
3242           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3243         }
3244
3245       loc = htab->srelgot->contents;
3246       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3247       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3248     }
3249
3250   if (h->needs_copy)
3251     {
3252       Elf_Internal_Rela rel;
3253       bfd_byte *loc;
3254
3255       /* This symbol needs a copy reloc.  Set it up.  */
3256
3257       if (h->dynindx == -1
3258           || (h->root.type != bfd_link_hash_defined
3259               && h->root.type != bfd_link_hash_defweak)
3260           || htab->srelbss == NULL)
3261         abort ();
3262
3263       rel.r_offset = (h->root.u.def.value
3264                       + h->root.u.def.section->output_section->vma
3265                       + h->root.u.def.section->output_offset);
3266       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3267       loc = htab->srelbss->contents;
3268       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3269       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3270     }
3271
3272   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3273      On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3274      is relative to the ".got" section.  */
3275   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3276       || (strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3277           && !htab->is_vxworks))
3278     sym->st_shndx = SHN_ABS;
3279
3280   return TRUE;
3281 }
3282
3283 /* Used to decide how to sort relocs in an optimal manner for the
3284    dynamic linker, before writing them out.  */
3285
3286 static enum elf_reloc_type_class
3287 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3288 {
3289   switch (ELF32_R_TYPE (rela->r_info))
3290     {
3291     case R_386_RELATIVE:
3292       return reloc_class_relative;
3293     case R_386_JUMP_SLOT:
3294       return reloc_class_plt;
3295     case R_386_COPY:
3296       return reloc_class_copy;
3297     default:
3298       return reloc_class_normal;
3299     }
3300 }
3301
3302 /* Finish up the dynamic sections.  */
3303
3304 static bfd_boolean
3305 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3306                                   struct bfd_link_info *info)
3307 {
3308   struct elf_i386_link_hash_table *htab;
3309   bfd *dynobj;
3310   asection *sdyn;
3311
3312   htab = elf_i386_hash_table (info);
3313   dynobj = htab->elf.dynobj;
3314   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3315
3316   if (htab->elf.dynamic_sections_created)
3317     {
3318       Elf32_External_Dyn *dyncon, *dynconend;
3319
3320       if (sdyn == NULL || htab->sgot == NULL)
3321         abort ();
3322
3323       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3324       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3325       for (; dyncon < dynconend; dyncon++)
3326         {
3327           Elf_Internal_Dyn dyn;
3328           asection *s;
3329
3330           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3331
3332           switch (dyn.d_tag)
3333             {
3334             default:
3335               continue;
3336
3337             case DT_PLTGOT:
3338               s = htab->sgotplt;
3339               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3340               break;
3341
3342             case DT_JMPREL:
3343               s = htab->srelplt;
3344               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3345               break;
3346
3347             case DT_PLTRELSZ:
3348               s = htab->srelplt;
3349               dyn.d_un.d_val = s->size;
3350               break;
3351
3352             case DT_RELSZ:
3353               /* My reading of the SVR4 ABI indicates that the
3354                  procedure linkage table relocs (DT_JMPREL) should be
3355                  included in the overall relocs (DT_REL).  This is
3356                  what Solaris does.  However, UnixWare can not handle
3357                  that case.  Therefore, we override the DT_RELSZ entry
3358                  here to make it not include the JMPREL relocs.  */
3359               s = htab->srelplt;
3360               if (s == NULL)
3361                 continue;
3362               dyn.d_un.d_val -= s->size;
3363               break;
3364
3365             case DT_REL:
3366               /* We may not be using the standard ELF linker script.
3367                  If .rel.plt is the first .rel section, we adjust
3368                  DT_REL to not include it.  */
3369               s = htab->srelplt;
3370               if (s == NULL)
3371                 continue;
3372               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3373                 continue;
3374               dyn.d_un.d_ptr += s->size;
3375               break;
3376             }
3377
3378           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3379         }
3380
3381       /* Fill in the first entry in the procedure linkage table.  */
3382       if (htab->splt && htab->splt->size > 0)
3383         {
3384           if (info->shared)
3385             {
3386               memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3387                       sizeof (elf_i386_pic_plt0_entry));
3388               memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3389                       htab->plt0_pad_byte,
3390                       PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3391             }
3392           else
3393             {
3394               memcpy (htab->splt->contents, elf_i386_plt0_entry,
3395                       sizeof(elf_i386_plt0_entry));
3396               memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3397                       htab->plt0_pad_byte,
3398                       PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
3399               bfd_put_32 (output_bfd,
3400                           (htab->sgotplt->output_section->vma
3401                            + htab->sgotplt->output_offset
3402                            + 4),
3403                           htab->splt->contents + 2);
3404               bfd_put_32 (output_bfd,
3405                           (htab->sgotplt->output_section->vma
3406                            + htab->sgotplt->output_offset
3407                            + 8),
3408                           htab->splt->contents + 8);
3409
3410               if (htab->is_vxworks)
3411                 {
3412                   Elf_Internal_Rela rel;
3413                   struct elf_link_hash_entry *hgot;
3414
3415                   /* The VxWorks GOT is relocated by the dynamic linker.
3416                      Therefore, we must emit relocations rather than
3417                      simply computing the values now.  */
3418                   hgot = elf_link_hash_lookup (elf_hash_table (info),
3419                                                "_GLOBAL_OFFSET_TABLE_",
3420                                                FALSE, FALSE, FALSE);
3421                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3422                      On IA32 we use REL relocations so the addend goes in
3423                      the PLT directly.  */
3424                   rel.r_offset = (htab->splt->output_section->vma
3425                                   + htab->splt->output_offset
3426                                   + 2);
3427                   rel.r_info = ELF32_R_INFO (hgot->indx, R_386_32);
3428                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3429                                             htab->srelplt2->contents);
3430                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
3431                   rel.r_offset = (htab->splt->output_section->vma
3432                                   + htab->splt->output_offset
3433                                   + 8);
3434                   rel.r_info = ELF32_R_INFO (hgot->indx, R_386_32);
3435                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3436                                             htab->srelplt2->contents +
3437                                             sizeof (Elf32_External_Rel));
3438                 }
3439             }
3440
3441           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3442              really seem like the right value.  */
3443           elf_section_data (htab->splt->output_section)
3444             ->this_hdr.sh_entsize = 4;
3445
3446           /* Correct the .rel.plt.unloaded relocations.  */
3447           if (htab->is_vxworks && !info->shared)
3448             {
3449               int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
3450               unsigned char *p;
3451
3452               p = htab->srelplt2->contents;
3453               if (info->shared)
3454                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
3455               else
3456                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
3457
3458               for (; num_plts; num_plts--)
3459                 {
3460                   Elf_Internal_Rela rel;
3461                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3462                   rel.r_info = ELF32_R_INFO (htab->hgot->indx, R_386_32);
3463                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3464                   p += sizeof (Elf32_External_Rel);
3465
3466                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3467                   rel.r_info = ELF32_R_INFO (htab->hplt->indx, R_386_32);
3468                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3469                   p += sizeof (Elf32_External_Rel);
3470                 }
3471             }
3472         }
3473     }
3474
3475   if (htab->sgotplt)
3476     {
3477       /* Fill in the first three entries in the global offset table.  */
3478       if (htab->sgotplt->size > 0)
3479         {
3480           bfd_put_32 (output_bfd,
3481                       (sdyn == NULL ? 0
3482                        : sdyn->output_section->vma + sdyn->output_offset),
3483                       htab->sgotplt->contents);
3484           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3485           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3486         }
3487
3488       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3489     }
3490
3491   if (htab->sgot && htab->sgot->size > 0)
3492     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3493
3494   return TRUE;
3495 }
3496
3497 /* Return address for Ith PLT stub in section PLT, for relocation REL
3498    or (bfd_vma) -1 if it should not be included.  */
3499
3500 static bfd_vma
3501 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
3502                       const arelent *rel ATTRIBUTE_UNUSED)
3503 {
3504   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3505 }
3506
3507
3508 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3509 #define TARGET_LITTLE_NAME              "elf32-i386"
3510 #define ELF_ARCH                        bfd_arch_i386
3511 #define ELF_MACHINE_CODE                EM_386
3512 #define ELF_MAXPAGESIZE                 0x1000
3513
3514 #define elf_backend_can_gc_sections     1
3515 #define elf_backend_can_refcount        1
3516 #define elf_backend_want_got_plt        1
3517 #define elf_backend_plt_readonly        1
3518 #define elf_backend_want_plt_sym        0
3519 #define elf_backend_got_header_size     12
3520
3521 /* Support RELA for objdump of prelink objects.  */
3522 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3523 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3524
3525 #define bfd_elf32_mkobject                    elf_i386_mkobject
3526
3527 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3528 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3529 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3530
3531 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3532 #define elf_backend_check_relocs              elf_i386_check_relocs
3533 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3534 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3535 #define elf_backend_fake_sections             elf_i386_fake_sections
3536 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3537 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3538 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3539 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3540 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3541 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3542 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3543 #define elf_backend_relocate_section          elf_i386_relocate_section
3544 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3545 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
3546
3547 #include "elf32-target.h"
3548
3549 /* FreeBSD support.  */
3550
3551 #undef  TARGET_LITTLE_SYM
3552 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3553 #undef  TARGET_LITTLE_NAME
3554 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3555
3556 /* The kernel recognizes executables as valid only if they carry a
3557    "FreeBSD" label in the ELF header.  So we put this label on all
3558    executables and (for simplicity) also all other object files.  */
3559
3560 static void
3561 elf_i386_post_process_headers (bfd *abfd,
3562                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3563 {
3564   Elf_Internal_Ehdr *i_ehdrp;
3565
3566   i_ehdrp = elf_elfheader (abfd);
3567
3568   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3569   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3570 #ifdef OLD_FREEBSD_ABI_LABEL
3571   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3572   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3573 #endif
3574 }
3575
3576 #undef  elf_backend_post_process_headers
3577 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3578 #undef  elf32_bed
3579 #define elf32_bed                               elf32_i386_fbsd_bed
3580
3581 #include "elf32-target.h"
3582
3583 /* VxWorks support.  */
3584
3585 #undef  TARGET_LITTLE_SYM
3586 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
3587 #undef  TARGET_LITTLE_NAME
3588 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
3589
3590
3591 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks.  */
3592
3593 static struct bfd_link_hash_table *
3594 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3595 {
3596   struct bfd_link_hash_table *ret;
3597   struct elf_i386_link_hash_table *htab;
3598
3599   ret = elf_i386_link_hash_table_create (abfd);
3600   if (ret)
3601     {
3602       htab = (struct elf_i386_link_hash_table *) ret;
3603       htab->is_vxworks = 1;
3604       htab->plt0_pad_byte = 0x90;
3605     }
3606
3607   return ret;
3608 }
3609
3610
3611 /* Tweak magic VxWorks symbols as they are written to the output file.  */
3612 static bfd_boolean
3613 elf_i386_vxworks_link_output_symbol_hook (struct bfd_link_info *info
3614                                             ATTRIBUTE_UNUSED,
3615                                           const char *name,
3616                                           Elf_Internal_Sym *sym,
3617                                           asection *input_sec ATTRIBUTE_UNUSED,
3618                                           struct elf_link_hash_entry *h
3619                                             ATTRIBUTE_UNUSED)
3620 {
3621   /* Ignore the first dummy symbol.  */
3622   if (!name)
3623     return TRUE;
3624
3625   return elf_vxworks_link_output_symbol_hook (name, sym);
3626 }
3627
3628 #undef  elf_backend_post_process_headers
3629 #undef bfd_elf32_bfd_link_hash_table_create
3630 #define bfd_elf32_bfd_link_hash_table_create \
3631   elf_i386_vxworks_link_hash_table_create
3632 #undef elf_backend_add_symbol_hook
3633 #define elf_backend_add_symbol_hook \
3634   elf_vxworks_add_symbol_hook
3635 #undef elf_backend_link_output_symbol_hook
3636 #define elf_backend_link_output_symbol_hook \
3637   elf_i386_vxworks_link_output_symbol_hook
3638 #undef elf_backend_emit_relocs
3639 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
3640 #undef elf_backend_final_write_processing
3641 #define elf_backend_final_write_processing \
3642   elf_vxworks_final_write_processing
3643
3644 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3645    define it.  */
3646 #undef elf_backend_want_plt_sym
3647 #define elf_backend_want_plt_sym        1
3648
3649 #undef  elf32_bed
3650 #define elf32_bed                               elf32_i386_vxworks_bed
3651
3652 #include "elf32-target.h"