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