bfd/elf32-i386.c

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