bfd/elf32-i386.c

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