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         {
1919           /* Strip this section if we don't need it; see the
1920              comment below.  */
1921           /* We'd like to strip these sections if they aren't needed, but if
1922              we've exported dynamic symbols from them we must leave them.
1923              It's too late to tell BFD to get rid of the symbols.  */
1924
1925           if (htab->hplt != NULL)
1926             strip_section = FALSE;
1927         }
1928       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1929         {
1930           if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
1931             relocs = TRUE;
1932
1933           /* We use the reloc_count field as a counter if we need
1934              to copy relocs into the output file.  */
1935           s->reloc_count = 0;
1936         }
1937       else
1938         {
1939           /* It's not one of our sections, so don't allocate space.  */
1940           continue;
1941         }
1942
1943       if (s->size == 0 && strip_section)
1944         {
1945           /* If we don't need this section, strip it from the
1946              output file.  This is mostly to handle .rel.bss and
1947              .rel.plt.  We must create both sections in
1948              create_dynamic_sections, because they must be created
1949              before the linker maps input sections to output
1950              sections.  The linker does that before
1951              adjust_dynamic_symbol is called, and it is that
1952              function which decides whether anything needs to go
1953              into these sections.  */
1954
1955           s->flags |= SEC_EXCLUDE;
1956           continue;
1957         }
1958
1959       /* Allocate memory for the section contents.  We use bfd_zalloc
1960          here in case unused entries are not reclaimed before the
1961          section's contents are written out.  This should not happen,
1962          but this way if it does, we get a R_386_NONE reloc instead
1963          of garbage.  */
1964       s->contents = bfd_zalloc (dynobj, s->size);
1965       if (s->contents == NULL)
1966         return FALSE;
1967     }
1968
1969   if (htab->elf.dynamic_sections_created)
1970     {
1971       /* Add some entries to the .dynamic section.  We fill in the
1972          values later, in elf_i386_finish_dynamic_sections, but we
1973          must add the entries now so that we get the correct size for
1974          the .dynamic section.  The DT_DEBUG entry is filled in by the
1975          dynamic linker and used by the debugger.  */
1976 #define add_dynamic_entry(TAG, VAL) \
1977   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1978
1979       if (info->executable)
1980         {
1981           if (!add_dynamic_entry (DT_DEBUG, 0))
1982             return FALSE;
1983         }
1984
1985       if (htab->splt->size != 0)
1986         {
1987           if (!add_dynamic_entry (DT_PLTGOT, 0)
1988               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1989               || !add_dynamic_entry (DT_PLTREL, DT_REL)
1990               || !add_dynamic_entry (DT_JMPREL, 0))
1991             return FALSE;
1992         }
1993
1994       if (relocs)
1995         {
1996           if (!add_dynamic_entry (DT_REL, 0)
1997               || !add_dynamic_entry (DT_RELSZ, 0)
1998               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1999             return FALSE;
2000
2001           /* If any dynamic relocs apply to a read-only section,
2002              then we need a DT_TEXTREL entry.  */
2003           if ((info->flags & DF_TEXTREL) == 0)
2004             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2005                                     (PTR) info);
2006
2007           if ((info->flags & DF_TEXTREL) != 0)
2008             {
2009               if (!add_dynamic_entry (DT_TEXTREL, 0))
2010                 return FALSE;
2011             }
2012         }
2013     }
2014 #undef add_dynamic_entry
2015
2016   return TRUE;
2017 }
2018
2019 /* Set the correct type for an x86 ELF section.  We do this by the
2020    section name, which is a hack, but ought to work.  */
2021
2022 static bfd_boolean
2023 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2024                         Elf_Internal_Shdr *hdr,
2025                         asection *sec)
2026 {
2027   register const char *name;
2028
2029   name = bfd_get_section_name (abfd, sec);
2030
2031   /* This is an ugly, but unfortunately necessary hack that is
2032      needed when producing EFI binaries on x86. It tells
2033      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2034      containing ELF relocation info.  We need this hack in order to
2035      be able to generate ELF binaries that can be translated into
2036      EFI applications (which are essentially COFF objects).  Those
2037      files contain a COFF ".reloc" section inside an ELFNN object,
2038      which would normally cause BFD to segfault because it would
2039      attempt to interpret this section as containing relocation
2040      entries for section "oc".  With this hack enabled, ".reloc"
2041      will be treated as a normal data section, which will avoid the
2042      segfault.  However, you won't be able to create an ELFNN binary
2043      with a section named "oc" that needs relocations, but that's
2044      the kind of ugly side-effects you get when detecting section
2045      types based on their names...  In practice, this limitation is
2046      unlikely to bite.  */
2047   if (strcmp (name, ".reloc") == 0)
2048     hdr->sh_type = SHT_PROGBITS;
2049
2050   return TRUE;
2051 }
2052
2053 /* Return the base VMA address which should be subtracted from real addresses
2054    when resolving @dtpoff relocation.
2055    This is PT_TLS segment p_vaddr.  */
2056
2057 static bfd_vma
2058 dtpoff_base (struct bfd_link_info *info)
2059 {
2060   /* If tls_sec is NULL, we should have signalled an error already.  */
2061   if (elf_hash_table (info)->tls_sec == NULL)
2062     return 0;
2063   return elf_hash_table (info)->tls_sec->vma;
2064 }
2065
2066 /* Return the relocation value for @tpoff relocation
2067    if STT_TLS virtual address is ADDRESS.  */
2068
2069 static bfd_vma
2070 tpoff (struct bfd_link_info *info, bfd_vma address)
2071 {
2072   struct elf_link_hash_table *htab = elf_hash_table (info);
2073
2074   /* If tls_sec is NULL, we should have signalled an error already.  */
2075   if (htab->tls_sec == NULL)
2076     return 0;
2077   return htab->tls_size + htab->tls_sec->vma - address;
2078 }
2079
2080 /* Relocate an i386 ELF section.  */
2081
2082 static bfd_boolean
2083 elf_i386_relocate_section (bfd *output_bfd,
2084                            struct bfd_link_info *info,
2085                            bfd *input_bfd,
2086                            asection *input_section,
2087                            bfd_byte *contents,
2088                            Elf_Internal_Rela *relocs,
2089                            Elf_Internal_Sym *local_syms,
2090                            asection **local_sections)
2091 {
2092   struct elf_i386_link_hash_table *htab;
2093   Elf_Internal_Shdr *symtab_hdr;
2094   struct elf_link_hash_entry **sym_hashes;
2095   bfd_vma *local_got_offsets;
2096   Elf_Internal_Rela *rel;
2097   Elf_Internal_Rela *relend;
2098
2099   htab = elf_i386_hash_table (info);
2100   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2101   sym_hashes = elf_sym_hashes (input_bfd);
2102   local_got_offsets = elf_local_got_offsets (input_bfd);
2103
2104   rel = relocs;
2105   relend = relocs + input_section->reloc_count;
2106   for (; rel < relend; rel++)
2107     {
2108       unsigned int r_type;
2109       reloc_howto_type *howto;
2110       unsigned long r_symndx;
2111       struct elf_link_hash_entry *h;
2112       Elf_Internal_Sym *sym;
2113       asection *sec;
2114       bfd_vma off;
2115       bfd_vma relocation;
2116       bfd_boolean unresolved_reloc;
2117       bfd_reloc_status_type r;
2118       unsigned int indx;
2119       int tls_type;
2120
2121       r_type = ELF32_R_TYPE (rel->r_info);
2122       if (r_type == R_386_GNU_VTINHERIT
2123           || r_type == R_386_GNU_VTENTRY)
2124         continue;
2125
2126       if ((indx = r_type) >= R_386_standard
2127           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2128               >= R_386_ext - R_386_standard)
2129           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2130               >= R_386_tls - R_386_ext))
2131         {
2132           (*_bfd_error_handler)
2133             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2134              input_bfd, input_section, r_type);
2135           bfd_set_error (bfd_error_bad_value);
2136           return FALSE;
2137         }
2138       howto = elf_howto_table + indx;
2139
2140       r_symndx = ELF32_R_SYM (rel->r_info);
2141
2142       if (info->relocatable)
2143         {
2144           bfd_vma val;
2145           bfd_byte *where;
2146
2147           /* This is a relocatable link.  We don't have to change
2148              anything, unless the reloc is against a section symbol,
2149              in which case we have to adjust according to where the
2150              section symbol winds up in the output section.  */
2151           if (r_symndx >= symtab_hdr->sh_info)
2152             continue;
2153
2154           sym = local_syms + r_symndx;
2155           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2156             continue;
2157
2158           sec = local_sections[r_symndx];
2159           val = sec->output_offset;
2160           if (val == 0)
2161             continue;
2162
2163           where = contents + rel->r_offset;
2164           switch (howto->size)
2165             {
2166               /* FIXME: overflow checks.  */
2167             case 0:
2168               val += bfd_get_8 (input_bfd, where);
2169               bfd_put_8 (input_bfd, val, where);
2170               break;
2171             case 1:
2172               val += bfd_get_16 (input_bfd, where);
2173               bfd_put_16 (input_bfd, val, where);
2174               break;
2175             case 2:
2176               val += bfd_get_32 (input_bfd, where);
2177               bfd_put_32 (input_bfd, val, where);
2178               break;
2179             default:
2180               abort ();
2181             }
2182           continue;
2183         }
2184
2185       /* This is a final link.  */
2186       h = NULL;
2187       sym = NULL;
2188       sec = NULL;
2189       unresolved_reloc = FALSE;
2190       if (r_symndx < symtab_hdr->sh_info)
2191         {
2192           sym = local_syms + r_symndx;
2193           sec = local_sections[r_symndx];
2194           relocation = (sec->output_section->vma
2195                         + sec->output_offset
2196                         + sym->st_value);
2197           if ((sec->flags & SEC_MERGE)
2198               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2199             {
2200               asection *msec;
2201               bfd_vma addend;
2202               bfd_byte *where = contents + rel->r_offset;
2203
2204               switch (howto->size)
2205                 {
2206                 case 0:
2207                   addend = bfd_get_8 (input_bfd, where);
2208                   if (howto->pc_relative)
2209                     {
2210                       addend = (addend ^ 0x80) - 0x80;
2211                       addend += 1;
2212                     }
2213                   break;
2214                 case 1:
2215                   addend = bfd_get_16 (input_bfd, where);
2216                   if (howto->pc_relative)
2217                     {
2218                       addend = (addend ^ 0x8000) - 0x8000;
2219                       addend += 2;
2220                     }
2221                   break;
2222                 case 2:
2223                   addend = bfd_get_32 (input_bfd, where);
2224                   if (howto->pc_relative)
2225                     {
2226                       addend = (addend ^ 0x80000000) - 0x80000000;
2227                       addend += 4;
2228                     }
2229                   break;
2230                 default:
2231                   abort ();
2232                 }
2233
2234               msec = sec;
2235               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2236               addend -= relocation;
2237               addend += msec->output_section->vma + msec->output_offset;
2238
2239               switch (howto->size)
2240                 {
2241                 case 0:
2242                   /* FIXME: overflow checks.  */
2243                   if (howto->pc_relative)
2244                     addend -= 1;
2245                   bfd_put_8 (input_bfd, addend, where);
2246                   break;
2247                 case 1:
2248                   if (howto->pc_relative)
2249                     addend -= 2;
2250                   bfd_put_16 (input_bfd, addend, where);
2251                   break;
2252                 case 2:
2253                   if (howto->pc_relative)
2254                     addend -= 4;
2255                   bfd_put_32 (input_bfd, addend, where);
2256                   break;
2257                 }
2258             }
2259         }
2260       else
2261         {
2262           bfd_boolean warned;
2263
2264           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2265                                    r_symndx, symtab_hdr, sym_hashes,
2266                                    h, sec, relocation,
2267                                    unresolved_reloc, warned);
2268         }
2269
2270       switch (r_type)
2271         {
2272         case R_386_GOT32:
2273           /* Relocation is to the entry for this symbol in the global
2274              offset table.  */
2275           if (htab->sgot == NULL)
2276             abort ();
2277
2278           if (h != NULL)
2279             {
2280               bfd_boolean dyn;
2281
2282               off = h->got.offset;
2283               dyn = htab->elf.dynamic_sections_created;
2284               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2285                   || (info->shared
2286                       && SYMBOL_REFERENCES_LOCAL (info, h))
2287                   || (ELF_ST_VISIBILITY (h->other)
2288                       && h->root.type == bfd_link_hash_undefweak))
2289                 {
2290                   /* This is actually a static link, or it is a
2291                      -Bsymbolic link and the symbol is defined
2292                      locally, or the symbol was forced to be local
2293                      because of a version file.  We must initialize
2294                      this entry in the global offset table.  Since the
2295                      offset must always be a multiple of 4, we use the
2296                      least significant bit to record whether we have
2297                      initialized it already.
2298
2299                      When doing a dynamic link, we create a .rel.got
2300                      relocation entry to initialize the value.  This
2301                      is done in the finish_dynamic_symbol routine.  */
2302                   if ((off & 1) != 0)
2303                     off &= ~1;
2304                   else
2305                     {
2306                       bfd_put_32 (output_bfd, relocation,
2307                                   htab->sgot->contents + off);
2308                       h->got.offset |= 1;
2309                     }
2310                 }
2311               else
2312                 unresolved_reloc = FALSE;
2313             }
2314           else
2315             {
2316               if (local_got_offsets == NULL)
2317                 abort ();
2318
2319               off = local_got_offsets[r_symndx];
2320
2321               /* The offset must always be a multiple of 4.  We use
2322                  the least significant bit to record whether we have
2323                  already generated the necessary reloc.  */
2324               if ((off & 1) != 0)
2325                 off &= ~1;
2326               else
2327                 {
2328                   bfd_put_32 (output_bfd, relocation,
2329                               htab->sgot->contents + off);
2330
2331                   if (info->shared)
2332                     {
2333                       asection *s;
2334                       Elf_Internal_Rela outrel;
2335                       bfd_byte *loc;
2336
2337                       s = htab->srelgot;
2338                       if (s == NULL)
2339                         abort ();
2340
2341                       outrel.r_offset = (htab->sgot->output_section->vma
2342                                          + htab->sgot->output_offset
2343                                          + off);
2344                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2345                       loc = s->contents;
2346                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2347                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2348                     }
2349
2350                   local_got_offsets[r_symndx] |= 1;
2351                 }
2352             }
2353
2354           if (off >= (bfd_vma) -2)
2355             abort ();
2356
2357           relocation = htab->sgot->output_section->vma
2358                        + htab->sgot->output_offset + off
2359                        - htab->sgotplt->output_section->vma
2360                        - htab->sgotplt->output_offset;
2361           break;
2362
2363         case R_386_GOTOFF:
2364           /* Relocation is relative to the start of the global offset
2365              table.  */
2366
2367           /* Check to make sure it isn't a protected function symbol
2368              for shared library since it may not be local when used
2369              as function address.  */
2370           if (info->shared
2371               && !info->executable
2372               && h
2373               && h->def_regular
2374               && h->type == STT_FUNC
2375               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2376             {
2377               (*_bfd_error_handler)
2378                 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2379                  input_bfd, h->root.root.string);
2380               bfd_set_error (bfd_error_bad_value);
2381               return FALSE;
2382             }
2383
2384           /* Note that sgot is not involved in this
2385              calculation.  We always want the start of .got.plt.  If we
2386              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2387              permitted by the ABI, we might have to change this
2388              calculation.  */
2389           relocation -= htab->sgotplt->output_section->vma
2390                         + htab->sgotplt->output_offset;
2391           break;
2392
2393         case R_386_GOTPC:
2394           /* Use global offset table as symbol value.  */
2395           relocation = htab->sgotplt->output_section->vma
2396                        + htab->sgotplt->output_offset;
2397           unresolved_reloc = FALSE;
2398           break;
2399
2400         case R_386_PLT32:
2401           /* Relocation is to the entry for this symbol in the
2402              procedure linkage table.  */
2403
2404           /* Resolve a PLT32 reloc against a local symbol directly,
2405              without using the procedure linkage table.  */
2406           if (h == NULL)
2407             break;
2408
2409           if (h->plt.offset == (bfd_vma) -1
2410               || htab->splt == NULL)
2411             {
2412               /* We didn't make a PLT entry for this symbol.  This
2413                  happens when statically linking PIC code, or when
2414                  using -Bsymbolic.  */
2415               break;
2416             }
2417
2418           relocation = (htab->splt->output_section->vma
2419                         + htab->splt->output_offset
2420                         + h->plt.offset);
2421           unresolved_reloc = FALSE;
2422           break;
2423
2424         case R_386_32:
2425         case R_386_PC32:
2426           /* r_symndx will be zero only for relocs against symbols
2427              from removed linkonce sections, or sections discarded by
2428              a linker script.  */
2429           if (r_symndx == 0)
2430             {
2431               /* Zero the section contents.  eh_frame generated by old
2432                  versions of gcc isn't edited by elf-eh-frame.c, so
2433                  FDEs for discarded linkonce functions might remain.
2434                  Putting zeros here will zero such FDE's address range.
2435                  This is a hint to unwinders and other consumers of
2436                  exception handling info that the FDE is invalid.  */
2437               bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2438               break;
2439             }
2440
2441           if ((input_section->flags & SEC_ALLOC) == 0)
2442             break;
2443
2444           if ((info->shared
2445                && (h == NULL
2446                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2447                    || h->root.type != bfd_link_hash_undefweak)
2448                && (r_type != R_386_PC32
2449                    || !SYMBOL_CALLS_LOCAL (info, h)))
2450               || (ELIMINATE_COPY_RELOCS
2451                   && !info->shared
2452                   && h != NULL
2453                   && h->dynindx != -1
2454                   && !h->non_got_ref
2455                   && ((h->def_dynamic
2456                        && !h->def_regular)
2457                       || h->root.type == bfd_link_hash_undefweak
2458                       || h->root.type == bfd_link_hash_undefined)))
2459             {
2460               Elf_Internal_Rela outrel;
2461               bfd_byte *loc;
2462               bfd_boolean skip, relocate;
2463               asection *sreloc;
2464
2465               /* When generating a shared object, these relocations
2466                  are copied into the output file to be resolved at run
2467                  time.  */
2468
2469               skip = FALSE;
2470               relocate = FALSE;
2471
2472               outrel.r_offset =
2473                 _bfd_elf_section_offset (output_bfd, info, input_section,
2474                                          rel->r_offset);
2475               if (outrel.r_offset == (bfd_vma) -1)
2476                 skip = TRUE;
2477               else if (outrel.r_offset == (bfd_vma) -2)
2478                 skip = TRUE, relocate = TRUE;
2479               outrel.r_offset += (input_section->output_section->vma
2480                                   + input_section->output_offset);
2481
2482               if (skip)
2483                 memset (&outrel, 0, sizeof outrel);
2484               else if (h != NULL
2485                        && h->dynindx != -1
2486                        && (r_type == R_386_PC32
2487                            || !info->shared
2488                            || !info->symbolic
2489                            || !h->def_regular))
2490                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2491               else
2492                 {
2493                   /* This symbol is local, or marked to become local.  */
2494                   relocate = TRUE;
2495                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2496                 }
2497
2498               sreloc = elf_section_data (input_section)->sreloc;
2499               if (sreloc == NULL)
2500                 abort ();
2501
2502               loc = sreloc->contents;
2503               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2504               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2505
2506               /* If this reloc is against an external symbol, we do
2507                  not want to fiddle with the addend.  Otherwise, we
2508                  need to include the symbol value so that it becomes
2509                  an addend for the dynamic reloc.  */
2510               if (! relocate)
2511                 continue;
2512             }
2513           break;
2514
2515         case R_386_TLS_IE:
2516           if (info->shared)
2517             {
2518               Elf_Internal_Rela outrel;
2519               bfd_byte *loc;
2520               asection *sreloc;
2521
2522               outrel.r_offset = rel->r_offset
2523                                 + input_section->output_section->vma
2524                                 + input_section->output_offset;
2525               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2526               sreloc = elf_section_data (input_section)->sreloc;
2527               if (sreloc == NULL)
2528                 abort ();
2529               loc = sreloc->contents;
2530               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2531               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2532             }
2533           /* Fall through */
2534
2535         case R_386_TLS_GD:
2536         case R_386_TLS_IE_32:
2537         case R_386_TLS_GOTIE:
2538           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2539           tls_type = GOT_UNKNOWN;
2540           if (h == NULL && local_got_offsets)
2541             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2542           else if (h != NULL)
2543             {
2544               tls_type = elf_i386_hash_entry(h)->tls_type;
2545               if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2546                 r_type = R_386_TLS_LE_32;
2547             }
2548           if (tls_type == GOT_TLS_IE)
2549             tls_type = GOT_TLS_IE_NEG;
2550           if (r_type == R_386_TLS_GD)
2551             {
2552               if (tls_type == GOT_TLS_IE_POS)
2553                 r_type = R_386_TLS_GOTIE;
2554               else if (tls_type & GOT_TLS_IE)
2555                 r_type = R_386_TLS_IE_32;
2556             }
2557
2558           if (r_type == R_386_TLS_LE_32)
2559             {
2560               BFD_ASSERT (! unresolved_reloc);
2561               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2562                 {
2563                   unsigned int val, type;
2564                   bfd_vma roff;
2565
2566                   /* GD->LE transition.  */
2567                   BFD_ASSERT (rel->r_offset >= 2);
2568                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2569                   BFD_ASSERT (type == 0x8d || type == 0x04);
2570                   BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2571                   BFD_ASSERT (bfd_get_8 (input_bfd,
2572                                          contents + rel->r_offset + 4)
2573                               == 0xe8);
2574                   BFD_ASSERT (rel + 1 < relend);
2575                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2576                   roff = rel->r_offset + 5;
2577                   val = bfd_get_8 (input_bfd,
2578                                    contents + rel->r_offset - 1);
2579                   if (type == 0x04)
2580                     {
2581                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2582                          Change it into:
2583                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2584                          (6 byte form of subl).  */
2585                       BFD_ASSERT (rel->r_offset >= 3);
2586                       BFD_ASSERT (bfd_get_8 (input_bfd,
2587                                              contents + rel->r_offset - 3)
2588                                   == 0x8d);
2589                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2590                       memcpy (contents + rel->r_offset - 3,
2591                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2592                     }
2593                   else
2594                     {
2595                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2596                       if (rel->r_offset + 10 <= input_section->size
2597                           && bfd_get_8 (input_bfd,
2598                                         contents + rel->r_offset + 9) == 0x90)
2599                         {
2600                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2601                              Change it into:
2602                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2603                              (6 byte form of subl).  */
2604                           memcpy (contents + rel->r_offset - 2,
2605                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2606                           roff = rel->r_offset + 6;
2607                         }
2608                       else
2609                         {
2610                           /* leal foo(%reg), %eax; call ___tls_get_addr
2611                              Change it into:
2612                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2613                              (5 byte form of subl).  */
2614                           memcpy (contents + rel->r_offset - 2,
2615                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2616                         }
2617                     }
2618                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2619                               contents + roff);
2620                   /* Skip R_386_PLT32.  */
2621                   rel++;
2622                   continue;
2623                 }
2624               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2625                 {
2626                   unsigned int val, type;
2627
2628                   /* IE->LE transition:
2629                      Originally it can be one of:
2630                      movl foo, %eax
2631                      movl foo, %reg
2632                      addl foo, %reg
2633                      We change it into:
2634                      movl $foo, %eax
2635                      movl $foo, %reg
2636                      addl $foo, %reg.  */
2637                   BFD_ASSERT (rel->r_offset >= 1);
2638                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2639                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2640                   if (val == 0xa1)
2641                     {
2642                       /* movl foo, %eax.  */
2643                       bfd_put_8 (output_bfd, 0xb8,
2644                                  contents + rel->r_offset - 1);
2645                     }
2646                   else
2647                     {
2648                       BFD_ASSERT (rel->r_offset >= 2);
2649                       type = bfd_get_8 (input_bfd,
2650                                         contents + rel->r_offset - 2);
2651                       switch (type)
2652                         {
2653                         case 0x8b:
2654                           /* movl */
2655                           BFD_ASSERT ((val & 0xc7) == 0x05);
2656                           bfd_put_8 (output_bfd, 0xc7,
2657                                      contents + rel->r_offset - 2);
2658                           bfd_put_8 (output_bfd,
2659                                      0xc0 | ((val >> 3) & 7),
2660                                      contents + rel->r_offset - 1);
2661                           break;
2662                         case 0x03:
2663                           /* addl */
2664                           BFD_ASSERT ((val & 0xc7) == 0x05);
2665                           bfd_put_8 (output_bfd, 0x81,
2666                                      contents + rel->r_offset - 2);
2667                           bfd_put_8 (output_bfd,
2668                                      0xc0 | ((val >> 3) & 7),
2669                                      contents + rel->r_offset - 1);
2670                           break;
2671                         default:
2672                           BFD_FAIL ();
2673                           break;
2674                         }
2675                     }
2676                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2677                               contents + rel->r_offset);
2678                   continue;
2679                 }
2680               else
2681                 {
2682                   unsigned int val, type;
2683
2684                   /* {IE_32,GOTIE}->LE transition:
2685                      Originally it can be one of:
2686                      subl foo(%reg1), %reg2
2687                      movl foo(%reg1), %reg2
2688                      addl foo(%reg1), %reg2
2689                      We change it into:
2690                      subl $foo, %reg2
2691                      movl $foo, %reg2 (6 byte form)
2692                      addl $foo, %reg2.  */
2693                   BFD_ASSERT (rel->r_offset >= 2);
2694                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2695                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2696                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2697                   BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2698                   if (type == 0x8b)
2699                     {
2700                       /* movl */
2701                       bfd_put_8 (output_bfd, 0xc7,
2702                                  contents + rel->r_offset - 2);
2703                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2704                                  contents + rel->r_offset - 1);
2705                     }
2706                   else if (type == 0x2b)
2707                     {
2708                       /* subl */
2709                       bfd_put_8 (output_bfd, 0x81,
2710                                  contents + rel->r_offset - 2);
2711                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2712                                  contents + rel->r_offset - 1);
2713                     }
2714                   else if (type == 0x03)
2715                     {
2716                       /* addl */
2717                       bfd_put_8 (output_bfd, 0x81,
2718                                  contents + rel->r_offset - 2);
2719                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2720                                  contents + rel->r_offset - 1);
2721                     }
2722                   else
2723                     BFD_FAIL ();
2724                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2725                     bfd_put_32 (output_bfd, -tpoff (info, relocation),
2726                                 contents + rel->r_offset);
2727                   else
2728                     bfd_put_32 (output_bfd, tpoff (info, relocation),
2729                                 contents + rel->r_offset);
2730                   continue;
2731                 }
2732             }
2733
2734           if (htab->sgot == NULL)
2735             abort ();
2736
2737           if (h != NULL)
2738             off = h->got.offset;
2739           else
2740             {
2741               if (local_got_offsets == NULL)
2742                 abort ();
2743
2744               off = local_got_offsets[r_symndx];
2745             }
2746
2747           if ((off & 1) != 0)
2748             off &= ~1;
2749           else
2750             {
2751               Elf_Internal_Rela outrel;
2752               bfd_byte *loc;
2753               int dr_type, indx;
2754
2755               if (htab->srelgot == NULL)
2756                 abort ();
2757
2758               outrel.r_offset = (htab->sgot->output_section->vma
2759                                  + htab->sgot->output_offset + off);
2760
2761               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2762               if (r_type == R_386_TLS_GD)
2763                 dr_type = R_386_TLS_DTPMOD32;
2764               else if (tls_type == GOT_TLS_IE_POS)
2765                 dr_type = R_386_TLS_TPOFF;
2766               else
2767                 dr_type = R_386_TLS_TPOFF32;
2768               if (dr_type == R_386_TLS_TPOFF && indx == 0)
2769                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2770                             htab->sgot->contents + off);
2771               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2772                 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
2773                             htab->sgot->contents + off);
2774               else
2775                 bfd_put_32 (output_bfd, 0,
2776                             htab->sgot->contents + off);
2777               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2778               loc = htab->srelgot->contents;
2779               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2780               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2781
2782               if (r_type == R_386_TLS_GD)
2783                 {
2784                   if (indx == 0)
2785                     {
2786                       BFD_ASSERT (! unresolved_reloc);
2787                       bfd_put_32 (output_bfd,
2788                                   relocation - dtpoff_base (info),
2789                                   htab->sgot->contents + off + 4);
2790                     }
2791                   else
2792                     {
2793                       bfd_put_32 (output_bfd, 0,
2794                                   htab->sgot->contents + off + 4);
2795                       outrel.r_info = ELF32_R_INFO (indx,
2796                                                     R_386_TLS_DTPOFF32);
2797                       outrel.r_offset += 4;
2798                       htab->srelgot->reloc_count++;
2799                       loc += sizeof (Elf32_External_Rel);
2800                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2801                     }
2802                 }
2803               else if (tls_type == GOT_TLS_IE_BOTH)
2804                 {
2805                   bfd_put_32 (output_bfd,
2806                               indx == 0 ? relocation - dtpoff_base (info) : 0,
2807                               htab->sgot->contents + off + 4);
2808                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2809                   outrel.r_offset += 4;
2810                   htab->srelgot->reloc_count++;
2811                   loc += sizeof (Elf32_External_Rel);
2812                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2813                 }
2814
2815               if (h != NULL)
2816                 h->got.offset |= 1;
2817               else
2818                 local_got_offsets[r_symndx] |= 1;
2819             }
2820
2821           if (off >= (bfd_vma) -2)
2822             abort ();
2823           if (r_type == ELF32_R_TYPE (rel->r_info))
2824             {
2825               bfd_vma g_o_t = htab->sgotplt->output_section->vma
2826                               + htab->sgotplt->output_offset;
2827               relocation = htab->sgot->output_section->vma
2828                            + htab->sgot->output_offset + off - g_o_t;
2829               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2830                   && tls_type == GOT_TLS_IE_BOTH)
2831                 relocation += 4;
2832               if (r_type == R_386_TLS_IE)
2833                 relocation += g_o_t;
2834               unresolved_reloc = FALSE;
2835             }
2836           else
2837             {
2838               unsigned int val, type;
2839               bfd_vma roff;
2840
2841               /* GD->IE transition.  */
2842               BFD_ASSERT (rel->r_offset >= 2);
2843               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2844               BFD_ASSERT (type == 0x8d || type == 0x04);
2845               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2846               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2847                           == 0xe8);
2848               BFD_ASSERT (rel + 1 < relend);
2849               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2850               roff = rel->r_offset - 3;
2851               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2852               if (type == 0x04)
2853                 {
2854                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2855                      Change it into:
2856                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2857                   BFD_ASSERT (rel->r_offset >= 3);
2858                   BFD_ASSERT (bfd_get_8 (input_bfd,
2859                                          contents + rel->r_offset - 3)
2860                               == 0x8d);
2861                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2862                   val >>= 3;
2863                 }
2864               else
2865                 {
2866                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2867                      Change it into:
2868                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2869                   BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
2870                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2871                   BFD_ASSERT (bfd_get_8 (input_bfd,
2872                                          contents + rel->r_offset + 9)
2873                               == 0x90);
2874                   roff = rel->r_offset - 2;
2875                 }
2876               memcpy (contents + roff,
2877                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2878               contents[roff + 7] = 0x80 | (val & 7);
2879               /* If foo is used only with foo@gotntpoff(%reg) and
2880                  foo@indntpoff, but not with foo@gottpoff(%reg), change
2881                  subl $foo@gottpoff(%reg), %eax
2882                  into:
2883                  addl $foo@gotntpoff(%reg), %eax.  */
2884               if (r_type == R_386_TLS_GOTIE)
2885                 {
2886                   contents[roff + 6] = 0x03;
2887                   if (tls_type == GOT_TLS_IE_BOTH)
2888                     off += 4;
2889                 }
2890               bfd_put_32 (output_bfd,
2891                           htab->sgot->output_section->vma
2892                           + htab->sgot->output_offset + off
2893                           - htab->sgotplt->output_section->vma
2894                           - htab->sgotplt->output_offset,
2895                           contents + roff + 8);
2896               /* Skip R_386_PLT32.  */
2897               rel++;
2898               continue;
2899             }
2900           break;
2901
2902         case R_386_TLS_LDM:
2903           if (! info->shared)
2904             {
2905               unsigned int val;
2906
2907               /* LD->LE transition:
2908                  Ensure it is:
2909                  leal foo(%reg), %eax; call ___tls_get_addr.
2910                  We change it into:
2911                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
2912               BFD_ASSERT (rel->r_offset >= 2);
2913               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2914                           == 0x8d);
2915               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2916               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2917               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2918               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2919                           == 0xe8);
2920               BFD_ASSERT (rel + 1 < relend);
2921               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2922               memcpy (contents + rel->r_offset - 2,
2923                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2924               /* Skip R_386_PLT32.  */
2925               rel++;
2926               continue;
2927             }
2928
2929           if (htab->sgot == NULL)
2930             abort ();
2931
2932           off = htab->tls_ldm_got.offset;
2933           if (off & 1)
2934             off &= ~1;
2935           else
2936             {
2937               Elf_Internal_Rela outrel;
2938               bfd_byte *loc;
2939
2940               if (htab->srelgot == NULL)
2941                 abort ();
2942
2943               outrel.r_offset = (htab->sgot->output_section->vma
2944                                  + htab->sgot->output_offset + off);
2945
2946               bfd_put_32 (output_bfd, 0,
2947                           htab->sgot->contents + off);
2948               bfd_put_32 (output_bfd, 0,
2949                           htab->sgot->contents + off + 4);
2950               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2951               loc = htab->srelgot->contents;
2952               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2953               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2954               htab->tls_ldm_got.offset |= 1;
2955             }
2956           relocation = htab->sgot->output_section->vma
2957                        + htab->sgot->output_offset + off
2958                        - htab->sgotplt->output_section->vma
2959                        - htab->sgotplt->output_offset;
2960           unresolved_reloc = FALSE;
2961           break;
2962
2963         case R_386_TLS_LDO_32:
2964           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2965             relocation -= dtpoff_base (info);
2966           else
2967             /* When converting LDO to LE, we must negate.  */
2968             relocation = -tpoff (info, relocation);
2969           break;
2970
2971         case R_386_TLS_LE_32:
2972         case R_386_TLS_LE:
2973           if (info->shared)
2974             {
2975               Elf_Internal_Rela outrel;
2976               asection *sreloc;
2977               bfd_byte *loc;
2978               int indx;
2979
2980               outrel.r_offset = rel->r_offset
2981                                 + input_section->output_section->vma
2982                                 + input_section->output_offset;
2983               if (h != NULL && h->dynindx != -1)
2984                 indx = h->dynindx;
2985               else
2986                 indx = 0;
2987               if (r_type == R_386_TLS_LE_32)
2988                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2989               else
2990                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2991               sreloc = elf_section_data (input_section)->sreloc;
2992               if (sreloc == NULL)
2993                 abort ();
2994               loc = sreloc->contents;
2995               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2996               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2997               if (indx)
2998                 continue;
2999               else if (r_type == R_386_TLS_LE_32)
3000                 relocation = dtpoff_base (info) - relocation;
3001               else
3002                 relocation -= dtpoff_base (info);
3003             }
3004           else if (r_type == R_386_TLS_LE_32)
3005             relocation = tpoff (info, relocation);
3006           else
3007             relocation = -tpoff (info, relocation);
3008           break;
3009
3010         default:
3011           break;
3012         }
3013
3014       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3015          because such sections are not SEC_ALLOC and thus ld.so will
3016          not process them.  */
3017       if (unresolved_reloc
3018           && !((input_section->flags & SEC_DEBUGGING) != 0
3019                && h->def_dynamic))
3020         {
3021           (*_bfd_error_handler)
3022             (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3023              input_bfd,
3024              input_section,
3025              (long) rel->r_offset,
3026              h->root.root.string);
3027           return FALSE;
3028         }
3029
3030       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3031                                     contents, rel->r_offset,
3032                                     relocation, 0);
3033
3034       if (r != bfd_reloc_ok)
3035         {
3036           const char *name;
3037
3038           if (h != NULL)
3039             name = h->root.root.string;
3040           else
3041             {
3042               name = bfd_elf_string_from_elf_section (input_bfd,
3043                                                       symtab_hdr->sh_link,
3044                                                       sym->st_name);
3045               if (name == NULL)
3046                 return FALSE;
3047               if (*name == '\0')
3048                 name = bfd_section_name (input_bfd, sec);
3049             }
3050
3051           if (r == bfd_reloc_overflow)
3052             {
3053               if (! ((*info->callbacks->reloc_overflow)
3054                      (info, (h ? &h->root : NULL), name, howto->name,
3055                       (bfd_vma) 0, input_bfd, input_section,
3056                       rel->r_offset)))
3057                 return FALSE;
3058             }
3059           else
3060             {
3061               (*_bfd_error_handler)
3062                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3063                  input_bfd, input_section,
3064                  (long) rel->r_offset, name, (int) r);
3065               return FALSE;
3066             }
3067         }
3068     }
3069
3070   return TRUE;
3071 }
3072
3073 /* Finish up dynamic symbol handling.  We set the contents of various
3074    dynamic sections here.  */
3075
3076 static bfd_boolean
3077 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3078                                 struct bfd_link_info *info,
3079                                 struct elf_link_hash_entry *h,
3080                                 Elf_Internal_Sym *sym)
3081 {
3082   struct elf_i386_link_hash_table *htab;
3083
3084   htab = elf_i386_hash_table (info);
3085
3086   if (h->plt.offset != (bfd_vma) -1)
3087     {
3088       bfd_vma plt_index;
3089       bfd_vma got_offset;
3090       Elf_Internal_Rela rel;
3091       bfd_byte *loc;
3092
3093       /* This symbol has an entry in the procedure linkage table.  Set
3094          it up.  */
3095
3096       if (h->dynindx == -1
3097           || htab->splt == NULL
3098           || htab->sgotplt == NULL
3099           || htab->srelplt == NULL)
3100         abort ();
3101
3102       /* Get the index in the procedure linkage table which
3103          corresponds to this symbol.  This is the index of this symbol
3104          in all the symbols for which we are making plt entries.  The
3105          first entry in the procedure linkage table is reserved.  */
3106       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3107
3108       /* Get the offset into the .got table of the entry that
3109          corresponds to this function.  Each .got entry is 4 bytes.
3110          The first three are reserved.  */
3111       got_offset = (plt_index + 3) * 4;
3112
3113       /* Fill in the entry in the procedure linkage table.  */
3114       if (! info->shared)
3115         {
3116           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3117                   PLT_ENTRY_SIZE);
3118           bfd_put_32 (output_bfd,
3119                       (htab->sgotplt->output_section->vma
3120                        + htab->sgotplt->output_offset
3121                        + got_offset),
3122                       htab->splt->contents + h->plt.offset + 2);
3123
3124           if (htab->is_vxworks)
3125             {
3126               int s, k, reloc_index;
3127
3128               /* Create the R_386_32 relocation referencing the GOT
3129                  for this PLT entry.  */
3130
3131               /* S: Current slot number (zero-based).  */
3132               s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3133               /* K: Number of relocations for PLTResolve. */
3134               if (info->shared)
3135                 k = PLTRESOLVE_RELOCS_SHLIB;
3136               else
3137                 k = PLTRESOLVE_RELOCS;
3138               /* Skip the PLTresolve relocations, and the relocations for
3139                  the other PLT slots. */
3140               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3141               loc = (htab->srelplt2->contents + reloc_index
3142                      * sizeof (Elf32_External_Rel));
3143
3144               rel.r_offset = (htab->splt->output_section->vma
3145                               + htab->splt->output_offset
3146                               + h->plt.offset + 2),
3147               rel.r_info = ELF32_R_INFO (htab->hgot->indx, R_386_32);
3148               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3149
3150               /* Create the R_386_32 relocation referencing the beginning of
3151                  the PLT for this GOT entry.  */
3152               rel.r_offset = (htab->sgotplt->output_section->vma
3153                               + htab->sgotplt->output_offset
3154                               + got_offset);
3155               rel.r_info = ELF32_R_INFO (htab->hplt->indx, R_386_32);
3156               bfd_elf32_swap_reloc_out (output_bfd, &rel,
3157               loc + sizeof (Elf32_External_Rel));
3158             }
3159
3160         }
3161       else
3162         {
3163           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3164                   PLT_ENTRY_SIZE);
3165           bfd_put_32 (output_bfd, got_offset,
3166                       htab->splt->contents + h->plt.offset + 2);
3167         }
3168
3169       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3170                   htab->splt->contents + h->plt.offset + 7);
3171       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3172                   htab->splt->contents + h->plt.offset + 12);
3173
3174       /* Fill in the entry in the global offset table.  */
3175       bfd_put_32 (output_bfd,
3176                   (htab->splt->output_section->vma
3177                    + htab->splt->output_offset
3178                    + h->plt.offset
3179                    + 6),
3180                   htab->sgotplt->contents + got_offset);
3181
3182       /* Fill in the entry in the .rel.plt section.  */
3183       rel.r_offset = (htab->sgotplt->output_section->vma
3184                       + htab->sgotplt->output_offset
3185                       + got_offset);
3186       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3187       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3188       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3189
3190       if (!h->def_regular)
3191         {
3192           /* Mark the symbol as undefined, rather than as defined in
3193              the .plt section.  Leave the value if there were any
3194              relocations where pointer equality matters (this is a clue
3195              for the dynamic linker, to make function pointer
3196              comparisons work between an application and shared
3197              library), otherwise set it to zero.  If a function is only
3198              called from a binary, there is no need to slow down
3199              shared libraries because of that.  */
3200           sym->st_shndx = SHN_UNDEF;
3201           if (!h->pointer_equality_needed)
3202             sym->st_value = 0;
3203         }
3204     }
3205
3206   if (h->got.offset != (bfd_vma) -1
3207       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
3208       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3209     {
3210       Elf_Internal_Rela rel;
3211       bfd_byte *loc;
3212
3213       /* This symbol has an entry in the global offset table.  Set it
3214          up.  */
3215
3216       if (htab->sgot == NULL || htab->srelgot == NULL)
3217         abort ();
3218
3219       rel.r_offset = (htab->sgot->output_section->vma
3220                       + htab->sgot->output_offset
3221                       + (h->got.offset & ~(bfd_vma) 1));
3222
3223       /* If this is a static link, or it is a -Bsymbolic link and the
3224          symbol is defined locally or was forced to be local because
3225          of a version file, we just want to emit a RELATIVE reloc.
3226          The entry in the global offset table will already have been
3227          initialized in the relocate_section function.  */
3228       if (info->shared
3229           && SYMBOL_REFERENCES_LOCAL (info, h))
3230         {
3231           BFD_ASSERT((h->got.offset & 1) != 0);
3232           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3233         }
3234       else
3235         {
3236           BFD_ASSERT((h->got.offset & 1) == 0);
3237           bfd_put_32 (output_bfd, (bfd_vma) 0,
3238                       htab->sgot->contents + h->got.offset);
3239           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3240         }
3241
3242       loc = htab->srelgot->contents;
3243       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3244       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3245     }
3246
3247   if (h->needs_copy)
3248     {
3249       Elf_Internal_Rela rel;
3250       bfd_byte *loc;
3251
3252       /* This symbol needs a copy reloc.  Set it up.  */
3253
3254       if (h->dynindx == -1
3255           || (h->root.type != bfd_link_hash_defined
3256               && h->root.type != bfd_link_hash_defweak)
3257           || htab->srelbss == NULL)
3258         abort ();
3259
3260       rel.r_offset = (h->root.u.def.value
3261                       + h->root.u.def.section->output_section->vma
3262                       + h->root.u.def.section->output_offset);
3263       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3264       loc = htab->srelbss->contents;
3265       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3266       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3267     }
3268
3269   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3270      On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3271      is relative to the ".got" section.  */
3272   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3273       || (strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3274           && !htab->is_vxworks))
3275     sym->st_shndx = SHN_ABS;
3276
3277   return TRUE;
3278 }
3279
3280 /* Used to decide how to sort relocs in an optimal manner for the
3281    dynamic linker, before writing them out.  */
3282
3283 static enum elf_reloc_type_class
3284 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3285 {
3286   switch (ELF32_R_TYPE (rela->r_info))
3287     {
3288     case R_386_RELATIVE:
3289       return reloc_class_relative;
3290     case R_386_JUMP_SLOT:
3291       return reloc_class_plt;
3292     case R_386_COPY:
3293       return reloc_class_copy;
3294     default:
3295       return reloc_class_normal;
3296     }
3297 }
3298
3299 /* Finish up the dynamic sections.  */
3300
3301 static bfd_boolean
3302 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3303                                   struct bfd_link_info *info)
3304 {
3305   struct elf_i386_link_hash_table *htab;
3306   bfd *dynobj;
3307   asection *sdyn;
3308
3309   htab = elf_i386_hash_table (info);
3310   dynobj = htab->elf.dynobj;
3311   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3312
3313   if (htab->elf.dynamic_sections_created)
3314     {
3315       Elf32_External_Dyn *dyncon, *dynconend;
3316
3317       if (sdyn == NULL || htab->sgot == NULL)
3318         abort ();
3319
3320       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3321       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3322       for (; dyncon < dynconend; dyncon++)
3323         {
3324           Elf_Internal_Dyn dyn;
3325           asection *s;
3326
3327           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3328
3329           switch (dyn.d_tag)
3330             {
3331             default:
3332               continue;
3333
3334             case DT_PLTGOT:
3335               s = htab->sgotplt;
3336               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3337               break;
3338
3339             case DT_JMPREL:
3340               s = htab->srelplt;
3341               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3342               break;
3343
3344             case DT_PLTRELSZ:
3345               s = htab->srelplt;
3346               dyn.d_un.d_val = s->size;
3347               break;
3348
3349             case DT_RELSZ:
3350               /* My reading of the SVR4 ABI indicates that the
3351                  procedure linkage table relocs (DT_JMPREL) should be
3352                  included in the overall relocs (DT_REL).  This is
3353                  what Solaris does.  However, UnixWare can not handle
3354                  that case.  Therefore, we override the DT_RELSZ entry
3355                  here to make it not include the JMPREL relocs.  */
3356               s = htab->srelplt;
3357               if (s == NULL)
3358                 continue;
3359               dyn.d_un.d_val -= s->size;
3360               break;
3361
3362             case DT_REL:
3363               /* We may not be using the standard ELF linker script.
3364                  If .rel.plt is the first .rel section, we adjust
3365                  DT_REL to not include it.  */
3366               s = htab->srelplt;
3367               if (s == NULL)
3368                 continue;
3369               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3370                 continue;
3371               dyn.d_un.d_ptr += s->size;
3372               break;
3373             }
3374
3375           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3376         }
3377
3378       /* Fill in the first entry in the procedure linkage table.  */
3379       if (htab->splt && htab->splt->size > 0)
3380         {
3381           if (info->shared)
3382             {
3383               memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3384                       sizeof (elf_i386_pic_plt0_entry));
3385               memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3386                       htab->plt0_pad_byte,
3387                       PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3388             }
3389           else
3390             {
3391               memcpy (htab->splt->contents, elf_i386_plt0_entry,
3392                       sizeof(elf_i386_plt0_entry));
3393               memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3394                       htab->plt0_pad_byte,
3395                       PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
3396               bfd_put_32 (output_bfd,
3397                           (htab->sgotplt->output_section->vma
3398                            + htab->sgotplt->output_offset
3399                            + 4),
3400                           htab->splt->contents + 2);
3401               bfd_put_32 (output_bfd,
3402                           (htab->sgotplt->output_section->vma
3403                            + htab->sgotplt->output_offset
3404                            + 8),
3405                           htab->splt->contents + 8);
3406
3407               if (htab->is_vxworks)
3408                 {
3409                   Elf_Internal_Rela rel;
3410                   struct elf_link_hash_entry *hgot;
3411
3412                   /* The VxWorks GOT is relocated by the dynamic linker.
3413                      Therefore, we must emit relocations rather than
3414                      simply computing the values now.  */
3415                   hgot = elf_link_hash_lookup (elf_hash_table (info),
3416                                                "_GLOBAL_OFFSET_TABLE_",
3417                                                FALSE, FALSE, FALSE);
3418                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3419                      On IA32 we use REL relocations so the addend goes in
3420                      the PLT directly.  */
3421                   rel.r_offset = (htab->splt->output_section->vma
3422                                   + htab->splt->output_offset
3423                                   + 2);
3424                   rel.r_info = ELF32_R_INFO (hgot->indx, R_386_32);
3425                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3426                                             htab->srelplt2->contents);
3427                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
3428                   rel.r_offset = (htab->splt->output_section->vma
3429                                   + htab->splt->output_offset
3430                                   + 8);
3431                   rel.r_info = ELF32_R_INFO (hgot->indx, R_386_32);
3432                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
3433                                             htab->srelplt2->contents +
3434                                             sizeof (Elf32_External_Rel));
3435                 }
3436             }
3437
3438           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3439              really seem like the right value.  */
3440           elf_section_data (htab->splt->output_section)
3441             ->this_hdr.sh_entsize = 4;
3442
3443           /* Correct the .rel.plt.unloaded relocations.  */
3444           if (htab->is_vxworks && !info->shared)
3445             {
3446               int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
3447               unsigned char *p;
3448
3449               p = htab->srelplt2->contents;
3450               if (info->shared)
3451                 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
3452               else
3453                 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
3454
3455               for (; num_plts; num_plts--)
3456                 {
3457                   Elf_Internal_Rela rel;
3458                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3459                   rel.r_info = ELF32_R_INFO (htab->hgot->indx, R_386_32);
3460                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3461                   p += sizeof (Elf32_External_Rel);
3462
3463                   bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
3464                   rel.r_info = ELF32_R_INFO (htab->hplt->indx, R_386_32);
3465                   bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
3466                   p += sizeof (Elf32_External_Rel);
3467                 }
3468             }
3469         }
3470     }
3471
3472   if (htab->sgotplt)
3473     {
3474       /* Fill in the first three entries in the global offset table.  */
3475       if (htab->sgotplt->size > 0)
3476         {
3477           bfd_put_32 (output_bfd,
3478                       (sdyn == NULL ? 0
3479                        : sdyn->output_section->vma + sdyn->output_offset),
3480                       htab->sgotplt->contents);
3481           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3482           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3483         }
3484
3485       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3486     }
3487
3488   if (htab->sgot && htab->sgot->size > 0)
3489     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3490
3491   return TRUE;
3492 }
3493
3494 /* Return address for Ith PLT stub in section PLT, for relocation REL
3495    or (bfd_vma) -1 if it should not be included.  */
3496
3497 static bfd_vma
3498 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
3499                       const arelent *rel ATTRIBUTE_UNUSED)
3500 {
3501   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3502 }
3503
3504
3505 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3506 #define TARGET_LITTLE_NAME              "elf32-i386"
3507 #define ELF_ARCH                        bfd_arch_i386
3508 #define ELF_MACHINE_CODE                EM_386
3509 #define ELF_MAXPAGESIZE                 0x1000
3510
3511 #define elf_backend_can_gc_sections     1
3512 #define elf_backend_can_refcount        1
3513 #define elf_backend_want_got_plt        1
3514 #define elf_backend_plt_readonly        1
3515 #define elf_backend_want_plt_sym        0
3516 #define elf_backend_got_header_size     12
3517
3518 /* Support RELA for objdump of prelink objects.  */
3519 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3520 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3521
3522 #define bfd_elf32_mkobject                    elf_i386_mkobject
3523
3524 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3525 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3526 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3527
3528 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3529 #define elf_backend_check_relocs              elf_i386_check_relocs
3530 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3531 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3532 #define elf_backend_fake_sections             elf_i386_fake_sections
3533 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3534 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3535 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3536 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3537 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3538 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3539 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3540 #define elf_backend_relocate_section          elf_i386_relocate_section
3541 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3542 #define elf_backend_plt_sym_val               elf_i386_plt_sym_val
3543
3544 #include "elf32-target.h"
3545
3546 /* FreeBSD support.  */
3547
3548 #undef  TARGET_LITTLE_SYM
3549 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3550 #undef  TARGET_LITTLE_NAME
3551 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3552
3553 /* The kernel recognizes executables as valid only if they carry a
3554    "FreeBSD" label in the ELF header.  So we put this label on all
3555    executables and (for simplicity) also all other object files.  */
3556
3557 static void
3558 elf_i386_post_process_headers (bfd *abfd,
3559                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3560 {
3561   Elf_Internal_Ehdr *i_ehdrp;
3562
3563   i_ehdrp = elf_elfheader (abfd);
3564
3565   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3566   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3567 #ifdef OLD_FREEBSD_ABI_LABEL
3568   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3569   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3570 #endif
3571 }
3572
3573 #undef  elf_backend_post_process_headers
3574 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3575 #undef  elf32_bed
3576 #define elf32_bed                               elf32_i386_fbsd_bed
3577
3578 #include "elf32-target.h"
3579
3580 /* VxWorks support.  */
3581
3582 #undef  TARGET_LITTLE_SYM
3583 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
3584 #undef  TARGET_LITTLE_NAME
3585 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
3586
3587
3588 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks.  */
3589
3590 static struct bfd_link_hash_table *
3591 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3592 {
3593   struct bfd_link_hash_table *ret;
3594   struct elf_i386_link_hash_table *htab;
3595
3596   ret = elf_i386_link_hash_table_create (abfd);
3597   if (ret)
3598     {
3599       htab = (struct elf_i386_link_hash_table *) ret;
3600       htab->is_vxworks = 1;
3601       htab->plt0_pad_byte = 0x90;
3602     }
3603
3604   return ret;
3605 }
3606
3607
3608 /* Tweak magic VxWorks symbols as they are written to the output file.  */
3609 static bfd_boolean
3610 elf_i386_vxworks_link_output_symbol_hook (struct bfd_link_info *info
3611                                             ATTRIBUTE_UNUSED,
3612                                           const char *name,
3613                                           Elf_Internal_Sym *sym,
3614                                           asection *input_sec ATTRIBUTE_UNUSED,
3615                                           struct elf_link_hash_entry *h
3616                                             ATTRIBUTE_UNUSED)
3617 {
3618   /* Ignore the first dummy symbol.  */
3619   if (!name)
3620     return TRUE;
3621
3622   return elf_vxworks_link_output_symbol_hook (name, sym);
3623 }
3624
3625 #undef  elf_backend_post_process_headers
3626 #undef bfd_elf32_bfd_link_hash_table_create
3627 #define bfd_elf32_bfd_link_hash_table_create \
3628   elf_i386_vxworks_link_hash_table_create
3629 #undef elf_backend_add_symbol_hook
3630 #define elf_backend_add_symbol_hook \
3631   elf_vxworks_add_symbol_hook
3632 #undef elf_backend_link_output_symbol_hook
3633 #define elf_backend_link_output_symbol_hook \
3634   elf_i386_vxworks_link_output_symbol_hook
3635 #undef elf_backend_emit_relocs
3636 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
3637 #undef elf_backend_final_write_processing
3638 #define elf_backend_final_write_processing \
3639   elf_vxworks_final_write_processing
3640
3641 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3642    define it.  */
3643 #undef elf_backend_want_plt_sym
3644 #define elf_backend_want_plt_sym        1
3645
3646 #undef  elf32_bed
3647 #define elf32_bed                               elf32_i386_vxworks_bed
3648
3649 #include "elf32-target.h"