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 (struct bfd_link_info *info,
 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           /* Add reloc counts against the indirect sym to the direct sym
 792              list.  Merge any entries against the same section.  */
 793           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 794             {
 795               struct elf_i386_dyn_relocs *q;
 796
 797               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 798                 if (q->sec == p->sec)
 799                   {
 800                     q->pc_count += p->pc_count;
 801                     q->count += p->count;
 802                     *pp = p->next;
 803                     break;
 804                   }
 805               if (q == NULL)
 806                 pp = &p->next;
 807             }
 808           *pp = edir->dyn_relocs;
 809         }
 810
 811       edir->dyn_relocs = eind->dyn_relocs;
 812       eind->dyn_relocs = NULL;
 813     }
 814
 815   if (ind->root.type == bfd_link_hash_indirect
 816       && dir->got.refcount <= 0)
 817     {
 818       edir->tls_type = eind->tls_type;
 819       eind->tls_type = GOT_UNKNOWN;
 820     }
 821
 822   if (ELIMINATE_COPY_RELOCS
 823       && ind->root.type != bfd_link_hash_indirect
 824       && dir->dynamic_adjusted)
 825     {
 826       /* If called to transfer flags for a weakdef during processing
 827          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 828          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 829       dir->ref_dynamic |= ind->ref_dynamic;
 830       dir->ref_regular |= ind->ref_regular;
 831       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 832       dir->needs_plt |= ind->needs_plt;
 833       dir->pointer_equality_needed |= ind->pointer_equality_needed;
 834     }
 835   else
 836     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 837 }
 838
 839 static int
 840 elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
 841 {
 842   if (info->shared)
 843     return r_type;
 844
 845   switch (r_type)
 846     {
 847     case R_386_TLS_GD:
 848     case R_386_TLS_IE_32:
 849       if (is_local)
 850         return R_386_TLS_LE_32;
 851       return R_386_TLS_IE_32;
 852     case R_386_TLS_IE:
 853     case R_386_TLS_GOTIE:
 854       if (is_local)
 855         return R_386_TLS_LE_32;
 856       return r_type;
 857     case R_386_TLS_LDM:
 858       return R_386_TLS_LE_32;
 859     }
 860
 861   return r_type;
 862 }
 863
 864 /* Look through the relocs for a section during the first phase, and
 865    calculate needed space in the global offset table, procedure linkage
 866    table, and dynamic reloc sections.  */
 867
 868 static bfd_boolean
 869 elf_i386_check_relocs (bfd *abfd,
 870                        struct bfd_link_info *info,
 871                        asection *sec,
 872                        const Elf_Internal_Rela *relocs)
 873 {
 874   struct elf_i386_link_hash_table *htab;
 875   Elf_Internal_Shdr *symtab_hdr;
 876   struct elf_link_hash_entry **sym_hashes;
 877   const Elf_Internal_Rela *rel;
 878   const Elf_Internal_Rela *rel_end;
 879   asection *sreloc;
 880
 881   if (info->relocatable)
 882     return TRUE;
 883
 884   htab = elf_i386_hash_table (info);
 885   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 886   sym_hashes = elf_sym_hashes (abfd);
 887
 888   sreloc = NULL;
 889
 890   rel_end = relocs + sec->reloc_count;
 891   for (rel = relocs; rel < rel_end; rel++)
 892     {
 893       unsigned int r_type;
 894       unsigned long r_symndx;
 895       struct elf_link_hash_entry *h;
 896
 897       r_symndx = ELF32_R_SYM (rel->r_info);
 898       r_type = ELF32_R_TYPE (rel->r_info);
 899
 900       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 901         {
 902           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
 903                                  abfd,
 904                                  r_symndx);
 905           return FALSE;
 906         }
 907
 908       if (r_symndx < symtab_hdr->sh_info)
 909         h = NULL;
 910       else
 911         {
 912           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 913           while (h->root.type == bfd_link_hash_indirect
 914                  || h->root.type == bfd_link_hash_warning)
 915             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 916         }
 917
 918       r_type = elf_i386_tls_transition (info, r_type, h == NULL);
 919
 920       switch (r_type)
 921         {
 922         case R_386_TLS_LDM:
 923           htab->tls_ldm_got.refcount += 1;
 924           goto create_got;
 925
 926         case R_386_PLT32:
 927           /* This symbol requires a procedure linkage table entry.  We
 928              actually build the entry in adjust_dynamic_symbol,
 929              because this might be a case of linking PIC code which is
 930              never referenced by a dynamic object, in which case we
 931              don't need to generate a procedure linkage table entry
 932              after all.  */
 933
 934           /* If this is a local symbol, we resolve it directly without
 935              creating a procedure linkage table entry.  */
 936           if (h == NULL)
 937             continue;
 938
 939           h->needs_plt = 1;
 940           h->plt.refcount += 1;
 941           break;
 942
 943         case R_386_TLS_IE_32:
 944         case R_386_TLS_IE:
 945         case R_386_TLS_GOTIE:
 946           if (info->shared)
 947             info->flags |= DF_STATIC_TLS;
 948           /* Fall through */
 949
 950         case R_386_GOT32:
 951         case R_386_TLS_GD:
 952           /* This symbol requires a global offset table entry.  */
 953           {
 954             int tls_type, old_tls_type;
 955
 956             switch (r_type)
 957               {
 958               default:
 959               case R_386_GOT32: tls_type = GOT_NORMAL; break;
 960               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
 961               case R_386_TLS_IE_32:
 962                 if (ELF32_R_TYPE (rel->r_info) == r_type)
 963                   tls_type = GOT_TLS_IE_NEG;
 964                 else
 965                   /* If this is a GD->IE transition, we may use either of
 966                      R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  */
 967                   tls_type = GOT_TLS_IE;
 968                 break;
 969               case R_386_TLS_IE:
 970               case R_386_TLS_GOTIE:
 971                 tls_type = GOT_TLS_IE_POS; break;
 972               }
 973
 974             if (h != NULL)
 975               {
 976                 h->got.refcount += 1;
 977                 old_tls_type = elf_i386_hash_entry(h)->tls_type;
 978               }
 979             else
 980               {
 981                 bfd_signed_vma *local_got_refcounts;
 982
 983                 /* This is a global offset table entry for a local symbol.  */
 984                 local_got_refcounts = elf_local_got_refcounts (abfd);
 985                 if (local_got_refcounts == NULL)
 986                   {
 987                     bfd_size_type size;
 988
 989                     size = symtab_hdr->sh_info;
 990                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
 991                     local_got_refcounts = bfd_zalloc (abfd, size);
 992                     if (local_got_refcounts == NULL)
 993                       return FALSE;
 994                     elf_local_got_refcounts (abfd) = local_got_refcounts;
 995                     elf_i386_local_got_tls_type (abfd)
 996                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
 997                   }
 998                 local_got_refcounts[r_symndx] += 1;
 999                 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1000               }
1001
1002             if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1003               tls_type |= old_tls_type;
1004             /* If a TLS symbol is accessed using IE at least once,
1005                there is no point to use dynamic model for it.  */
1006             else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1007                      && (old_tls_type != GOT_TLS_GD
1008                          || (tls_type & GOT_TLS_IE) == 0))
1009               {
1010                 if ((old_tls_type & GOT_TLS_IE) && tls_type == GOT_TLS_GD)
1011                   tls_type = old_tls_type;
1012                 else
1013                   {
1014                     (*_bfd_error_handler)
1015                       (_("%B: `%s' accessed both as normal and "
1016                          "thread local symbol"),
1017                        abfd,
1018                        h ? h->root.root.string : "<local>");
1019                     return FALSE;
1020                   }
1021               }
1022
1023             if (old_tls_type != tls_type)
1024               {
1025                 if (h != NULL)
1026                   elf_i386_hash_entry (h)->tls_type = tls_type;
1027                 else
1028                   elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1029               }
1030           }
1031           /* Fall through */
1032
1033         case R_386_GOTOFF:
1034         case R_386_GOTPC:
1035         create_got:
1036           if (htab->sgot == NULL)
1037             {
1038               if (htab->elf.dynobj == NULL)
1039                 htab->elf.dynobj = abfd;
1040               if (!create_got_section (htab->elf.dynobj, info))
1041                 return FALSE;
1042             }
1043           if (r_type != R_386_TLS_IE)
1044             break;
1045           /* Fall through */
1046
1047         case R_386_TLS_LE_32:
1048         case R_386_TLS_LE:
1049           if (!info->shared)
1050             break;
1051           info->flags |= DF_STATIC_TLS;
1052           /* Fall through */
1053
1054         case R_386_32:
1055         case R_386_PC32:
1056           if (h != NULL && !info->shared)
1057             {
1058               /* If this reloc is in a read-only section, we might
1059                  need a copy reloc.  We can't check reliably at this
1060                  stage whether the section is read-only, as input
1061                  sections have not yet been mapped to output sections.
1062                  Tentatively set the flag for now, and correct in
1063                  adjust_dynamic_symbol.  */
1064               h->non_got_ref = 1;
1065
1066               /* We may need a .plt entry if the function this reloc
1067                  refers to is in a shared lib.  */
1068               h->plt.refcount += 1;
1069               if (r_type != R_386_PC32)
1070                 h->pointer_equality_needed = 1;
1071             }
1072
1073           /* If we are creating a shared library, and this is a reloc
1074              against a global symbol, or a non PC relative reloc
1075              against a local symbol, then we need to copy the reloc
1076              into the shared library.  However, if we are linking with
1077              -Bsymbolic, we do not need to copy a reloc against a
1078              global symbol which is defined in an object we are
1079              including in the link (i.e., DEF_REGULAR is set).  At
1080              this point we have not seen all the input files, so it is
1081              possible that DEF_REGULAR is not set now but will be set
1082              later (it is never cleared).  In case of a weak definition,
1083              DEF_REGULAR may be cleared later by a strong definition in
1084              a shared library.  We account for that possibility below by
1085              storing information in the relocs_copied field of the hash
1086              table entry.  A similar situation occurs when creating
1087              shared libraries and symbol visibility changes render the
1088              symbol local.
1089
1090              If on the other hand, we are creating an executable, we
1091              may need to keep relocations for symbols satisfied by a
1092              dynamic library if we manage to avoid copy relocs for the
1093              symbol.  */
1094           if ((info->shared
1095                && (sec->flags & SEC_ALLOC) != 0
1096                && (r_type != R_386_PC32
1097                    || (h != NULL
1098                        && (! info->symbolic
1099                            || h->root.type == bfd_link_hash_defweak
1100                            || !h->def_regular))))
1101               || (ELIMINATE_COPY_RELOCS
1102                   && !info->shared
1103                   && (sec->flags & SEC_ALLOC) != 0
1104                   && h != NULL
1105                   && (h->root.type == bfd_link_hash_defweak
1106                       || !h->def_regular)))
1107             {
1108               struct elf_i386_dyn_relocs *p;
1109               struct elf_i386_dyn_relocs **head;
1110
1111               /* We must copy these reloc types into the output file.
1112                  Create a reloc section in dynobj and make room for
1113                  this reloc.  */
1114               if (sreloc == NULL)
1115                 {
1116                   const char *name;
1117                   bfd *dynobj;
1118                   unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1119                   unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1120
1121                   name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1122                   if (name == NULL)
1123                     return FALSE;
1124
1125                   if (strncmp (name, ".rel", 4) != 0
1126                       || strcmp (bfd_get_section_name (abfd, sec),
1127                                  name + 4) != 0)
1128                     {
1129                       (*_bfd_error_handler)
1130                         (_("%B: bad relocation section name `%s\'"),
1131                          abfd, name);
1132                     }
1133
1134                   if (htab->elf.dynobj == NULL)
1135                     htab->elf.dynobj = abfd;
1136
1137                   dynobj = htab->elf.dynobj;
1138                   sreloc = bfd_get_section_by_name (dynobj, name);
1139                   if (sreloc == NULL)
1140                     {
1141                       flagword flags;
1142
1143                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1144                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1145                       if ((sec->flags & SEC_ALLOC) != 0)
1146                         flags |= SEC_ALLOC | SEC_LOAD;
1147                       sreloc = bfd_make_section_with_flags (dynobj,
1148                                                             name,
1149                                                             flags);
1150                       if (sreloc == NULL
1151                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1152                         return FALSE;
1153                     }
1154                   elf_section_data (sec)->sreloc = sreloc;
1155                 }
1156
1157               /* If this is a global symbol, we count the number of
1158                  relocations we need for this symbol.  */
1159               if (h != NULL)
1160                 {
1161                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1162                 }
1163               else
1164                 {
1165                   void **vpp;
1166                   /* Track dynamic relocs needed for local syms too.
1167                      We really need local syms available to do this
1168                      easily.  Oh well.  */
1169
1170                   asection *s;
1171                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1172                                                  sec, r_symndx);
1173                   if (s == NULL)
1174                     return FALSE;
1175
1176                   vpp = &elf_section_data (s)->local_dynrel;
1177                   head = (struct elf_i386_dyn_relocs **)vpp;
1178                 }
1179
1180               p = *head;
1181               if (p == NULL || p->sec != sec)
1182                 {
1183                   bfd_size_type amt = sizeof *p;
1184                   p = bfd_alloc (htab->elf.dynobj, amt);
1185                   if (p == NULL)
1186                     return FALSE;
1187                   p->next = *head;
1188                   *head = p;
1189                   p->sec = sec;
1190                   p->count = 0;
1191                   p->pc_count = 0;
1192                 }
1193
1194               p->count += 1;
1195               if (r_type == R_386_PC32)
1196                 p->pc_count += 1;
1197             }
1198           break;
1199
1200           /* This relocation describes the C++ object vtable hierarchy.
1201              Reconstruct it for later use during GC.  */
1202         case R_386_GNU_VTINHERIT:
1203           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1204             return FALSE;
1205           break;
1206
1207           /* This relocation describes which C++ vtable entries are actually
1208              used.  Record for later use during GC.  */
1209         case R_386_GNU_VTENTRY:
1210           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1211             return FALSE;
1212           break;
1213
1214         default:
1215           break;
1216         }
1217     }
1218
1219   return TRUE;
1220 }
1221
1222 /* Return the section that should be marked against GC for a given
1223    relocation.  */
1224
1225 static asection *
1226 elf_i386_gc_mark_hook (asection *sec,
1227                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
1228                        Elf_Internal_Rela *rel,
1229                        struct elf_link_hash_entry *h,
1230                        Elf_Internal_Sym *sym)
1231 {
1232   if (h != NULL)
1233     {
1234       switch (ELF32_R_TYPE (rel->r_info))
1235         {
1236         case R_386_GNU_VTINHERIT:
1237         case R_386_GNU_VTENTRY:
1238           break;
1239
1240         default:
1241           switch (h->root.type)
1242             {
1243             case bfd_link_hash_defined:
1244             case bfd_link_hash_defweak:
1245               return h->root.u.def.section;
1246
1247             case bfd_link_hash_common:
1248               return h->root.u.c.p->section;
1249
1250             default:
1251               break;
1252             }
1253         }
1254     }
1255   else
1256     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1257
1258   return NULL;
1259 }
1260
1261 /* Update the got entry reference counts for the section being removed.  */
1262
1263 static bfd_boolean
1264 elf_i386_gc_sweep_hook (bfd *abfd,
1265                         struct bfd_link_info *info,
1266                         asection *sec,
1267                         const Elf_Internal_Rela *relocs)
1268 {
1269   Elf_Internal_Shdr *symtab_hdr;
1270   struct elf_link_hash_entry **sym_hashes;
1271   bfd_signed_vma *local_got_refcounts;
1272   const Elf_Internal_Rela *rel, *relend;
1273
1274   elf_section_data (sec)->local_dynrel = NULL;
1275
1276   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1277   sym_hashes = elf_sym_hashes (abfd);
1278   local_got_refcounts = elf_local_got_refcounts (abfd);
1279
1280   relend = relocs + sec->reloc_count;
1281   for (rel = relocs; rel < relend; rel++)
1282     {
1283       unsigned long r_symndx;
1284       unsigned int r_type;
1285       struct elf_link_hash_entry *h = NULL;
1286
1287       r_symndx = ELF32_R_SYM (rel->r_info);
1288       if (r_symndx >= symtab_hdr->sh_info)
1289         {
1290           struct elf_i386_link_hash_entry *eh;
1291           struct elf_i386_dyn_relocs **pp;
1292           struct elf_i386_dyn_relocs *p;
1293
1294           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1295           while (h->root.type == bfd_link_hash_indirect
1296                  || h->root.type == bfd_link_hash_warning)
1297             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1298           eh = (struct elf_i386_link_hash_entry *) h;
1299
1300           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1301             if (p->sec == sec)
1302               {
1303                 /* Everything must go for SEC.  */
1304                 *pp = p->next;
1305                 break;
1306               }
1307         }
1308
1309       r_type = ELF32_R_TYPE (rel->r_info);
1310       r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1311       switch (r_type)
1312         {
1313         case R_386_TLS_LDM:
1314           if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1315             elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1316           break;
1317
1318         case R_386_TLS_GD:
1319         case R_386_TLS_IE_32:
1320         case R_386_TLS_IE:
1321         case R_386_TLS_GOTIE:
1322         case R_386_GOT32:
1323           if (h != NULL)
1324             {
1325               if (h->got.refcount > 0)
1326                 h->got.refcount -= 1;
1327             }
1328           else if (local_got_refcounts != NULL)
1329             {
1330               if (local_got_refcounts[r_symndx] > 0)
1331                 local_got_refcounts[r_symndx] -= 1;
1332             }
1333           break;
1334
1335         case R_386_32:
1336         case R_386_PC32:
1337           if (info->shared)
1338             break;
1339           /* Fall through */
1340
1341         case R_386_PLT32:
1342           if (h != NULL)
1343             {
1344               if (h->plt.refcount > 0)
1345                 h->plt.refcount -= 1;
1346             }
1347           break;
1348
1349         default:
1350           break;
1351         }
1352     }
1353
1354   return TRUE;
1355 }
1356
1357 /* Adjust a symbol defined by a dynamic object and referenced by a
1358    regular object.  The current definition is in some section of the
1359    dynamic object, but we're not including those sections.  We have to
1360    change the definition to something the rest of the link can
1361    understand.  */
1362
1363 static bfd_boolean
1364 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1365                                 struct elf_link_hash_entry *h)
1366 {
1367   struct elf_i386_link_hash_table *htab;
1368   asection *s;
1369   unsigned int power_of_two;
1370
1371   /* If this is a function, put it in the procedure linkage table.  We
1372      will fill in the contents of the procedure linkage table later,
1373      when we know the address of the .got section.  */
1374   if (h->type == STT_FUNC
1375       || h->needs_plt)
1376     {
1377       if (h->plt.refcount <= 0
1378           || SYMBOL_CALLS_LOCAL (info, h)
1379           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1380               && h->root.type == bfd_link_hash_undefweak))
1381         {
1382           /* This case can occur if we saw a PLT32 reloc in an input
1383              file, but the symbol was never referred to by a dynamic
1384              object, or if all references were garbage collected.  In
1385              such a case, we don't actually need to build a procedure
1386              linkage table, and we can just do a PC32 reloc instead.  */
1387           h->plt.offset = (bfd_vma) -1;
1388           h->needs_plt = 0;
1389         }
1390
1391       return TRUE;
1392     }
1393   else
1394     /* It's possible that we incorrectly decided a .plt reloc was
1395        needed for an R_386_PC32 reloc to a non-function sym in
1396        check_relocs.  We can't decide accurately between function and
1397        non-function syms in check-relocs;  Objects loaded later in
1398        the link may change h->type.  So fix it now.  */
1399     h->plt.offset = (bfd_vma) -1;
1400
1401   /* If this is a weak symbol, and there is a real definition, the
1402      processor independent code will have arranged for us to see the
1403      real definition first, and we can just use the same value.  */
1404   if (h->u.weakdef != NULL)
1405     {
1406       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1407                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1408       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1409       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1410       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1411         h->non_got_ref = h->u.weakdef->non_got_ref;
1412       return TRUE;
1413     }
1414
1415   /* This is a reference to a symbol defined by a dynamic object which
1416      is not a function.  */
1417
1418   /* If we are creating a shared library, we must presume that the
1419      only references to the symbol are via the global offset table.
1420      For such cases we need not do anything here; the relocations will
1421      be handled correctly by relocate_section.  */
1422   if (info->shared)
1423     return TRUE;
1424
1425   /* If there are no references to this symbol that do not use the
1426      GOT, we don't need to generate a copy reloc.  */
1427   if (!h->non_got_ref)
1428     return TRUE;
1429
1430   /* If -z nocopyreloc was given, we won't generate them either.  */
1431   if (info->nocopyreloc)
1432     {
1433       h->non_got_ref = 0;
1434       return TRUE;
1435     }
1436
1437   htab = elf_i386_hash_table (info);
1438
1439   /* If there aren't any dynamic relocs in read-only sections, then
1440      we can keep the dynamic relocs and avoid the copy reloc.  This
1441      doesn't work on VxWorks, where we can not have dynamic relocations
1442      (other than copy and jump slot relocations) in an executable.  */
1443   if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
1444     {
1445       struct elf_i386_link_hash_entry * eh;
1446       struct elf_i386_dyn_relocs *p;
1447
1448       eh = (struct elf_i386_link_hash_entry *) h;
1449       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1450         {
1451           s = p->sec->output_section;
1452           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1453             break;
1454         }
1455
1456       if (p == NULL)
1457         {
1458           h->non_got_ref = 0;
1459           return TRUE;
1460         }
1461     }
1462
1463   if (h->size == 0)
1464     {
1465       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1466                              h->root.root.string);
1467       return TRUE;
1468     }
1469
1470   /* We must allocate the symbol in our .dynbss section, which will
1471      become part of the .bss section of the executable.  There will be
1472      an entry for this symbol in the .dynsym section.  The dynamic
1473      object will contain position independent code, so all references
1474      from the dynamic object to this symbol will go through the global
1475      offset table.  The dynamic linker will use the .dynsym entry to
1476      determine the address it must put in the global offset table, so
1477      both the dynamic object and the regular object will refer to the
1478      same memory location for the variable.  */
1479
1480   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1481      copy the initial value out of the dynamic object and into the
1482      runtime process image.  */
1483   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1484     {
1485       htab->srelbss->size += sizeof (Elf32_External_Rel);
1486       h->needs_copy = 1;
1487     }
1488
1489   /* We need to figure out the alignment required for this symbol.  I
1490      have no idea how ELF linkers handle this.  */
1491   power_of_two = bfd_log2 (h->size);
1492   if (power_of_two > 3)
1493     power_of_two = 3;
1494
1495   /* Apply the required alignment.  */
1496   s = htab->sdynbss;
1497   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1498   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1499     {
1500       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1501         return FALSE;
1502     }
1503
1504   /* Define the symbol as being at this point in the section.  */
1505   h->root.u.def.section = s;
1506   h->root.u.def.value = s->size;
1507
1508   /* Increment the section size to make room for the symbol.  */
1509   s->size += h->size;
1510
1511   return TRUE;
1512 }
1513
1514 /* Allocate space in .plt, .got and associated reloc sections for
1515    dynamic relocs.  */
1516
1517 static bfd_boolean
1518 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1519 {
1520   struct bfd_link_info *info;
1521   struct elf_i386_link_hash_table *htab;
1522   struct elf_i386_link_hash_entry *eh;
1523   struct elf_i386_dyn_relocs *p;
1524
1525   if (h->root.type == bfd_link_hash_indirect)
1526     return TRUE;
1527
1528   if (h->root.type == bfd_link_hash_warning)
1529     /* When warning symbols are created, they **replace** the "real"
1530        entry in the hash table, thus we never get to see the real
1531        symbol in a hash traversal.  So look at it now.  */
1532     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1533
1534   info = (struct bfd_link_info *) inf;
1535   htab = elf_i386_hash_table (info);
1536
1537   if (htab->elf.dynamic_sections_created
1538       && h->plt.refcount > 0)
1539     {
1540       /* Make sure this symbol is output as a dynamic symbol.
1541          Undefined weak syms won't yet be marked as dynamic.  */
1542       if (h->dynindx == -1
1543           && !h->forced_local)
1544         {
1545           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1546             return FALSE;
1547         }
1548
1549       if (info->shared
1550           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1551         {
1552           asection *s = htab->splt;
1553
1554           /* If this is the first .plt entry, make room for the special
1555              first entry.  */
1556           if (s->size == 0)
1557             s->size += PLT_ENTRY_SIZE;
1558
1559           h->plt.offset = s->size;
1560
1561           /* If this symbol is not defined in a regular file, and we are
1562              not generating a shared library, then set the symbol to this
1563              location in the .plt.  This is required to make function
1564              pointers compare as equal between the normal executable and
1565              the shared library.  */
1566           if (! info->shared
1567               && !h->def_regular)
1568             {
1569               h->root.u.def.section = s;
1570               h->root.u.def.value = h->plt.offset;
1571             }
1572
1573           /* Make room for this entry.  */
1574           s->size += PLT_ENTRY_SIZE;
1575
1576           /* We also need to make an entry in the .got.plt section, which
1577              will be placed in the .got section by the linker script.  */
1578           htab->sgotplt->size += 4;
1579
1580           /* We also need to make an entry in the .rel.plt section.  */
1581           htab->srelplt->size += sizeof (Elf32_External_Rel);
1582
1583           if (htab->is_vxworks && !info->shared)
1584             {
1585               /* VxWorks has a second set of relocations for each PLT entry
1586                  in executables.  They go in a separate relocation section,
1587                  which is processed by the kernel loader.  */
1588
1589               /* There are two relocations for the initial PLT entry: an
1590                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1591                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
1592
1593               if (h->plt.offset == PLT_ENTRY_SIZE)
1594                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1595
1596               /* There are two extra relocations for each subsequent PLT entry:
1597                  an R_386_32 relocation for the GOT entry, and an R_386_32
1598                  relocation for the PLT entry.  */
1599
1600               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1601             }
1602         }
1603       else
1604         {
1605           h->plt.offset = (bfd_vma) -1;
1606           h->needs_plt = 0;
1607         }
1608     }
1609   else
1610     {
1611       h->plt.offset = (bfd_vma) -1;
1612       h->needs_plt = 0;
1613     }
1614
1615   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1616      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
1617   if (h->got.refcount > 0
1618       && !info->shared
1619       && h->dynindx == -1
1620       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1621     h->got.offset = (bfd_vma) -1;
1622   else if (h->got.refcount > 0)
1623     {
1624       asection *s;
1625       bfd_boolean dyn;
1626       int tls_type = elf_i386_hash_entry(h)->tls_type;
1627
1628       /* Make sure this symbol is output as a dynamic symbol.
1629          Undefined weak syms won't yet be marked as dynamic.  */
1630       if (h->dynindx == -1
1631           && !h->forced_local)
1632         {
1633           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1634             return FALSE;
1635         }
1636
1637       s = htab->sgot;
1638       h->got.offset = s->size;
1639       s->size += 4;
1640       /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
1641       if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE_BOTH)
1642         s->size += 4;
1643       dyn = htab->elf.dynamic_sections_created;
1644       /* R_386_TLS_IE_32 needs one dynamic relocation,
1645          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1646          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1647          need two), R_386_TLS_GD needs one if local symbol and two if
1648          global.  */
1649       if (tls_type == GOT_TLS_IE_BOTH)
1650         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1651       else if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1652                || (tls_type & GOT_TLS_IE))
1653         htab->srelgot->size += sizeof (Elf32_External_Rel);
1654       else if (tls_type == GOT_TLS_GD)
1655         htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1656       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1657                 || h->root.type != bfd_link_hash_undefweak)
1658                && (info->shared
1659                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1660         htab->srelgot->size += sizeof (Elf32_External_Rel);
1661     }
1662   else
1663     h->got.offset = (bfd_vma) -1;
1664
1665   eh = (struct elf_i386_link_hash_entry *) h;
1666   if (eh->dyn_relocs == NULL)
1667     return TRUE;
1668
1669   /* In the shared -Bsymbolic case, discard space allocated for
1670      dynamic pc-relative relocs against symbols which turn out to be
1671      defined in regular objects.  For the normal shared case, discard
1672      space for pc-relative relocs that have become local due to symbol
1673      visibility changes.  */
1674
1675   if (info->shared)
1676     {
1677       /* The only reloc that uses pc_count is R_386_PC32, which will
1678          appear on a call or on something like ".long foo - .".  We
1679          want calls to protected symbols to resolve directly to the
1680          function rather than going via the plt.  If people want
1681          function pointer comparisons to work as expected then they
1682          should avoid writing assembly like ".long foo - .".  */
1683       if (SYMBOL_CALLS_LOCAL (info, h))
1684         {
1685           struct elf_i386_dyn_relocs **pp;
1686
1687           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1688             {
1689               p->count -= p->pc_count;
1690               p->pc_count = 0;
1691               if (p->count == 0)
1692                 *pp = p->next;
1693               else
1694                 pp = &p->next;
1695             }
1696         }
1697
1698       /* Also discard relocs on undefined weak syms with non-default
1699          visibility.  */
1700       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1701           && h->root.type == bfd_link_hash_undefweak)
1702         eh->dyn_relocs = NULL;
1703     }
1704   else if (ELIMINATE_COPY_RELOCS)
1705     {
1706       /* For the non-shared case, discard space for relocs against
1707          symbols which turn out to need copy relocs or are not
1708          dynamic.  */
1709
1710       if (!h->non_got_ref
1711           && ((h->def_dynamic
1712                && !h->def_regular)
1713               || (htab->elf.dynamic_sections_created
1714                   && (h->root.type == bfd_link_hash_undefweak
1715                       || h->root.type == bfd_link_hash_undefined))))
1716         {
1717           /* Make sure this symbol is output as a dynamic symbol.
1718              Undefined weak syms won't yet be marked as dynamic.  */
1719           if (h->dynindx == -1
1720               && !h->forced_local)
1721             {
1722               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1723                 return FALSE;
1724             }
1725
1726           /* If that succeeded, we know we'll be keeping all the
1727              relocs.  */
1728           if (h->dynindx != -1)
1729             goto keep;
1730         }
1731
1732       eh->dyn_relocs = NULL;
1733
1734     keep: ;
1735     }
1736
1737   /* Finally, allocate space.  */
1738   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1739     {
1740       asection *sreloc = elf_section_data (p->sec)->sreloc;
1741       sreloc->size += p->count * sizeof (Elf32_External_Rel);
1742     }
1743
1744   return TRUE;
1745 }
1746
1747 /* Find any dynamic relocs that apply to read-only sections.  */
1748
1749 static bfd_boolean
1750 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1751 {
1752   struct elf_i386_link_hash_entry *eh;
1753   struct elf_i386_dyn_relocs *p;
1754
1755   if (h->root.type == bfd_link_hash_warning)
1756     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1757
1758   eh = (struct elf_i386_link_hash_entry *) h;
1759   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1760     {
1761       asection *s = p->sec->output_section;
1762
1763       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1764         {
1765           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1766
1767           info->flags |= DF_TEXTREL;
1768
1769           /* Not an error, just cut short the traversal.  */
1770           return FALSE;
1771         }
1772     }
1773   return TRUE;
1774 }
1775
1776 /* Set the sizes of the dynamic sections.  */
1777
1778 static bfd_boolean
1779 elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1780                                 struct bfd_link_info *info)
1781 {
1782   struct elf_i386_link_hash_table *htab;
1783   bfd *dynobj;
1784   asection *s;
1785   bfd_boolean relocs;
1786   bfd *ibfd;
1787
1788   htab = elf_i386_hash_table (info);
1789   dynobj = htab->elf.dynobj;
1790   if (dynobj == NULL)
1791     abort ();
1792
1793   if (htab->elf.dynamic_sections_created)
1794     {
1795       /* Set the contents of the .interp section to the interpreter.  */
1796       if (info->executable)
1797         {
1798           s = bfd_get_section_by_name (dynobj, ".interp");
1799           if (s == NULL)
1800             abort ();
1801           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1802           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1803         }
1804     }
1805
1806   /* Set up .got offsets for local syms, and space for local dynamic
1807      relocs.  */
1808   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1809     {
1810       bfd_signed_vma *local_got;
1811       bfd_signed_vma *end_local_got;
1812       char *local_tls_type;
1813       bfd_size_type locsymcount;
1814       Elf_Internal_Shdr *symtab_hdr;
1815       asection *srel;
1816
1817       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1818         continue;
1819
1820       for (s = ibfd->sections; s != NULL; s = s->next)
1821         {
1822           struct elf_i386_dyn_relocs *p;
1823
1824           for (p = ((struct elf_i386_dyn_relocs *)
1825                      elf_section_data (s)->local_dynrel);
1826                p != NULL;
1827                p = p->next)
1828             {
1829               if (!bfd_is_abs_section (p->sec)
1830                   && bfd_is_abs_section (p->sec->output_section))
1831                 {
1832                   /* Input section has been discarded, either because
1833                      it is a copy of a linkonce section or due to
1834                      linker script /DISCARD/, so we'll be discarding
1835                      the relocs too.  */
1836                 }
1837               else if (p->count != 0)
1838                 {
1839                   srel = elf_section_data (p->sec)->sreloc;
1840                   srel->size += p->count * sizeof (Elf32_External_Rel);
1841                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1842                     info->flags |= DF_TEXTREL;
1843                 }
1844             }
1845         }
1846
1847       local_got = elf_local_got_refcounts (ibfd);
1848       if (!local_got)
1849         continue;
1850
1851       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1852       locsymcount = symtab_hdr->sh_info;
1853       end_local_got = local_got + locsymcount;
1854       local_tls_type = elf_i386_local_got_tls_type (ibfd);
1855       s = htab->sgot;
1856       srel = htab->srelgot;
1857       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1858         {
1859           if (*local_got > 0)
1860             {
1861               *local_got = s->size;
1862               s->size += 4;
1863               if (*local_tls_type == GOT_TLS_GD
1864                   || *local_tls_type == GOT_TLS_IE_BOTH)
1865                 s->size += 4;
1866               if (info->shared
1867                   || *local_tls_type == GOT_TLS_GD
1868                   || (*local_tls_type & GOT_TLS_IE))
1869                 {
1870                   if (*local_tls_type == GOT_TLS_IE_BOTH)
1871                     srel->size += 2 * sizeof (Elf32_External_Rel);
1872                   else
1873                     srel->size += sizeof (Elf32_External_Rel);
1874                 }
1875             }
1876           else
1877             *local_got = (bfd_vma) -1;
1878         }
1879     }
1880
1881   if (htab->tls_ldm_got.refcount > 0)
1882     {
1883       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1884          relocs.  */
1885       htab->tls_ldm_got.offset = htab->sgot->size;
1886       htab->sgot->size += 8;
1887       htab->srelgot->size += sizeof (Elf32_External_Rel);
1888     }
1889   else
1890     htab->tls_ldm_got.offset = -1;
1891
1892   if (htab->is_vxworks)
1893     {
1894       /* Save the GOT and PLT symbols in the hash table for easy access.
1895          Mark them as having relocations; they might not, but we won't
1896          know for sure until we build the GOT in finish_dynamic_symbol.  */
1897
1898       htab->hgot = elf_link_hash_lookup (elf_hash_table (info),
1899                                         "_GLOBAL_OFFSET_TABLE_",
1900                                         FALSE, FALSE, FALSE);
1901       if (htab->hgot)
1902         htab->hgot->indx = -2;
1903       htab->hplt = elf_link_hash_lookup (elf_hash_table (info),
1904                                         "_PROCEDURE_LINKAGE_TABLE_",
1905                                         FALSE, FALSE, FALSE);
1906       if (htab->hplt)
1907         htab->hplt->indx = -2;
1908
1909       if (htab->is_vxworks && htab->hplt && htab->splt->flags & SEC_CODE)
1910         htab->hplt->type = STT_FUNC;
1911     }
1912
1913   /* Allocate global sym .plt and .got entries, and space for global
1914      sym dynamic relocs.  */
1915   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1916
1917   /* We now have determined the sizes of the various dynamic sections.
1918      Allocate memory for them.  */
1919   relocs = FALSE;
1920   for (s = dynobj->sections; s != NULL; s = s->next)
1921     {
1922       bfd_boolean strip_section = TRUE;
1923
1924       if ((s->flags & SEC_LINKER_CREATED) == 0)
1925         continue;
1926
1927       if (s == htab->splt
1928           || s == htab->sgot
1929           || s == htab->sgotplt
1930           || s == htab->sdynbss)
1931         {
1932           /* Strip this section if we don't need it; see the
1933              comment below.  */
1934           /* We'd like to strip these sections if they aren't needed, but if
1935              we've exported dynamic symbols from them we must leave them.
1936              It's too late to tell BFD to get rid of the symbols.  */
1937
1938           if (htab->hplt != NULL)
1939             strip_section = FALSE;
1940         }
1941       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1942         {
1943           if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
1944             relocs = TRUE;
1945
1946           /* We use the reloc_count field as a counter if we need
1947              to copy relocs into the output file.  */
1948           s->reloc_count = 0;
1949         }
1950       else
1951         {
1952           /* It's not one of our sections, so don't allocate space.  */
1953           continue;
1954         }
1955
1956       if (s->size == 0)
1957         {
1958           /* If we don't need this section, strip it from the
1959              output file.  This is mostly to handle .rel.bss and
1960              .rel.plt.  We must create both sections in
1961              create_dynamic_sections, because they must be created
1962              before the linker maps input sections to output
1963              sections.  The linker does that before
1964              adjust_dynamic_symbol is called, and it is that
1965              function which decides whether anything needs to go
1966              into these sections.  */
1967           if (strip_section)
1968             s->flags |= SEC_EXCLUDE;
1969           continue;
1970         }
1971
1972       if ((s->flags & SEC_HAS_CONTENTS) == 0)
1973         continue;
1974
1975       /* Allocate memory for the section contents.  We use bfd_zalloc
1976          here in case unused entries are not reclaimed before the
1977          section's contents are written out.  This should not happen,
1978          but this way if it does, we get a R_386_NONE reloc instead
1979          of garbage.  */
1980       s->contents = bfd_zalloc (dynobj, s->size);
1981       if (s->contents == NULL)
1982         return FALSE;
1983     }
1984
1985   if (htab->elf.dynamic_sections_created)
1986     {
1987       /* Add some entries to the .dynamic section.  We fill in the
1988          values later, in elf_i386_finish_dynamic_sections, but we
1989          must add the entries now so that we get the correct size for
1990          the .dynamic section.  The DT_DEBUG entry is filled in by the
1991          dynamic linker and used by the debugger.  */
1992 #define add_dynamic_entry(TAG, VAL) \
1993   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1994
1995       if (info->executable)
1996         {
1997           if (!add_dynamic_entry (DT_DEBUG, 0))
1998             return FALSE;
1999         }
2000
2001       if (htab->splt->size != 0)
2002         {
2003           if (!add_dynamic_entry (DT_PLTGOT, 0)
2004               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2005               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2006               || !add_dynamic_entry (DT_JMPREL, 0))
2007             return FALSE;
2008         }
2009
2010       if (relocs)
2011         {
2012           if (!add_dynamic_entry (DT_REL, 0)
2013               || !add_dynamic_entry (DT_RELSZ, 0)
2014               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2015             return FALSE;
2016
2017           /* If any dynamic relocs apply to a read-only section,
2018              then we need a DT_TEXTREL entry.  */
2019           if ((info->flags & DF_TEXTREL) == 0)
2020             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2021                                     (PTR) info);
2022
2023           if ((info->flags & DF_TEXTREL) != 0)
2024             {
2025               if (!add_dynamic_entry (DT_TEXTREL, 0))
2026                 return FALSE;
2027             }
2028         }
2029     }
2030 #undef add_dynamic_entry
2031
2032   return TRUE;
2033 }
2034
2035 /* Set the correct type for an x86 ELF section.  We do this by the
2036    section name, which is a hack, but ought to work.  */
2037
2038 static bfd_boolean
2039 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2040                         Elf_Internal_Shdr *hdr,
2041                         asection *sec)
2042 {
2043   register const char *name;
2044
2045   name = bfd_get_section_name (abfd, sec);
2046
2047   /* This is an ugly, but unfortunately necessary hack that is
2048      needed when producing EFI binaries on x86. It tells
2049      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2050      containing ELF relocation info.  We need this hack in order to
2051      be able to generate ELF binaries that can be translated into
2052      EFI applications (which are essentially COFF objects).  Those
2053      files contain a COFF ".reloc" section inside an ELFNN object,
2054      which would normally cause BFD to segfault because it would
2055      attempt to interpret this section as containing relocation
2056      entries for section "oc".  With this hack enabled, ".reloc"
2057      will be treated as a normal data section, which will avoid the
2058      segfault.  However, you won't be able to create an ELFNN binary
2059      with a section named "oc" that needs relocations, but that's
2060      the kind of ugly side-effects you get when detecting section
2061      types based on their names...  In practice, this limitation is
2062      unlikely to bite.  */
2063   if (strcmp (name, ".reloc") == 0)
2064     hdr->sh_type = SHT_PROGBITS;
2065
2066   return TRUE;
2067 }
2068
2069 /* Return the base VMA address which should be subtracted from real addresses
2070    when resolving @dtpoff relocation.
2071    This is PT_TLS segment p_vaddr.  */
2072
2073 static bfd_vma
2074 dtpoff_base (struct bfd_link_info *info)
2075 {
2076   /* If tls_sec is NULL, we should have signalled an error already.  */
2077   if (elf_hash_table (info)->tls_sec == NULL)
2078     return 0;
2079   return elf_hash_table (info)->tls_sec->vma;
2080 }
2081
2082 /* Return the relocation value for @tpoff relocation
2083    if STT_TLS virtual address is ADDRESS.  */
2084
2085 static bfd_vma
2086 tpoff (struct bfd_link_info *info, bfd_vma address)
2087 {
2088   struct elf_link_hash_table *htab = elf_hash_table (info);
2089
2090   /* If tls_sec is NULL, we should have signalled an error already.  */
2091   if (htab->tls_sec == NULL)
2092     return 0;
2093   return htab->tls_size + htab->tls_sec->vma - address;
2094 }
2095
2096 /* Relocate an i386 ELF section.  */
2097
2098 static bfd_boolean
2099 elf_i386_relocate_section (bfd *output_bfd,
2100                            struct bfd_link_info *info,
2101                            bfd *input_bfd,
2102                            asection *input_section,
2103                            bfd_byte *contents,
2104                            Elf_Internal_Rela *relocs,
2105                            Elf_Internal_Sym *local_syms,
2106                            asection **local_sections)
2107 {
2108   struct elf_i386_link_hash_table *htab;
2109   Elf_Internal_Shdr *symtab_hdr;
2110   struct elf_link_hash_entry **sym_hashes;
2111   bfd_vma *local_got_offsets;
2112   Elf_Internal_Rela *rel;
2113   Elf_Internal_Rela *relend;
2114
2115   htab = elf_i386_hash_table (info);
2116   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2117   sym_hashes = elf_sym_hashes (input_bfd);
2118   local_got_offsets = elf_local_got_offsets (input_bfd);
2119
2120   rel = relocs;
2121   relend = relocs + input_section->reloc_count;
2122   for (; rel < relend; rel++)
2123     {
2124       unsigned int r_type;
2125       reloc_howto_type *howto;
2126       unsigned long r_symndx;
2127       struct elf_link_hash_entry *h;
2128       Elf_Internal_Sym *sym;
2129       asection *sec;
2130       bfd_vma off;
2131       bfd_vma relocation;
2132       bfd_boolean unresolved_reloc;
2133       bfd_reloc_status_type r;
2134       unsigned int indx;
2135       int tls_type;
2136
2137       r_type = ELF32_R_TYPE (rel->r_info);
2138       if (r_type == R_386_GNU_VTINHERIT
2139           || r_type == R_386_GNU_VTENTRY)
2140         continue;
2141
2142       if ((indx = r_type) >= R_386_standard
2143           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2144               >= R_386_ext - R_386_standard)
2145           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2146               >= R_386_tls - R_386_ext))
2147         {
2148           (*_bfd_error_handler)
2149             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2150              input_bfd, input_section, r_type);
2151           bfd_set_error (bfd_error_bad_value);
2152           return FALSE;
2153         }
2154       howto = elf_howto_table + indx;
2155
2156       r_symndx = ELF32_R_SYM (rel->r_info);
2157
2158       if (info->relocatable)
2159         {
2160           bfd_vma val;
2161           bfd_byte *where;
2162
2163           /* This is a relocatable link.  We don't have to change
2164              anything, unless the reloc is against a section symbol,
2165              in which case we have to adjust according to where the
2166              section symbol winds up in the output section.  */
2167           if (r_symndx >= symtab_hdr->sh_info)
2168             continue;
2169
2170           sym = local_syms + r_symndx;
2171           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2172             continue;
2173
2174           sec = local_sections[r_symndx];
2175           val = sec->output_offset;
2176           if (val == 0)
2177             continue;
2178
2179           where = contents + rel->r_offset;
2180           switch (howto->size)
2181             {
2182               /* FIXME: overflow checks.  */
2183             case 0:
2184               val += bfd_get_8 (input_bfd, where);
2185               bfd_put_8 (input_bfd, val, where);
2186               break;
2187             case 1:
2188               val += bfd_get_16 (input_bfd, where);
2189               bfd_put_16 (input_bfd, val, where);
2190               break;
2191             case 2:
2192               val += bfd_get_32 (input_bfd, where);
2193               bfd_put_32 (input_bfd, val, where);
2194               break;
2195             default:
2196               abort ();
2197             }
2198           continue;
2199         }
2200
2201       /* This is a final link.  */
2202       h = NULL;
2203       sym = NULL;
2204       sec = NULL;
2205       unresolved_reloc = FALSE;
2206       if (r_symndx < symtab_hdr->sh_info)
2207         {
2208           sym = local_syms + r_symndx;
2209           sec = local_sections[r_symndx];
2210           relocation = (sec->output_section->vma
2211                         + sec->output_offset
2212                         + sym->st_value);
2213           if ((sec->flags & SEC_MERGE)
2214               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2215             {
2216               asection *msec;
2217               bfd_vma addend;
2218               bfd_byte *where = contents + rel->r_offset;
2219
2220               switch (howto->size)
2221                 {
2222                 case 0:
2223                   addend = bfd_get_8 (input_bfd, where);
2224                   if (howto->pc_relative)
2225                     {
2226                       addend = (addend ^ 0x80) - 0x80;
2227                       addend += 1;
2228                     }
2229                   break;
2230                 case 1:
2231                   addend = bfd_get_16 (input_bfd, where);
2232                   if (howto->pc_relative)
2233                     {
2234                       addend = (addend ^ 0x8000) - 0x8000;
2235                       addend += 2;
2236                     }
2237                   break;
2238                 case 2:
2239                   addend = bfd_get_32 (input_bfd, where);
2240                   if (howto->pc_relative)
2241                     {
2242                       addend = (addend ^ 0x80000000) - 0x80000000;
2243                       addend += 4;
2244                     }
2245                   break;
2246                 default:
2247                   abort ();
2248                 }
2249
2250               msec = sec;
2251               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2252               addend -= relocation;
2253               addend += msec->output_section->vma + msec->output_offset;
2254
2255               switch (howto->size)
2256                 {
2257                 case 0:
2258                   /* FIXME: overflow checks.  */
2259                   if (howto->pc_relative)
2260                     addend -= 1;
2261                   bfd_put_8 (input_bfd, addend, where);
2262                   break;
2263                 case 1:
2264                   if (howto->pc_relative)
2265                     addend -= 2;
2266                   bfd_put_16 (input_bfd, addend, where);
2267                   break;
2268                 case 2:
2269                   if (howto->pc_relative)
2270                     addend -= 4;
2271                   bfd_put_32 (input_bfd, addend, where);
2272                   break;
2273                 }
2274             }
2275         }
2276       else
2277         {
2278           bfd_boolean warned;
2279
2280           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2281                                    r_symndx, symtab_hdr, sym_hashes,
2282                                    h, sec, relocation,
2283                                    unresolved_reloc, warned);
2284         }
2285
2286       if (r_symndx == 0)
2287         {
2288         /* r_symndx will be zero only for relocs against symbols from
2289            removed linkonce sections, or sections discarded by a linker
2290            script.  For these relocs, we just want the section contents
2291            zeroed.  Avoid any special processing in the switch below.  */
2292           r_type = R_386_NONE;
2293
2294           relocation = 0;
2295           if (howto->pc_relative)
2296             relocation = (input_section->output_section->vma
2297                           + input_section->output_offset
2298                           + rel->r_offset);
2299         }
2300
2301       switch (r_type)
2302         {
2303         case R_386_GOT32:
2304           /* Relocation is to the entry for this symbol in the global
2305              offset table.  */
2306           if (htab->sgot == NULL)
2307             abort ();
2308
2309           if (h != NULL)
2310             {
2311               bfd_boolean dyn;
2312
2313               off = h->got.offset;
2314               dyn = htab->elf.dynamic_sections_created;
2315               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2316                   || (info->shared
2317                       && SYMBOL_REFERENCES_LOCAL (info, h))
2318                   || (ELF_ST_VISIBILITY (h->other)
2319                       && h->root.type == bfd_link_hash_undefweak))
2320                 {
2321                   /* This is actually a static link, or it is a
2322                      -Bsymbolic link and the symbol is defined
2323                      locally, or the symbol was forced to be local
2324                      because of a version file.  We must initialize
2325                      this entry in the global offset table.  Since the
2326                      offset must always be a multiple of 4, we use the
2327                      least significant bit to record whether we have
2328                      initialized it already.
2329
2330                      When doing a dynamic link, we create a .rel.got
2331                      relocation entry to initialize the value.  This
2332                      is done in the finish_dynamic_symbol routine.  */
2333                   if ((off & 1) != 0)
2334                     off &= ~1;
2335                   else
2336                     {
2337                       bfd_put_32 (output_bfd, relocation,
2338                                   htab->sgot->contents + off);
2339                       h->got.offset |= 1;
2340                     }
2341                 }
2342               else
2343                 unresolved_reloc = FALSE;
2344             }
2345           else
2346             {
2347               if (local_got_offsets == NULL)
2348                 abort ();
2349
2350               off = local_got_offsets[r_symndx];
2351
2352               /* The offset must always be a multiple of 4.  We use
2353                  the least significant bit to record whether we have
2354                  already generated the necessary reloc.  */
2355               if ((off & 1) != 0)
2356                 off &= ~1;
2357               else
2358                 {
2359                   bfd_put_32 (output_bfd, relocation,
2360                               htab->sgot->contents + off);
2361
2362                   if (info->shared)
2363                     {
2364                       asection *s;
2365                       Elf_Internal_Rela outrel;
2366                       bfd_byte *loc;
2367
2368                       s = htab->srelgot;
2369                       if (s == NULL)
2370                         abort ();
2371
2372                       outrel.r_offset = (htab->sgot->output_section->vma
2373                                          + htab->sgot->output_offset
2374                                          + off);
2375                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2376                       loc = s->contents;
2377                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2378                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2379                     }
2380
2381                   local_got_offsets[r_symndx] |= 1;
2382                 }
2383             }
2384
2385           if (off >= (bfd_vma) -2)
2386             abort ();
2387
2388           relocation = htab->sgot->output_section->vma
2389                        + htab->sgot->output_offset + off
2390                        - htab->sgotplt->output_section->vma
2391                        - htab->sgotplt->output_offset;
2392           break;
2393
2394         case R_386_GOTOFF:
2395           /* Relocation is relative to the start of the global offset
2396              table.  */
2397
2398           /* Check to make sure it isn't a protected function symbol
2399              for shared library since it may not be local when used
2400              as function address.  */
2401           if (info->shared
2402               && !info->executable
2403               && h
2404               && h->def_regular
2405               && h->type == STT_FUNC
2406               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2407             {
2408               (*_bfd_error_handler)
2409                 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2410                  input_bfd, h->root.root.string);
2411               bfd_set_error (bfd_error_bad_value);
2412               return FALSE;
2413             }
2414
2415           /* Note that sgot is not involved in this
2416              calculation.  We always want the start of .got.plt.  If we
2417              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2418              permitted by the ABI, we might have to change this
2419              calculation.  */
2420           relocation -= htab->sgotplt->output_section->vma
2421                         + htab->sgotplt->output_offset;
2422           break;
2423
2424         case R_386_GOTPC:
2425           /* Use global offset table as symbol value.  */
2426           relocation = htab->sgotplt->output_section->vma
2427                        + htab->sgotplt->output_offset;
2428           unresolved_reloc = FALSE;
2429           break;
2430
2431         case R_386_PLT32:
2432           /* Relocation is to the entry for this symbol in the
2433              procedure linkage table.  */
2434
2435           /* Resolve a PLT32 reloc against a local symbol directly,
2436              without using the procedure linkage table.  */
2437           if (h == NULL)
2438             break;
2439
2440           if (h->plt.offset == (bfd_vma) -1
2441               || htab->splt == NULL)
2442             {
2443               /* We didn't make a PLT entry for this symbol.  This
2444                  happens when statically linking PIC code, or when
2445                  using -Bsymbolic.  */
2446               break;
2447             }
2448
2449           relocation = (htab->splt->output_section->vma
2450                         + htab->splt->output_offset
2451                         + h->plt.offset);
2452           unresolved_reloc = FALSE;
2453           break;
2454
2455         case R_386_32:
2456         case R_386_PC32:
2457           if ((input_section->flags & SEC_ALLOC) == 0)
2458             break;
2459
2460           if ((info->shared
2461                && (h == NULL
2462                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2463                    || h->root.type != bfd_link_hash_undefweak)
2464                && (r_type != R_386_PC32
2465                    || !SYMBOL_CALLS_LOCAL (info, h)))
2466               || (ELIMINATE_COPY_RELOCS
2467                   && !info->shared
2468                   && h != NULL
2469                   && h->dynindx != -1
2470                   && !h->non_got_ref
2471                   && ((h->def_dynamic
2472                        && !h->def_regular)
2473                       || h->root.type == bfd_link_hash_undefweak
2474                       || h->root.type == bfd_link_hash_undefined)))
2475             {
2476               Elf_Internal_Rela outrel;
2477               bfd_byte *loc;
2478               bfd_boolean skip, relocate;
2479               asection *sreloc;
2480
2481               /* When generating a shared object, these relocations
2482                  are copied into the output file to be resolved at run
2483                  time.  */
2484
2485               skip = FALSE;
2486               relocate = FALSE;
2487
2488               outrel.r_offset =
2489                 _bfd_elf_section_offset (output_bfd, info, input_section,
2490                                          rel->r_offset);
2491               if (outrel.r_offset == (bfd_vma) -1)
2492                 skip = TRUE;
2493               else if (outrel.r_offset == (bfd_vma) -2)
2494                 skip = TRUE, relocate = TRUE;
2495               outrel.r_offset += (input_section->output_section->vma
2496                                   + input_section->output_offset);
2497
2498               if (skip)
2499                 memset (&outrel, 0, sizeof outrel);
2500               else if (h != NULL
2501                        && h->dynindx != -1
2502                        && (r_type == R_386_PC32
2503                            || !info->shared
2504                            || !info->symbolic
2505                            || !h->def_regular))
2506                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2507               else
2508                 {
2509                   /* This symbol is local, or marked to become local.  */
2510                   relocate = TRUE;
2511                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2512                 }
2513
2514               sreloc = elf_section_data (input_section)->sreloc;
2515               if (sreloc == NULL)
2516                 abort ();
2517
2518               loc = sreloc->contents;
2519               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2520               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2521
2522               /* If this reloc is against an external symbol, we do
2523                  not want to fiddle with the addend.  Otherwise, we
2524                  need to include the symbol value so that it becomes
2525                  an addend for the dynamic reloc.  */
2526               if (! relocate)
2527                 continue;
2528             }
2529           break;
2530
2531         case R_386_TLS_IE:
2532           if (info->shared)
2533             {
2534               Elf_Internal_Rela outrel;
2535               bfd_byte *loc;
2536               asection *sreloc;
2537
2538               outrel.r_offset = rel->r_offset
2539                                 + input_section->output_section->vma
2540                                 + input_section->output_offset;
2541               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2542               sreloc = elf_section_data (input_section)->sreloc;
2543               if (sreloc == NULL)
2544                 abort ();
2545               loc = sreloc->contents;
2546               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2547               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2548             }
2549           /* Fall through */
2550
2551         case R_386_TLS_GD:
2552         case R_386_TLS_IE_32:
2553         case R_386_TLS_GOTIE:
2554           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2555           tls_type = GOT_UNKNOWN;
2556           if (h == NULL && local_got_offsets)
2557             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2558           else if (h != NULL)
2559             {
2560               tls_type = elf_i386_hash_entry(h)->tls_type;
2561               if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2562                 r_type = R_386_TLS_LE_32;
2563             }
2564           if (tls_type == GOT_TLS_IE)
2565             tls_type = GOT_TLS_IE_NEG;
2566           if (r_type == R_386_TLS_GD)
2567             {
2568               if (tls_type == GOT_TLS_IE_POS)
2569                 r_type = R_386_TLS_GOTIE;
2570               else if (tls_type & GOT_TLS_IE)
2571                 r_type = R_386_TLS_IE_32;
2572             }
2573
2574           if (r_type == R_386_TLS_LE_32)
2575             {
2576               BFD_ASSERT (! unresolved_reloc);
2577               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2578                 {
2579                   unsigned int val, type;
2580                   bfd_vma roff;
2581
2582                   /* GD->LE transition.  */
2583                   BFD_ASSERT (rel->r_offset >= 2);
2584                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2585                   BFD_ASSERT (type == 0x8d || type == 0x04);
2586                   BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2587                   BFD_ASSERT (bfd_get_8 (input_bfd,
2588                                          contents + rel->r_offset + 4)
2589                               == 0xe8);
2590                   BFD_ASSERT (rel + 1 < relend);
2591                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2592                   roff = rel->r_offset + 5;
2593                   val = bfd_get_8 (input_bfd,
2594                                    contents + rel->r_offset - 1);
2595                   if (type == 0x04)
2596                     {
2597                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2598                          Change it into:
2599                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2600                          (6 byte form of subl).  */
2601                       BFD_ASSERT (rel->r_offset >= 3);
2602                       BFD_ASSERT (bfd_get_8 (input_bfd,
2603                                              contents + rel->r_offset - 3)
2604                                   == 0x8d);
2605                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2606                       memcpy (contents + rel->r_offset - 3,
2607                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2608                     }
2609                   else
2610                     {
2611                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2612                       if (rel->r_offset + 10 <= input_section->size
2613                           && bfd_get_8 (input_bfd,
2614                                         contents + rel->r_offset + 9) == 0x90)
2615                         {
2616                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2617                              Change it into:
2618                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2619                              (6 byte form of subl).  */
2620                           memcpy (contents + rel->r_offset - 2,
2621                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2622                           roff = rel->r_offset + 6;
2623                         }
2624                       else
2625                         {
2626                           /* leal foo(%reg), %eax; call ___tls_get_addr
2627                              Change it into:
2628                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2629                              (5 byte form of subl).  */
2630                           memcpy (contents + rel->r_offset - 2,
2631                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2632                         }
2633                     }
2634                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2635                               contents + roff);
2636                   /* Skip R_386_PLT32.  */
2637                   rel++;
2638                   continue;
2639                 }
2640               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2641                 {
2642                   unsigned int val, type;
2643
2644                   /* IE->LE transition:
2645                      Originally it can be one of:
2646                      movl foo, %eax
2647                      movl foo, %reg
2648                      addl foo, %reg
2649                      We change it into:
2650                      movl $foo, %eax
2651                      movl $foo, %reg
2652                      addl $foo, %reg.  */
2653                   BFD_ASSERT (rel->r_offset >= 1);
2654                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2655                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2656                   if (val == 0xa1)
2657                     {
2658                       /* movl foo, %eax.  */
2659                       bfd_put_8 (output_bfd, 0xb8,
2660                                  contents + rel->r_offset - 1);
2661                     }
2662                   else
2663                     {
2664                       BFD_ASSERT (rel->r_offset >= 2);
2665                       type = bfd_get_8 (input_bfd,
2666                                         contents + rel->r_offset - 2);
2667                       switch (type)
2668                         {
2669                         case 0x8b:
2670                           /* movl */
2671                           BFD_ASSERT ((val & 0xc7) == 0x05);
2672                           bfd_put_8 (output_bfd, 0xc7,
2673                                      contents + rel->r_offset - 2);
2674                           bfd_put_8 (output_bfd,
2675                                      0xc0 | ((val >> 3) & 7),
2676                                      contents + rel->r_offset - 1);
2677                           break;
2678                         case 0x03:
2679                           /* addl */
2680                           BFD_ASSERT ((val & 0xc7) == 0x05);
2681                           bfd_put_8 (output_bfd, 0x81,
2682                                      contents + rel->r_offset - 2);
2683                           bfd_put_8 (output_bfd,
2684                                      0xc0 | ((val >> 3) & 7),
2685                                      contents + rel->r_offset - 1);
2686                           break;
2687                         default:
2688                           BFD_FAIL ();
2689                           break;
2690                         }
2691                     }
2692                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2693                               contents + rel->r_offset);
2694                   continue;
2695                 }
2696               else
2697                 {
2698                   unsigned int val, type;
2699
2700                   /* {IE_32,GOTIE}->LE transition:
2701                      Originally it can be one of:
2702                      subl foo(%reg1), %reg2
2703                      movl foo(%reg1), %reg2
2704                      addl foo(%reg1), %reg2
2705                      We change it into:
2706                      subl $foo, %reg2
2707                      movl $foo, %reg2 (6 byte form)
2708                      addl $foo, %reg2.  */
2709                   BFD_ASSERT (rel->r_offset >= 2);
2710                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2711                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2712                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2713                   BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2714                   if (type == 0x8b)
2715                     {
2716                       /* movl */
2717                       bfd_put_8 (output_bfd, 0xc7,
2718                                  contents + rel->r_offset - 2);
2719                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2720                                  contents + rel->r_offset - 1);
2721                     }
2722                   else if (type == 0x2b)
2723                     {
2724                       /* subl */
2725                       bfd_put_8 (output_bfd, 0x81,
2726                                  contents + rel->r_offset - 2);
2727                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2728                                  contents + rel->r_offset - 1);
2729                     }
2730                   else if (type == 0x03)
2731                     {
2732                       /* addl */
2733                       bfd_put_8 (output_bfd, 0x81,
2734                                  contents + rel->r_offset - 2);
2735                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2736                                  contents + rel->r_offset - 1);
2737                     }
2738                   else
2739                     BFD_FAIL ();
2740                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2741                     bfd_put_32 (output_bfd, -tpoff (info, relocation),
2742                                 contents + rel->r_offset);
2743                   else
2744                     bfd_put_32 (output_bfd, tpoff (info, relocation),
2745                                 contents + rel->r_offset);
2746                   continue;
2747                 }
2748             }
2749
2750           if (htab->sgot == NULL)
2751             abort ();
2752
2753           if (h != NULL)
2754             off = h->got.offset;
2755           else
2756             {
2757               if (local_got_offsets == NULL)
2758                 abort ();
2759
2760               off = local_got_offsets[r_symndx];
2761             }
2762
2763           if ((off & 1) != 0)
2764             off &= ~1;
2765           else
2766             {
2767               Elf_Internal_Rela outrel;
2768               bfd_byte *loc;
2769               int dr_type, indx;
2770
2771               if (htab->srelgot == NULL)
2772                 abort ();
2773
2774               outrel.r_offset = (htab->sgot->output_section->vma
2775                                  + htab->sgot->output_offset + off);
2776
2777               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2778               if (r_type == R_386_TLS_GD)
2779                 dr_type = R_386_TLS_DTPMOD32;
2780               else if (tls_type == GOT_TLS_IE_POS)
2781                 dr_type = R_386_TLS_TPOFF;
2782               else
2783                 dr_type = R_386_TLS_TPOFF32;
2784               if (dr_type == R_386_TLS_TPOFF && indx == 0)
2785                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2786                             htab->sgot->contents + off);
2787               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2788                 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
2789                             htab->sgot->contents + off);
2790               else
2791                 bfd_put_32 (output_bfd, 0,
2792                             htab->sgot->contents + off);
2793               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2794               loc = htab->srelgot->contents;
2795               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2796               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2797
2798               if (r_type == R_386_TLS_GD)
2799                 {
2800                   if (indx == 0)
2801                     {
2802                       BFD_ASSERT (! unresolved_reloc);
2803                       bfd_put_32 (output_bfd,
2804                                   relocation - dtpoff_base (info),
2805                                   htab->sgot->contents + off + 4);
2806                     }
2807                   else
2808                     {
2809                       bfd_put_32 (output_bfd, 0,
2810                                   htab->sgot->contents + off + 4);
2811                       outrel.r_info = ELF32_R_INFO (indx,
2812                                                     R_386_TLS_DTPOFF32);
2813                       outrel.r_offset += 4;
2814                       htab->srelgot->reloc_count++;
2815                       loc += sizeof (Elf32_External_Rel);
2816                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2817                     }
2818                 }
2819               else if (tls_type == GOT_TLS_IE_BOTH)
2820                 {
2821                   bfd_put_32 (output_bfd,
2822                               indx == 0 ? relocation - dtpoff_base (info) : 0,
2823                               htab->sgot->contents + off + 4);
2824                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2825                   outrel.r_offset += 4;
2826                   htab->srelgot->reloc_count++;
2827                   loc += sizeof (Elf32_External_Rel);
2828                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2829                 }
2830
2831               if (h != NULL)
2832                 h->got.offset |= 1;
2833               else
2834                 local_got_offsets[r_symndx] |= 1;
2835             }
2836
2837           if (off >= (bfd_vma) -2)
2838             abort ();
2839           if (r_type == ELF32_R_TYPE (rel->r_info))
2840             {
2841               bfd_vma g_o_t = htab->sgotplt->output_section->vma
2842                               + htab->sgotplt->output_offset;
2843               relocation = htab->sgot->output_section->vma
2844                            + htab->sgot->output_offset + off - g_o_t;
2845               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2846                   && tls_type == GOT_TLS_IE_BOTH)
2847                 relocation += 4;
2848               if (r_type == R_386_TLS_IE)
2849                 relocation += g_o_t;
2850               unresolved_reloc = FALSE;
2851             }
2852           else
2853             {
2854               unsigned int val, type;
2855               bfd_vma roff;
2856
2857               /* GD->IE transition.  */
2858               BFD_ASSERT (rel->r_offset >= 2);
2859               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2860               BFD_ASSERT (type == 0x8d || type == 0x04);
2861               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2862               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2863                           == 0xe8);
2864               BFD_ASSERT (rel + 1 < relend);
2865               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2866               roff = rel->r_offset - 3;
2867               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2868               if (type == 0x04)
2869                 {
2870                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2871                      Change it into:
2872                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2873                   BFD_ASSERT (rel->r_offset >= 3);
2874                   BFD_ASSERT (bfd_get_8 (input_bfd,
2875                                          contents + rel->r_offset - 3)
2876                               == 0x8d);
2877                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2878                   val >>= 3;
2879                 }
2880               else
2881                 {
2882                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2883                      Change it into:
2884                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2885                   BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
2886                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2887                   BFD_ASSERT (bfd_get_8 (input_bfd,
2888                                          contents + rel->r_offset + 9)
2889                               == 0x90);
2890                   roff = rel->r_offset - 2;
2891                 }
2892               memcpy (contents + roff,
2893                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2894               contents[roff + 7] = 0x80 | (val & 7);
2895               /* If foo is used only with foo@gotntpoff(%reg) and
2896                  foo@indntpoff, but not with foo@gottpoff(%reg), change
2897                  subl $foo@gottpoff(%reg), %eax
2898                  into:
2899                  addl $foo@gotntpoff(%reg), %eax.  */
2900               if (r_type == R_386_TLS_GOTIE)
2901                 {
2902                   contents[roff + 6] = 0x03;
2903                   if (tls_type == GOT_TLS_IE_BOTH)
2904                     off += 4;
2905                 }
2906               bfd_put_32 (output_bfd,
2907                           htab->sgot->output_section->vma
2908                           + htab->sgot->output_offset + off
2909                           - htab->sgotplt->output_section->vma
2910                           - htab->sgotplt->output_offset,
2911                           contents + roff + 8);
2912               /* Skip R_386_PLT32.  */
2913               rel++;
2914               continue;
2915             }
2916           break;
2917
2918         case R_386_TLS_LDM:
2919           if (! info->shared)
2920             {
2921               unsigned int val;
2922
2923               /* LD->LE transition:
2924                  Ensure it is:
2925                  leal foo(%reg), %eax; call ___tls_get_addr.
2926                  We change it into:
2927                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
2928               BFD_ASSERT (rel->r_offset >= 2);
2929               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2930                           == 0x8d);
2931               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2932               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2933               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2934               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2935                           == 0xe8);
2936               BFD_ASSERT (rel + 1 < relend);
2937               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2938               memcpy (contents + rel->r_offset - 2,
2939                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2940               /* Skip R_386_PLT32.  */
2941               rel++;
2942               continue;
2943             }
2944
2945           if (htab->sgot == NULL)
2946             abort ();
2947
2948           off = htab->tls_ldm_got.offset;
2949           if (off & 1)
2950             off &= ~1;
2951           else
2952             {
2953               Elf_Internal_Rela outrel;
2954               bfd_byte *loc;
2955
2956               if (htab->srelgot == NULL)
2957                 abort ();
2958
2959               outrel.r_offset = (htab->sgot->output_section->vma
2960                                  + htab->sgot->output_offset + off);
2961
2962               bfd_put_32 (output_bfd, 0,
2963                           htab->sgot->contents + off);
2964               bfd_put_32 (output_bfd, 0,
2965                           htab->sgot->contents + off + 4);
2966               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2967               loc = htab->srelgot->contents;
2968               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2969               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2970               htab->tls_ldm_got.offset |= 1;
2971             }
2972           relocation = htab->sgot->output_section->vma
2973                        + htab->sgot->output_offset + off
2974                        - htab->sgotplt->output_section->vma
2975                        - htab->sgotplt->output_offset;
2976           unresolved_reloc = FALSE;
2977           break;
2978
2979         case R_386_TLS_LDO_32:
2980           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2981             relocation -= dtpoff_base (info);
2982           else
2983             /* When converting LDO to LE, we must negate.  */
2984             relocation = -tpoff (info, relocation);
2985           break;
2986
2987         case R_386_TLS_LE_32:
2988         case R_386_TLS_LE:
2989           if (info->shared)
2990             {
2991               Elf_Internal_Rela outrel;
2992               asection *sreloc;
2993               bfd_byte *loc;
2994               int indx;
2995
2996               outrel.r_offset = rel->r_offset
2997                                 + input_section->output_section->vma
2998                                 + input_section->output_offset;
2999               if (h != NULL && h->dynindx != -1)
3000                 indx = h->dynindx;
3001               else
3002                 indx = 0;
3003               if (r_type == R_386_TLS_LE_32)
3004                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3005               else
3006                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3007               sreloc = elf_section_data (input_section)->sreloc;
3008               if (sreloc == NULL)
3009                 abort ();
3010               loc = sreloc->contents;
3011               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3012               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3013               if (indx)
3014                 continue;
3015               else if (r_type == R_386_TLS_LE_32)
3016                 relocation = dtpoff_base (info) - relocation;
3017               else
3018                 relocation -= dtpoff_base (info);
3019             }
3020           else if (r_type == R_386_TLS_LE_32)
3021             relocation = tpoff (info, relocation);
3022           else
3023             relocation = -tpoff (info, relocation);
3024           break;
3025
3026         default:
3027           break;
3028         }
3029
3030       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3031          because such sections are not SEC_ALLOC and thus ld.so will
3032          not process them.  */
3033       if (unresolved_reloc
3034           && !((input_section->flags & SEC_DEBUGGING) != 0
3035                && h->def_dynamic))
3036         {
3037           (*_bfd_error_handler)
3038             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3039              input_bfd,
3040              input_section,
3041              (long) rel->r_offset,
3042              howto->name,
3043              h->root.root.string);
3044           return FALSE;
3045         }
3046
3047       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3048                                     contents, rel->r_offset,
3049                                     relocation, 0);
3050
3051       if (r != bfd_reloc_ok)
3052         {
3053           const char *name;
3054
3055           if (h != NULL)
3056             name = h->root.root.string;
3057           else
3058             {
3059               name = bfd_elf_string_from_elf_section (input_bfd,
3060                                                       symtab_hdr->sh_link,
3061                                                       sym->st_name);
3062               if (name == NULL)
3063                 return FALSE;
3064               if (*name == '\0')
3065                 name = bfd_section_name (input_bfd, sec);
3066             }
3067
3068           if (r == bfd_reloc_overflow)
3069             {
3070               if (! ((*info->callbacks->reloc_overflow)
3071                      (info, (h ? &h->root : NULL), name, howto->name,
3072                       (bfd_vma) 0, input_bfd, input_section,
3073                       rel->r_offset)))
3074                 return FALSE;
3075             }
3076           else
3077             {
3078               (*_bfd_error_handler)
3079                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3080                  input_bfd, input_section,
3081                  (long) rel->r_offset, name, (int) r);
3082               return FALSE;
3083             }
3084         }
3085     }
3086
3087   return TRUE;
3088 }
3089
3090 /* Finish up dynamic symbol handling.  We set the contents of various
3091    dynamic sections here.  */
3092
3093 static bfd_boolean
3094 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3095                                 struct bfd_link_info *info,
3096                                 struct elf_link_hash_entry *h,
3097                                 Elf_Internal_Sym *sym)
3098 {
3099   struct elf_i386_link_hash_table *htab;
3100
3101   htab = elf_i386_hash_table (info);
3102
3103   if (h->plt.offset != (bfd_vma) -1)
3104     {
3105       bfd_vma plt_index;
3106       bfd_vma got_offset;
3107       Elf_Internal_Rela rel;
3108       bfd_byte *loc;
3109
3110       /* This symbol has an entry in the procedure linkage table.  Set
3111          it up.  */
3112
3113       if (h->dynindx == -1
3114           || htab->splt == NULL
3115           || htab->sgotplt == NULL
3116           || htab->srelplt == NULL)
3117         abort ();
3118
3119       /* Get the index in the procedure linkage table which
3120          corresponds to this symbol.  This is the index of this symbol
3121          in all the symbols for which we are making plt entries.  The
3122          first entry in the procedure linkage table is reserved.  */
3123       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3124
3125       /* Get the offset into the .got table of the entry that
3126          corresponds to this function.  Each .got entry is 4 bytes.
3127          The first three are reserved.  */
3128       got_offset = (plt_index + 3) * 4;
3129
3130       /* Fill in the entry in the procedure linkage table.  */
3131       if (! info->shared)
3132         {
3133           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3134                   PLT_ENTRY_SIZE);
3135           bfd_put_32 (output_bfd,
3136                       (htab->sgotplt->output_section->vma
3137                        + htab->sgotplt->output_offset
3138                        + got_offset),
3139                       htab->splt->contents + h->plt.offset + 2);
3140
3141           if (htab->is_vxworks)
3142             {
3143               int s, k, reloc_index;
3144
3145               /* Create the R_386_32 relocation referencing the GOT
3146                  for this PLT entry.  */
3147
3148               /* S: Current slot number (zero-based).  */
3149               s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3150               /* K: Number of relocations for PLTResolve. */
3151               if (info->shared)
3152                 k = PLTRESOLVE_RELOCS_SHLIB;
3153               else
3154                 k = PLTRESOLVE_RELOCS;
3155               /* Skip the PLTresolve relocations, and the relocations for
3156                  the other PLT slots. */
3157               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3158               loc = (htab->srelplt2->contents + reloc_index
3159                      * sizeof (Elf32_External_Rel));
3160
3161               rel.r_offset = (htab->splt->output_section->vma
3162                               + htab->splt->output_offset
3163                               + h->plt.offset + 2),
3164               rel.r_info = ELF32_R_INFO (htab->hgot->indx, R_386_32);
3165               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3166
3167               /* Create the R_386_32 relocation referencing the beginning of
3168                  the PLT for this GOT entry.  */
3169               rel.r_offset = (htab->sgotplt->output_section->vma
3170                               + htab->sgotplt->output_offset
3171                               + got_offset);
3172               rel.r_info = ELF32_R_INFO (htab->hplt->indx, R_386_32);
3173               bfd_elf32_swap_reloc_out (output_bfd, &rel,
3174               loc + sizeof (Elf32_External_Rel));
3175             }
3176         }
3177       else
3178         {
3179           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3180                   PLT_ENTRY_SIZE);
3181           bfd_put_32 (output_bfd, got_offset,
3182                       htab->splt->contents + h->plt.offset + 2);
3183         }
3184
3185       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3186                   htab->splt->contents + h->plt.offset + 7);
3187       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3188                   htab->splt->contents + h->plt.offset + 12);
3189
3190       /* Fill in the entry in the global offset table.  */
3191       bfd_put_32 (output_bfd,
3192                   (htab->splt->output_section->vma
3193                    + htab->splt->output_offset
3194                    + h->plt.offset
3195                    + 6),
3196                   htab->sgotplt->contents + got_offset);
3197
3198       /* Fill in the entry in the .rel.plt section.  */
3199       rel.r_offset = (htab->sgotplt->output_section->vma
3200                       + htab->sgotplt->output_offset
3201                       + got_offset);
3202       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3203       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3204       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3205
3206       if (!h->def_regular)
3207         {
3208           /* Mark the symbol as undefined, rather than as defined in
3209              the .plt section.  Leave the value if there were any
3210              relocations where pointer equality matters (this is a clue
3211              for the dynamic linker, to make function pointer
3212              comparisons work between an application and shared
3213              library), otherwise set it to zero.  If a function is only
3214              called from a binary, there is no need to slow down
3215              shared libraries because of that.  */
3216           sym->st_shndx = SHN_UNDEF;
3217           if (!h->pointer_equality_needed)
3218             sym->st_value = 0;
3219         }
3220     }
3221
3222   if (h->got.offset != (bfd_vma) -1
3223       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
3224       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3225     {
3226       Elf_Internal_Rela rel;
3227       bfd_byte *loc;
3228
3229       /* This symbol has an entry in the global offset table.  Set it
3230          up.  */
3231
3232       if (htab->sgot == NULL || htab->srelgot == NULL)
3233         abort ();
3234
3235       rel.r_offset = (htab->sgot->output_section->vma
3236                       + htab->sgot->output_offset
3237                       + (h->got.offset & ~(bfd_vma) 1));
3238
3239       /* If this is a static link, or it is a -Bsymbolic link and the
3240          symbol is defined locally or was forced to be local because
3241          of a version file, we just want to emit a RELATIVE reloc.
3242          The entry in the global offset table will already have been
3243          initialized in the relocate_section function.  */
3244       if (info->shared
3245           && SYMBOL_REFERENCES_LOCAL (info, h))
3246         {
3247           BFD_ASSERT((h->got.offset & 1) != 0);
3248           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3249         }
3250       else
3251         {
3252           BFD_ASSERT((h->got.offset & 1) == 0);
3253           bfd_put_32 (output_bfd, (bfd_vma) 0,
3254                       htab->sgot->contents + h->got.offset);
3255           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3256         }
3257
3258       loc = htab->srelgot->contents;
3259       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3260       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3261     }
3262
3263   if (h->needs_copy)
3264     {
3265       Elf_Internal_Rela rel;
3266       bfd_byte *loc;
3267
3268       /* This symbol needs a copy reloc.  Set it up.  */
3269
3270       if (h->dynindx == -1
3271           || (h->root.type != bfd_link_hash_defined
3272               && h->root.type != bfd_link_hash_defweak)
3273           || htab->srelbss == NULL)
3274         abort ();
3275
3276       rel.r_offset = (h->root.u.def.value
3277                       + h->root.u.def.section->output_section->vma
3278                       + h->root.u.def.section->output_offset);
3279       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3280       loc = htab->srelbss->contents;
3281       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3282       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3283     }
3284
3285   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3286      On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3287      is relative to the ".got" section.  */
3288   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3289       || (strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3290           && !htab->is_vxworks))
3291     sym->st_shndx = SHN_ABS;
3292
3293   return TRUE;
3294 }
3295
3296 /* Used to decide how to sort relocs in an optimal manner for the
3297    dynamic linker, before writing them out.  */
3298
3299 static enum elf_reloc_type_class
3300 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3301 {
3302   switch (ELF32_R_TYPE (rela->r_info))
3303     {
3304     case R_386_RELATIVE:
3305       return reloc_class_relative;
3306     case R_386_JUMP_SLOT:
3307       return reloc_class_plt;
3308     case R_386_COPY:
3309       return reloc_class_copy;
3310     default:
3311       return reloc_class_normal;
3312     }
3313 }
3314
3315 /* Finish up the dynamic sections.  */
3316
3317 static bfd_boolean
3318 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3319                                   struct bfd_link_info *info)
3320 {
3321   struct elf_i386_link_hash_table *htab;
3322   bfd *dynobj;
3323   asection *sdyn;
3324
3325   htab = elf_i386_hash_table (info);
3326   dynobj = htab->elf.dynobj;
3327   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3328
3329   if (htab->elf.dynamic_sections_created)
3330     {
3331       Elf32_External_Dyn *dyncon, *dynconend;
3332
3333       if (sdyn == NULL || htab->sgot == NULL)
3334         abort ();
3335
3336       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3337       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3338       for (; dyncon < dynconend; dyncon++)
3339         {
3340           Elf_Internal_Dyn dyn;
3341           asection *s;
3342
3343           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3344
3345           switch (dyn.d_tag)
3346             {
3347             default:
3348               continue;
3349
3350             case DT_PLTGOT:
3351               s = htab->sgotplt;
3352               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3353               break;
3354
3355             case DT_JMPREL:
3356               s = htab->srelplt;
3357               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3358               break;
3359
3360             case DT_PLTRELSZ:
3361               s = htab->srelplt;
3362               dyn.d_un.d_val = s->size;
3363               break;
3364
3365             case DT_RELSZ:
3366               /* My reading of the SVR4 ABI indicates that the
3367                  procedure linkage table relocs (DT_JMPREL) should be
3368                  included in the overall relocs (DT_REL).  This is
3369                  what Solaris does.  However, UnixWare can not handle
3370                  that case.  Therefore, we override the DT_RELSZ entry
3371                  here to make it not include the JMPREL relocs.  */
3372               s = htab->srelplt;
3373               if (s == NULL)
3374                 continue;
3375               dyn.d_un.d_val -= s->size;
3376               break;
3377
3378             case DT_REL:
3379               /* We may not be using the standard ELF linker script.
3380                  If .rel.plt is the first .rel section, we adjust
3381                  DT_REL to not include it.  */
3382               s = htab->srelplt;
3383               if (s == NULL)
3384                 continue;
3385               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3386                 continue;
3387               dyn.d_un.d_ptr += s->size;
3388               break;
3389             }
3390
3391           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3392         }
3393
3394       /* Fill in the first entry in the procedure linkage table.  */
3395       if (htab->splt && htab->splt->size > 0)
3396         {
3397           if (info->shared)
3398             {
3399               memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3400                       sizeof (elf_i386_pic_plt0_entry));
3401               memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3402                       htab->plt0_pad_byte,
3403                       PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3404             }
3405           else
3406             {
3407               memcpy (htab->splt->contents, elf_i386_plt0_entry,
3408                       sizeof(elf_i386_plt0_entry));
3409               memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3410                       htab->plt0_pad_byte,
3411                       PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
3412               bfd_put_32 (output_bfd,
3413                           (htab->sgotplt->output_section->vma
3414                            + htab->sgotplt->output_offset
3415                            + 4),
3416                           htab->splt->contents + 2);
3417               bfd_put_32 (output_bfd,
3418                           (htab->sgotplt->output_section->vma
3419                            + htab->sgotplt->output_offset
3420                            + 8),
3421                           htab->splt->contents + 8);
3422
3423               if (htab->is_vxworks)
3424                 {
3425                   Elf_Internal_Rela rel;
3426                   struct elf_link_hash_entry *hgot;
3427
3428                   /* The VxWorks GOT is relocated by the dynamic linker.
3429                      Therefore, we must emit relocations rather than
3430                      simply computing the values now.  */
3431                   hgot = elf_link_hash_lookup (elf_hash_table (info),
3432                                                "_GLOBAL_OFFSET_TABLE_",
3433                                                FALSE, FALSE, FALSE);
3434                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3435                      On IA32 we use REL relocations so the addend goes in
3436                      the PLT directly.  */
3437                   rel.r_offset = (htab->splt->output_section->vma
3438                                   + htab->splt->output_offset
3439                                   + 2);
3440                   rel.r_info = ELF32_R_INFO (hgot->indx, R_386_32);
3441                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3442                                             htab->srelplt2->contents);
3443                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
3444                   rel.r_offset = (htab->splt->output_section->vma
3445                                   + htab->splt->output_offset
3446                                   + 8);
3447                   rel.r_info = ELF32_R_INFO (hgot->indx, R_386_32);
3448                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3449                                             htab->srelplt2->contents +
3450                                             sizeof (Elf32_External_Rel));
3451                 }
3452             }
3453
3454           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3455              really seem like the right value.  */
3456           elf_section_data (htab->splt->output_section)
3457             ->this_hdr.sh_entsize = 4;
3458
3459           /* Correct the .rel.plt.unloaded relocations.  */
3460           if (htab->is_vxworks && !info->shared)
3461             {
3462               int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
3463               unsigned char *p;
3464
3465               p = htab->srelplt2->contents;
3466               if (info->shared)
3467                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
3468               else
3469                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
3470
3471               for (; num_plts; num_plts--)
3472                 {
3473                   Elf_Internal_Rela rel;
3474                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3475                   rel.r_info = ELF32_R_INFO (htab->hgot->indx, R_386_32);
3476                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3477                   p += sizeof (Elf32_External_Rel);
3478
3479                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3480                   rel.r_info = ELF32_R_INFO (htab->hplt->indx, R_386_32);
3481                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3482                   p += sizeof (Elf32_External_Rel);
3483                 }
3484             }
3485         }
3486     }
3487
3488   if (htab->sgotplt)
3489     {
3490       /* Fill in the first three entries in the global offset table.  */
3491       if (htab->sgotplt->size > 0)
3492         {
3493           bfd_put_32 (output_bfd,
3494                       (sdyn == NULL ? 0
3495                        : sdyn->output_section->vma + sdyn->output_offset),
3496                       htab->sgotplt->contents);
3497           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3498           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3499         }
3500
3501       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3502     }
3503
3504   if (htab->sgot && htab->sgot->size > 0)
3505     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3506
3507   return TRUE;
3508 }
3509
3510 /* Return address for Ith PLT stub in section PLT, for relocation REL
3511    or (bfd_vma) -1 if it should not be included.  */
3512
3513 static bfd_vma
3514 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
3515                       const arelent *rel ATTRIBUTE_UNUSED)
3516 {
3517   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3518 }
3519
3520
3521 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3522 #define TARGET_LITTLE_NAME              "elf32-i386"
3523 #define ELF_ARCH                        bfd_arch_i386
3524 #define ELF_MACHINE_CODE                EM_386
3525 #define ELF_MAXPAGESIZE                 0x1000
3526
3527 #define elf_backend_can_gc_sections     1
3528 #define elf_backend_can_refcount        1
3529 #define elf_backend_want_got_plt        1
3530 #define elf_backend_plt_readonly        1
3531 #define elf_backend_want_plt_sym        0
3532 #define elf_backend_got_header_size     12
3533
3534 /* Support RELA for objdump of prelink objects.  */
3535 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3536 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3537
3538 #define bfd_elf32_mkobject                    elf_i386_mkobject
3539
3540 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3541 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3542 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3543
3544 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3545 #define elf_backend_check_relocs              elf_i386_check_relocs
3546 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3547 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3548 #define elf_backend_fake_sections             elf_i386_fake_sections
3549 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3550 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3551 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3552 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3553 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3554 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3555 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3556 #define elf_backend_relocate_section          elf_i386_relocate_section
3557 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3558 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
3559
3560 #include "elf32-target.h"
3561
3562 /* FreeBSD support.  */
3563
3564 #undef  TARGET_LITTLE_SYM
3565 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3566 #undef  TARGET_LITTLE_NAME
3567 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3568
3569 /* The kernel recognizes executables as valid only if they carry a
3570    "FreeBSD" label in the ELF header.  So we put this label on all
3571    executables and (for simplicity) also all other object files.  */
3572
3573 static void
3574 elf_i386_post_process_headers (bfd *abfd,
3575                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3576 {
3577   Elf_Internal_Ehdr *i_ehdrp;
3578
3579   i_ehdrp = elf_elfheader (abfd);
3580
3581   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3582   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3583 #ifdef OLD_FREEBSD_ABI_LABEL
3584   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3585   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3586 #endif
3587 }
3588
3589 #undef  elf_backend_post_process_headers
3590 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3591 #undef  elf32_bed
3592 #define elf32_bed                               elf32_i386_fbsd_bed
3593
3594 #include "elf32-target.h"
3595
3596 /* VxWorks support.  */
3597
3598 #undef  TARGET_LITTLE_SYM
3599 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
3600 #undef  TARGET_LITTLE_NAME
3601 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
3602
3603
3604 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks.  */
3605
3606 static struct bfd_link_hash_table *
3607 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3608 {
3609   struct bfd_link_hash_table *ret;
3610   struct elf_i386_link_hash_table *htab;
3611
3612   ret = elf_i386_link_hash_table_create (abfd);
3613   if (ret)
3614     {
3615       htab = (struct elf_i386_link_hash_table *) ret;
3616       htab->is_vxworks = 1;
3617       htab->plt0_pad_byte = 0x90;
3618     }
3619
3620   return ret;
3621 }
3622
3623
3624 /* Tweak magic VxWorks symbols as they are written to the output file.  */
3625 static bfd_boolean
3626 elf_i386_vxworks_link_output_symbol_hook (struct bfd_link_info *info
3627                                             ATTRIBUTE_UNUSED,
3628                                           const char *name,
3629                                           Elf_Internal_Sym *sym,
3630                                           asection *input_sec ATTRIBUTE_UNUSED,
3631                                           struct elf_link_hash_entry *h
3632                                             ATTRIBUTE_UNUSED)
3633 {
3634   /* Ignore the first dummy symbol.  */
3635   if (!name)
3636     return TRUE;
3637
3638   return elf_vxworks_link_output_symbol_hook (name, sym);
3639 }
3640
3641 #undef  elf_backend_post_process_headers
3642 #undef bfd_elf32_bfd_link_hash_table_create
3643 #define bfd_elf32_bfd_link_hash_table_create \
3644   elf_i386_vxworks_link_hash_table_create
3645 #undef elf_backend_add_symbol_hook
3646 #define elf_backend_add_symbol_hook \
3647   elf_vxworks_add_symbol_hook
3648 #undef elf_backend_link_output_symbol_hook
3649 #define elf_backend_link_output_symbol_hook \
3650   elf_i386_vxworks_link_output_symbol_hook
3651 #undef elf_backend_emit_relocs
3652 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
3653 #undef elf_backend_final_write_processing
3654 #define elf_backend_final_write_processing \
3655   elf_vxworks_final_write_processing
3656
3657 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3658    define it.  */
3659 #undef elf_backend_want_plt_sym
3660 #define elf_backend_want_plt_sym        1
3661
3662 #undef  elf32_bed
3663 #define elf32_bed                               elf32_i386_vxworks_bed
3664
3665 #include "elf32-target.h"