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