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 (const 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_sec is NULL, we should have signalled an error already.  */
1957   if (elf_hash_table (info)->tls_sec == NULL)
1958     return 0;
1959   return elf_hash_table (info)->tls_sec->vma;
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_hash_table *htab = elf_hash_table (info);
1969
1970   /* If tls_sec is NULL, we should have signalled an error already.  */
1971   if (htab->tls_sec == NULL)
1972     return 0;
1973   return htab->tls_size + htab->tls_sec->vma - address;
1974 }
1975
1976 /* Relocate an i386 ELF section.  */
1977
1978 static bfd_boolean
1979 elf_i386_relocate_section (bfd *output_bfd,
1980                            struct bfd_link_info *info,
1981                            bfd *input_bfd,
1982                            asection *input_section,
1983                            bfd_byte *contents,
1984                            Elf_Internal_Rela *relocs,
1985                            Elf_Internal_Sym *local_syms,
1986                            asection **local_sections)
1987 {
1988   struct elf_i386_link_hash_table *htab;
1989   Elf_Internal_Shdr *symtab_hdr;
1990   struct elf_link_hash_entry **sym_hashes;
1991   bfd_vma *local_got_offsets;
1992   Elf_Internal_Rela *rel;
1993   Elf_Internal_Rela *relend;
1994
1995   htab = elf_i386_hash_table (info);
1996   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1997   sym_hashes = elf_sym_hashes (input_bfd);
1998   local_got_offsets = elf_local_got_offsets (input_bfd);
1999
2000   rel = relocs;
2001   relend = relocs + input_section->reloc_count;
2002   for (; rel < relend; rel++)
2003     {
2004       unsigned int r_type;
2005       reloc_howto_type *howto;
2006       unsigned long r_symndx;
2007       struct elf_link_hash_entry *h;
2008       Elf_Internal_Sym *sym;
2009       asection *sec;
2010       bfd_vma off;
2011       bfd_vma relocation;
2012       bfd_boolean unresolved_reloc;
2013       bfd_reloc_status_type r;
2014       unsigned int indx;
2015       int tls_type;
2016
2017       r_type = ELF32_R_TYPE (rel->r_info);
2018       if (r_type == R_386_GNU_VTINHERIT
2019           || r_type == R_386_GNU_VTENTRY)
2020         continue;
2021
2022       if ((indx = r_type) >= R_386_standard
2023           && ((indx = r_type - R_386_ext_offset) - R_386_standard
2024               >= R_386_ext - R_386_standard)
2025           && ((indx = r_type - R_386_tls_offset) - R_386_ext
2026               >= R_386_tls - R_386_ext))
2027         {
2028           bfd_set_error (bfd_error_bad_value);
2029           return FALSE;
2030         }
2031       howto = elf_howto_table + indx;
2032
2033       r_symndx = ELF32_R_SYM (rel->r_info);
2034
2035       if (info->relocatable)
2036         {
2037           bfd_vma val;
2038           bfd_byte *where;
2039
2040           /* This is a relocatable link.  We don't have to change
2041              anything, unless the reloc is against a section symbol,
2042              in which case we have to adjust according to where the
2043              section symbol winds up in the output section.  */
2044           if (r_symndx >= symtab_hdr->sh_info)
2045             continue;
2046
2047           sym = local_syms + r_symndx;
2048           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2049             continue;
2050
2051           sec = local_sections[r_symndx];
2052           val = sec->output_offset;
2053           if (val == 0)
2054             continue;
2055
2056           where = contents + rel->r_offset;
2057           switch (howto->size)
2058             {
2059               /* FIXME: overflow checks.  */
2060             case 0:
2061               val += bfd_get_8 (input_bfd, where);
2062               bfd_put_8 (input_bfd, val, where);
2063               break;
2064             case 1:
2065               val += bfd_get_16 (input_bfd, where);
2066               bfd_put_16 (input_bfd, val, where);
2067               break;
2068             case 2:
2069               val += bfd_get_32 (input_bfd, where);
2070               bfd_put_32 (input_bfd, val, where);
2071               break;
2072             default:
2073               abort ();
2074             }
2075           continue;
2076         }
2077
2078       /* This is a final link.  */
2079       h = NULL;
2080       sym = NULL;
2081       sec = NULL;
2082       unresolved_reloc = FALSE;
2083       if (r_symndx < symtab_hdr->sh_info)
2084         {
2085           sym = local_syms + r_symndx;
2086           sec = local_sections[r_symndx];
2087           relocation = (sec->output_section->vma
2088                         + sec->output_offset
2089                         + sym->st_value);
2090           if ((sec->flags & SEC_MERGE)
2091               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2092             {
2093               asection *msec;
2094               bfd_vma addend;
2095               bfd_byte *where = contents + rel->r_offset;
2096
2097               switch (howto->size)
2098                 {
2099                 case 0:
2100                   addend = bfd_get_8 (input_bfd, where);
2101                   if (howto->pc_relative)
2102                     {
2103                       addend = (addend ^ 0x80) - 0x80;
2104                       addend += 1;
2105                     }
2106                   break;
2107                 case 1:
2108                   addend = bfd_get_16 (input_bfd, where);
2109                   if (howto->pc_relative)
2110                     {
2111                       addend = (addend ^ 0x8000) - 0x8000;
2112                       addend += 2;
2113                     }
2114                   break;
2115                 case 2:
2116                   addend = bfd_get_32 (input_bfd, where);
2117                   if (howto->pc_relative)
2118                     {
2119                       addend = (addend ^ 0x80000000) - 0x80000000;
2120                       addend += 4;
2121                     }
2122                   break;
2123                 default:
2124                   abort ();
2125                 }
2126
2127               msec = sec;
2128               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2129               addend -= relocation;
2130               addend += msec->output_section->vma + msec->output_offset;
2131
2132               switch (howto->size)
2133                 {
2134                 case 0:
2135                   /* FIXME: overflow checks.  */
2136                   if (howto->pc_relative)
2137                     addend -= 1;
2138                   bfd_put_8 (input_bfd, addend, where);
2139                   break;
2140                 case 1:
2141                   if (howto->pc_relative)
2142                     addend -= 2;
2143                   bfd_put_16 (input_bfd, addend, where);
2144                   break;
2145                 case 2:
2146                   if (howto->pc_relative)
2147                     addend -= 4;
2148                   bfd_put_32 (input_bfd, addend, where);
2149                   break;
2150                 }
2151             }
2152         }
2153       else
2154         {
2155           bfd_boolean warned;
2156
2157           RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx, symtab_hdr, relocation, sec, unresolved_reloc, info, warned);
2158         }
2159
2160       switch (r_type)
2161         {
2162         case R_386_GOT32:
2163           /* Relocation is to the entry for this symbol in the global
2164              offset table.  */
2165           if (htab->sgot == NULL)
2166             abort ();
2167
2168           if (h != NULL)
2169             {
2170               bfd_boolean dyn;
2171
2172               off = h->got.offset;
2173               dyn = htab->elf.dynamic_sections_created;
2174               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2175                   || (info->shared
2176                       && SYMBOL_REFERENCES_LOCAL (info, h))
2177                   || (ELF_ST_VISIBILITY (h->other)
2178                       && h->root.type == bfd_link_hash_undefweak))
2179                 {
2180                   /* This is actually a static link, or it is a
2181                      -Bsymbolic link and the symbol is defined
2182                      locally, or the symbol was forced to be local
2183                      because of a version file.  We must initialize
2184                      this entry in the global offset table.  Since the
2185                      offset must always be a multiple of 4, we use the
2186                      least significant bit to record whether we have
2187                      initialized it already.
2188
2189                      When doing a dynamic link, we create a .rel.got
2190                      relocation entry to initialize the value.  This
2191                      is done in the finish_dynamic_symbol routine.  */
2192                   if ((off & 1) != 0)
2193                     off &= ~1;
2194                   else
2195                     {
2196                       bfd_put_32 (output_bfd, relocation,
2197                                   htab->sgot->contents + off);
2198                       h->got.offset |= 1;
2199                     }
2200                 }
2201               else
2202                 unresolved_reloc = FALSE;
2203             }
2204           else
2205             {
2206               if (local_got_offsets == NULL)
2207                 abort ();
2208
2209               off = local_got_offsets[r_symndx];
2210
2211               /* The offset must always be a multiple of 4.  We use
2212                  the least significant bit to record whether we have
2213                  already generated the necessary reloc.  */
2214               if ((off & 1) != 0)
2215                 off &= ~1;
2216               else
2217                 {
2218                   bfd_put_32 (output_bfd, relocation,
2219                               htab->sgot->contents + off);
2220
2221                   if (info->shared)
2222                     {
2223                       asection *s;
2224                       Elf_Internal_Rela outrel;
2225                       bfd_byte *loc;
2226
2227                       s = htab->srelgot;
2228                       if (s == NULL)
2229                         abort ();
2230
2231                       outrel.r_offset = (htab->sgot->output_section->vma
2232                                          + htab->sgot->output_offset
2233                                          + off);
2234                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2235                       loc = s->contents;
2236                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2237                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2238                     }
2239
2240                   local_got_offsets[r_symndx] |= 1;
2241                 }
2242             }
2243
2244           if (off >= (bfd_vma) -2)
2245             abort ();
2246
2247           relocation = htab->sgot->output_offset + off;
2248           break;
2249
2250         case R_386_GOTOFF:
2251           /* Relocation is relative to the start of the global offset
2252              table.  */
2253
2254           /* Note that sgot->output_offset is not involved in this
2255              calculation.  We always want the start of .got.  If we
2256              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2257              permitted by the ABI, we might have to change this
2258              calculation.  */
2259           relocation -= htab->sgot->output_section->vma;
2260           break;
2261
2262         case R_386_GOTPC:
2263           /* Use global offset table as symbol value.  */
2264           relocation = htab->sgot->output_section->vma;
2265           unresolved_reloc = FALSE;
2266           break;
2267
2268         case R_386_PLT32:
2269           /* Relocation is to the entry for this symbol in the
2270              procedure linkage table.  */
2271
2272           /* Resolve a PLT32 reloc against a local symbol directly,
2273              without using the procedure linkage table.  */
2274           if (h == NULL)
2275             break;
2276
2277           if (h->plt.offset == (bfd_vma) -1
2278               || htab->splt == NULL)
2279             {
2280               /* We didn't make a PLT entry for this symbol.  This
2281                  happens when statically linking PIC code, or when
2282                  using -Bsymbolic.  */
2283               break;
2284             }
2285
2286           relocation = (htab->splt->output_section->vma
2287                         + htab->splt->output_offset
2288                         + h->plt.offset);
2289           unresolved_reloc = FALSE;
2290           break;
2291
2292         case R_386_32:
2293         case R_386_PC32:
2294           /* r_symndx will be zero only for relocs against symbols
2295              from removed linkonce sections, or sections discarded by
2296              a linker script.  */
2297           if (r_symndx == 0
2298               || (input_section->flags & SEC_ALLOC) == 0)
2299             break;
2300
2301           if ((info->shared
2302                && (h == NULL
2303                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2304                    || h->root.type != bfd_link_hash_undefweak)
2305                && (r_type != R_386_PC32
2306                    || !SYMBOL_CALLS_LOCAL (info, h)))
2307               || (ELIMINATE_COPY_RELOCS
2308                   && !info->shared
2309                   && h != NULL
2310                   && h->dynindx != -1
2311                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2312                   && (((h->elf_link_hash_flags
2313                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2314                        && (h->elf_link_hash_flags
2315                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2316                       || h->root.type == bfd_link_hash_undefweak
2317                       || h->root.type == bfd_link_hash_undefined)))
2318             {
2319               Elf_Internal_Rela outrel;
2320               bfd_byte *loc;
2321               bfd_boolean skip, relocate;
2322               asection *sreloc;
2323
2324               /* When generating a shared object, these relocations
2325                  are copied into the output file to be resolved at run
2326                  time.  */
2327
2328               skip = FALSE;
2329               relocate = FALSE;
2330
2331               outrel.r_offset =
2332                 _bfd_elf_section_offset (output_bfd, info, input_section,
2333                                          rel->r_offset);
2334               if (outrel.r_offset == (bfd_vma) -1)
2335                 skip = TRUE;
2336               else if (outrel.r_offset == (bfd_vma) -2)
2337                 skip = TRUE, relocate = TRUE;
2338               outrel.r_offset += (input_section->output_section->vma
2339                                   + input_section->output_offset);
2340
2341               if (skip)
2342                 memset (&outrel, 0, sizeof outrel);
2343               else if (h != NULL
2344                        && h->dynindx != -1
2345                        && (r_type == R_386_PC32
2346                            || !info->shared
2347                            || !info->symbolic
2348                            || (h->elf_link_hash_flags
2349                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2350                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2351               else
2352                 {
2353                   /* This symbol is local, or marked to become local.  */
2354                   relocate = TRUE;
2355                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2356                 }
2357
2358               sreloc = elf_section_data (input_section)->sreloc;
2359               if (sreloc == NULL)
2360                 abort ();
2361
2362               loc = sreloc->contents;
2363               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2364               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2365
2366               /* If this reloc is against an external symbol, we do
2367                  not want to fiddle with the addend.  Otherwise, we
2368                  need to include the symbol value so that it becomes
2369                  an addend for the dynamic reloc.  */
2370               if (! relocate)
2371                 continue;
2372             }
2373           break;
2374
2375         case R_386_TLS_IE:
2376           if (info->shared)
2377             {
2378               Elf_Internal_Rela outrel;
2379               bfd_byte *loc;
2380               asection *sreloc;
2381
2382               outrel.r_offset = rel->r_offset
2383                                 + input_section->output_section->vma
2384                                 + input_section->output_offset;
2385               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2386               sreloc = elf_section_data (input_section)->sreloc;
2387               if (sreloc == NULL)
2388                 abort ();
2389               loc = sreloc->contents;
2390               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2391               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2392             }
2393           /* Fall through */
2394
2395         case R_386_TLS_GD:
2396         case R_386_TLS_IE_32:
2397         case R_386_TLS_GOTIE:
2398           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2399           tls_type = GOT_UNKNOWN;
2400           if (h == NULL && local_got_offsets)
2401             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2402           else if (h != NULL)
2403             {
2404               tls_type = elf_i386_hash_entry(h)->tls_type;
2405               if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2406                 r_type = R_386_TLS_LE_32;
2407             }
2408           if (tls_type == GOT_TLS_IE)
2409             tls_type = GOT_TLS_IE_NEG;
2410           if (r_type == R_386_TLS_GD)
2411             {
2412               if (tls_type == GOT_TLS_IE_POS)
2413                 r_type = R_386_TLS_GOTIE;
2414               else if (tls_type & GOT_TLS_IE)
2415                 r_type = R_386_TLS_IE_32;
2416             }
2417
2418           if (r_type == R_386_TLS_LE_32)
2419             {
2420               BFD_ASSERT (! unresolved_reloc);
2421               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2422                 {
2423                   unsigned int val, type;
2424                   bfd_vma roff;
2425
2426                   /* GD->LE transition.  */
2427                   BFD_ASSERT (rel->r_offset >= 2);
2428                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2429                   BFD_ASSERT (type == 0x8d || type == 0x04);
2430                   BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2431                   BFD_ASSERT (bfd_get_8 (input_bfd,
2432                                          contents + rel->r_offset + 4)
2433                               == 0xe8);
2434                   BFD_ASSERT (rel + 1 < relend);
2435                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2436                   roff = rel->r_offset + 5;
2437                   val = bfd_get_8 (input_bfd,
2438                                    contents + rel->r_offset - 1);
2439                   if (type == 0x04)
2440                     {
2441                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2442                          Change it into:
2443                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2444                          (6 byte form of subl).  */
2445                       BFD_ASSERT (rel->r_offset >= 3);
2446                       BFD_ASSERT (bfd_get_8 (input_bfd,
2447                                              contents + rel->r_offset - 3)
2448                                   == 0x8d);
2449                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2450                       memcpy (contents + rel->r_offset - 3,
2451                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2452                     }
2453                   else
2454                     {
2455                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2456                       if (rel->r_offset + 10 <= input_section->_raw_size
2457                           && bfd_get_8 (input_bfd,
2458                                         contents + rel->r_offset + 9) == 0x90)
2459                         {
2460                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2461                              Change it into:
2462                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2463                              (6 byte form of subl).  */
2464                           memcpy (contents + rel->r_offset - 2,
2465                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2466                           roff = rel->r_offset + 6;
2467                         }
2468                       else
2469                         {
2470                           /* leal foo(%reg), %eax; call ___tls_get_addr
2471                              Change it into:
2472                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2473                              (5 byte form of subl).  */
2474                           memcpy (contents + rel->r_offset - 2,
2475                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2476                         }
2477                     }
2478                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2479                               contents + roff);
2480                   /* Skip R_386_PLT32.  */
2481                   rel++;
2482                   continue;
2483                 }
2484               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2485                 {
2486                   unsigned int val, type;
2487
2488                   /* IE->LE transition:
2489                      Originally it can be one of:
2490                      movl foo, %eax
2491                      movl foo, %reg
2492                      addl foo, %reg
2493                      We change it into:
2494                      movl $foo, %eax
2495                      movl $foo, %reg
2496                      addl $foo, %reg.  */
2497                   BFD_ASSERT (rel->r_offset >= 1);
2498                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2499                   BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2500                   if (val == 0xa1)
2501                     {
2502                       /* movl foo, %eax.  */
2503                       bfd_put_8 (output_bfd, 0xb8,
2504                                  contents + rel->r_offset - 1);
2505                     }
2506                   else
2507                     {
2508                       BFD_ASSERT (rel->r_offset >= 2);
2509                       type = bfd_get_8 (input_bfd,
2510                                         contents + rel->r_offset - 2);
2511                       switch (type)
2512                         {
2513                         case 0x8b:
2514                           /* movl */
2515                           BFD_ASSERT ((val & 0xc7) == 0x05);
2516                           bfd_put_8 (output_bfd, 0xc7,
2517                                      contents + rel->r_offset - 2);
2518                           bfd_put_8 (output_bfd,
2519                                      0xc0 | ((val >> 3) & 7),
2520                                      contents + rel->r_offset - 1);
2521                           break;
2522                         case 0x03:
2523                           /* addl */
2524                           BFD_ASSERT ((val & 0xc7) == 0x05);
2525                           bfd_put_8 (output_bfd, 0x81,
2526                                      contents + rel->r_offset - 2);
2527                           bfd_put_8 (output_bfd,
2528                                      0xc0 | ((val >> 3) & 7),
2529                                      contents + rel->r_offset - 1);
2530                           break;
2531                         default:
2532                           BFD_FAIL ();
2533                           break;
2534                         }
2535                     }
2536                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2537                               contents + rel->r_offset);
2538                   continue;
2539                 }
2540               else
2541                 {
2542                   unsigned int val, type;
2543
2544                   /* {IE_32,GOTIE}->LE transition:
2545                      Originally it can be one of:
2546                      subl foo(%reg1), %reg2
2547                      movl foo(%reg1), %reg2
2548                      addl foo(%reg1), %reg2
2549                      We change it into:
2550                      subl $foo, %reg2
2551                      movl $foo, %reg2 (6 byte form)
2552                      addl $foo, %reg2.  */
2553                   BFD_ASSERT (rel->r_offset >= 2);
2554                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2555                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2556                   BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2557                   BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2558                   if (type == 0x8b)
2559                     {
2560                       /* movl */
2561                       bfd_put_8 (output_bfd, 0xc7,
2562                                  contents + rel->r_offset - 2);
2563                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2564                                  contents + rel->r_offset - 1);
2565                     }
2566                   else if (type == 0x2b)
2567                     {
2568                       /* subl */
2569                       bfd_put_8 (output_bfd, 0x81,
2570                                  contents + rel->r_offset - 2);
2571                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2572                                  contents + rel->r_offset - 1);
2573                     }
2574                   else if (type == 0x03)
2575                     {
2576                       /* addl */
2577                       bfd_put_8 (output_bfd, 0x81,
2578                                  contents + rel->r_offset - 2);
2579                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2580                                  contents + rel->r_offset - 1);
2581                     }
2582                   else
2583                     BFD_FAIL ();
2584                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2585                     bfd_put_32 (output_bfd, -tpoff (info, relocation),
2586                                 contents + rel->r_offset);
2587                   else
2588                     bfd_put_32 (output_bfd, tpoff (info, relocation),
2589                                 contents + rel->r_offset);
2590                   continue;
2591                 }
2592             }
2593
2594           if (htab->sgot == NULL)
2595             abort ();
2596
2597           if (h != NULL)
2598             off = h->got.offset;
2599           else
2600             {
2601               if (local_got_offsets == NULL)
2602                 abort ();
2603
2604               off = local_got_offsets[r_symndx];
2605             }
2606
2607           if ((off & 1) != 0)
2608             off &= ~1;
2609           else
2610             {
2611               Elf_Internal_Rela outrel;
2612               bfd_byte *loc;
2613               int dr_type, indx;
2614
2615               if (htab->srelgot == NULL)
2616                 abort ();
2617
2618               outrel.r_offset = (htab->sgot->output_section->vma
2619                                  + htab->sgot->output_offset + off);
2620
2621               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2622               if (r_type == R_386_TLS_GD)
2623                 dr_type = R_386_TLS_DTPMOD32;
2624               else if (tls_type == GOT_TLS_IE_POS)
2625                 dr_type = R_386_TLS_TPOFF;
2626               else
2627                 dr_type = R_386_TLS_TPOFF32;
2628               if (dr_type == R_386_TLS_TPOFF && indx == 0)
2629                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2630                             htab->sgot->contents + off);
2631               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2632                 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
2633                             htab->sgot->contents + off);
2634               else
2635                 bfd_put_32 (output_bfd, 0,
2636                             htab->sgot->contents + off);
2637               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2638               loc = htab->srelgot->contents;
2639               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2640               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2641
2642               if (r_type == R_386_TLS_GD)
2643                 {
2644                   if (indx == 0)
2645                     {
2646                       BFD_ASSERT (! unresolved_reloc);
2647                       bfd_put_32 (output_bfd,
2648                                   relocation - dtpoff_base (info),
2649                                   htab->sgot->contents + off + 4);
2650                     }
2651                   else
2652                     {
2653                       bfd_put_32 (output_bfd, 0,
2654                                   htab->sgot->contents + off + 4);
2655                       outrel.r_info = ELF32_R_INFO (indx,
2656                                                     R_386_TLS_DTPOFF32);
2657                       outrel.r_offset += 4;
2658                       htab->srelgot->reloc_count++;
2659                       loc += sizeof (Elf32_External_Rel);
2660                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2661                     }
2662                 }
2663               else if (tls_type == GOT_TLS_IE_BOTH)
2664                 {
2665                   bfd_put_32 (output_bfd,
2666                               indx == 0 ? relocation - dtpoff_base (info) : 0,
2667                               htab->sgot->contents + off + 4);
2668                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2669                   outrel.r_offset += 4;
2670                   htab->srelgot->reloc_count++;
2671                   loc += sizeof (Elf32_External_Rel);
2672                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2673                 }
2674
2675               if (h != NULL)
2676                 h->got.offset |= 1;
2677               else
2678                 local_got_offsets[r_symndx] |= 1;
2679             }
2680
2681           if (off >= (bfd_vma) -2)
2682             abort ();
2683           if (r_type == ELF32_R_TYPE (rel->r_info))
2684             {
2685               relocation = htab->sgot->output_offset + off;
2686               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2687                   && tls_type == GOT_TLS_IE_BOTH)
2688                 relocation += 4;
2689               if (r_type == R_386_TLS_IE)
2690                 relocation += htab->sgot->output_section->vma;
2691               unresolved_reloc = FALSE;
2692             }
2693           else
2694             {
2695               unsigned int val, type;
2696               bfd_vma roff;
2697
2698               /* GD->IE transition.  */
2699               BFD_ASSERT (rel->r_offset >= 2);
2700               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2701               BFD_ASSERT (type == 0x8d || type == 0x04);
2702               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2703               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2704                           == 0xe8);
2705               BFD_ASSERT (rel + 1 < relend);
2706               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2707               roff = rel->r_offset - 3;
2708               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2709               if (type == 0x04)
2710                 {
2711                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2712                      Change it into:
2713                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2714                   BFD_ASSERT (rel->r_offset >= 3);
2715                   BFD_ASSERT (bfd_get_8 (input_bfd,
2716                                          contents + rel->r_offset - 3)
2717                               == 0x8d);
2718                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2719                   val >>= 3;
2720                 }
2721               else
2722                 {
2723                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2724                      Change it into:
2725                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2726                   BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2727                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2728                   BFD_ASSERT (bfd_get_8 (input_bfd,
2729                                          contents + rel->r_offset + 9)
2730                               == 0x90);
2731                   roff = rel->r_offset - 2;
2732                 }
2733               memcpy (contents + roff,
2734                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2735               contents[roff + 7] = 0x80 | (val & 7);
2736               /* If foo is used only with foo@gotntpoff(%reg) and
2737                  foo@indntpoff, but not with foo@gottpoff(%reg), change
2738                  subl $foo@gottpoff(%reg), %eax
2739                  into:
2740                  addl $foo@gotntpoff(%reg), %eax.  */
2741               if (r_type == R_386_TLS_GOTIE)
2742                 {
2743                   contents[roff + 6] = 0x03;
2744                   if (tls_type == GOT_TLS_IE_BOTH)
2745                     off += 4;
2746                 }
2747               bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2748                           contents + roff + 8);
2749               /* Skip R_386_PLT32.  */
2750               rel++;
2751               continue;
2752             }
2753           break;
2754
2755         case R_386_TLS_LDM:
2756           if (! info->shared)
2757             {
2758               unsigned int val;
2759
2760               /* LD->LE transition:
2761                  Ensure it is:
2762                  leal foo(%reg), %eax; call ___tls_get_addr.
2763                  We change it into:
2764                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
2765               BFD_ASSERT (rel->r_offset >= 2);
2766               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2767                           == 0x8d);
2768               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2769               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2770               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2771               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2772                           == 0xe8);
2773               BFD_ASSERT (rel + 1 < relend);
2774               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2775               memcpy (contents + rel->r_offset - 2,
2776                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2777               /* Skip R_386_PLT32.  */
2778               rel++;
2779               continue;
2780             }
2781
2782           if (htab->sgot == NULL)
2783             abort ();
2784
2785           off = htab->tls_ldm_got.offset;
2786           if (off & 1)
2787             off &= ~1;
2788           else
2789             {
2790               Elf_Internal_Rela outrel;
2791               bfd_byte *loc;
2792
2793               if (htab->srelgot == NULL)
2794                 abort ();
2795
2796               outrel.r_offset = (htab->sgot->output_section->vma
2797                                  + htab->sgot->output_offset + off);
2798
2799               bfd_put_32 (output_bfd, 0,
2800                           htab->sgot->contents + off);
2801               bfd_put_32 (output_bfd, 0,
2802                           htab->sgot->contents + off + 4);
2803               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2804               loc = htab->srelgot->contents;
2805               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2806               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2807               htab->tls_ldm_got.offset |= 1;
2808             }
2809           relocation = htab->sgot->output_offset + off;
2810           unresolved_reloc = FALSE;
2811           break;
2812
2813         case R_386_TLS_LDO_32:
2814           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2815             relocation -= dtpoff_base (info);
2816           else
2817             /* When converting LDO to LE, we must negate.  */
2818             relocation = -tpoff (info, relocation);
2819           break;
2820
2821         case R_386_TLS_LE_32:
2822         case R_386_TLS_LE:
2823           if (info->shared)
2824             {
2825               Elf_Internal_Rela outrel;
2826               asection *sreloc;
2827               bfd_byte *loc;
2828               int indx;
2829
2830               outrel.r_offset = rel->r_offset
2831                                 + input_section->output_section->vma
2832                                 + input_section->output_offset;
2833               if (h != NULL && h->dynindx != -1)
2834                 indx = h->dynindx;
2835               else
2836                 indx = 0;
2837               if (r_type == R_386_TLS_LE_32)
2838                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2839               else
2840                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2841               sreloc = elf_section_data (input_section)->sreloc;
2842               if (sreloc == NULL)
2843                 abort ();
2844               loc = sreloc->contents;
2845               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2846               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2847               if (indx)
2848                 continue;
2849               else if (r_type == R_386_TLS_LE_32)
2850                 relocation = dtpoff_base (info) - relocation;
2851               else
2852                 relocation -= dtpoff_base (info);
2853             }
2854           else if (r_type == R_386_TLS_LE_32)
2855             relocation = tpoff (info, relocation);
2856           else
2857             relocation = -tpoff (info, relocation);
2858           break;
2859
2860         default:
2861           break;
2862         }
2863
2864       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2865          because such sections are not SEC_ALLOC and thus ld.so will
2866          not process them.  */
2867       if (unresolved_reloc
2868           && !((input_section->flags & SEC_DEBUGGING) != 0
2869                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2870         {
2871           (*_bfd_error_handler)
2872             (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2873              bfd_archive_filename (input_bfd),
2874              bfd_get_section_name (input_bfd, input_section),
2875              (long) rel->r_offset,
2876              h->root.root.string);
2877           return FALSE;
2878         }
2879
2880       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2881                                     contents, rel->r_offset,
2882                                     relocation, 0);
2883
2884       if (r != bfd_reloc_ok)
2885         {
2886           const char *name;
2887
2888           if (h != NULL)
2889             name = h->root.root.string;
2890           else
2891             {
2892               name = bfd_elf_string_from_elf_section (input_bfd,
2893                                                       symtab_hdr->sh_link,
2894                                                       sym->st_name);
2895               if (name == NULL)
2896                 return FALSE;
2897               if (*name == '\0')
2898                 name = bfd_section_name (input_bfd, sec);
2899             }
2900
2901           if (r == bfd_reloc_overflow)
2902             {
2903               if (! ((*info->callbacks->reloc_overflow)
2904                      (info, name, howto->name, 0,
2905                       input_bfd, input_section, rel->r_offset)))
2906                 return FALSE;
2907             }
2908           else
2909             {
2910               (*_bfd_error_handler)
2911                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2912                  bfd_archive_filename (input_bfd),
2913                  bfd_get_section_name (input_bfd, input_section),
2914                  (long) rel->r_offset, name, (int) r);
2915               return FALSE;
2916             }
2917         }
2918     }
2919
2920   return TRUE;
2921 }
2922
2923 /* Finish up dynamic symbol handling.  We set the contents of various
2924    dynamic sections here.  */
2925
2926 static bfd_boolean
2927 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
2928                                 struct bfd_link_info *info,
2929                                 struct elf_link_hash_entry *h,
2930                                 Elf_Internal_Sym *sym)
2931 {
2932   struct elf_i386_link_hash_table *htab;
2933
2934   htab = elf_i386_hash_table (info);
2935
2936   if (h->plt.offset != (bfd_vma) -1)
2937     {
2938       bfd_vma plt_index;
2939       bfd_vma got_offset;
2940       Elf_Internal_Rela rel;
2941       bfd_byte *loc;
2942
2943       /* This symbol has an entry in the procedure linkage table.  Set
2944          it up.  */
2945
2946       if (h->dynindx == -1
2947           || htab->splt == NULL
2948           || htab->sgotplt == NULL
2949           || htab->srelplt == NULL)
2950         abort ();
2951
2952       /* Get the index in the procedure linkage table which
2953          corresponds to this symbol.  This is the index of this symbol
2954          in all the symbols for which we are making plt entries.  The
2955          first entry in the procedure linkage table is reserved.  */
2956       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2957
2958       /* Get the offset into the .got table of the entry that
2959          corresponds to this function.  Each .got entry is 4 bytes.
2960          The first three are reserved.  */
2961       got_offset = (plt_index + 3) * 4;
2962
2963       /* Fill in the entry in the procedure linkage table.  */
2964       if (! info->shared)
2965         {
2966           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
2967                   PLT_ENTRY_SIZE);
2968           bfd_put_32 (output_bfd,
2969                       (htab->sgotplt->output_section->vma
2970                        + htab->sgotplt->output_offset
2971                        + got_offset),
2972                       htab->splt->contents + h->plt.offset + 2);
2973         }
2974       else
2975         {
2976           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
2977                   PLT_ENTRY_SIZE);
2978           bfd_put_32 (output_bfd, got_offset,
2979                       htab->splt->contents + h->plt.offset + 2);
2980         }
2981
2982       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
2983                   htab->splt->contents + h->plt.offset + 7);
2984       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2985                   htab->splt->contents + h->plt.offset + 12);
2986
2987       /* Fill in the entry in the global offset table.  */
2988       bfd_put_32 (output_bfd,
2989                   (htab->splt->output_section->vma
2990                    + htab->splt->output_offset
2991                    + h->plt.offset
2992                    + 6),
2993                   htab->sgotplt->contents + got_offset);
2994
2995       /* Fill in the entry in the .rel.plt section.  */
2996       rel.r_offset = (htab->sgotplt->output_section->vma
2997                       + htab->sgotplt->output_offset
2998                       + got_offset);
2999       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3000       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3001       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3002
3003       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3004         {
3005           /* Mark the symbol as undefined, rather than as defined in
3006              the .plt section.  Leave the value alone.  This is a clue
3007              for the dynamic linker, to make function pointer
3008              comparisons work between an application and shared
3009              library.  */
3010           sym->st_shndx = SHN_UNDEF;
3011         }
3012     }
3013
3014   if (h->got.offset != (bfd_vma) -1
3015       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
3016       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3017     {
3018       Elf_Internal_Rela rel;
3019       bfd_byte *loc;
3020
3021       /* This symbol has an entry in the global offset table.  Set it
3022          up.  */
3023
3024       if (htab->sgot == NULL || htab->srelgot == NULL)
3025         abort ();
3026
3027       rel.r_offset = (htab->sgot->output_section->vma
3028                       + htab->sgot->output_offset
3029                       + (h->got.offset & ~(bfd_vma) 1));
3030
3031       /* If this is a static link, or it is a -Bsymbolic link and the
3032          symbol is defined locally or was forced to be local because
3033          of a version file, we just want to emit a RELATIVE reloc.
3034          The entry in the global offset table will already have been
3035          initialized in the relocate_section function.  */
3036       if (info->shared
3037           && SYMBOL_REFERENCES_LOCAL (info, h))
3038         {
3039           BFD_ASSERT((h->got.offset & 1) != 0);
3040           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3041         }
3042       else
3043         {
3044           BFD_ASSERT((h->got.offset & 1) == 0);
3045           bfd_put_32 (output_bfd, (bfd_vma) 0,
3046                       htab->sgot->contents + h->got.offset);
3047           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3048         }
3049
3050       loc = htab->srelgot->contents;
3051       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3052       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3053     }
3054
3055   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3056     {
3057       Elf_Internal_Rela rel;
3058       bfd_byte *loc;
3059
3060       /* This symbol needs a copy reloc.  Set it up.  */
3061
3062       if (h->dynindx == -1
3063           || (h->root.type != bfd_link_hash_defined
3064               && h->root.type != bfd_link_hash_defweak)
3065           || htab->srelbss == NULL)
3066         abort ();
3067
3068       rel.r_offset = (h->root.u.def.value
3069                       + h->root.u.def.section->output_section->vma
3070                       + h->root.u.def.section->output_offset);
3071       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3072       loc = htab->srelbss->contents;
3073       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3074       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3075     }
3076
3077   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3078   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3079       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3080     sym->st_shndx = SHN_ABS;
3081
3082   return TRUE;
3083 }
3084
3085 /* Used to decide how to sort relocs in an optimal manner for the
3086    dynamic linker, before writing them out.  */
3087
3088 static enum elf_reloc_type_class
3089 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3090 {
3091   switch (ELF32_R_TYPE (rela->r_info))
3092     {
3093     case R_386_RELATIVE:
3094       return reloc_class_relative;
3095     case R_386_JUMP_SLOT:
3096       return reloc_class_plt;
3097     case R_386_COPY:
3098       return reloc_class_copy;
3099     default:
3100       return reloc_class_normal;
3101     }
3102 }
3103
3104 /* Finish up the dynamic sections.  */
3105
3106 static bfd_boolean
3107 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3108                                   struct bfd_link_info *info)
3109 {
3110   struct elf_i386_link_hash_table *htab;
3111   bfd *dynobj;
3112   asection *sdyn;
3113
3114   htab = elf_i386_hash_table (info);
3115   dynobj = htab->elf.dynobj;
3116   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3117
3118   if (htab->elf.dynamic_sections_created)
3119     {
3120       Elf32_External_Dyn *dyncon, *dynconend;
3121
3122       if (sdyn == NULL || htab->sgot == NULL)
3123         abort ();
3124
3125       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3126       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3127       for (; dyncon < dynconend; dyncon++)
3128         {
3129           Elf_Internal_Dyn dyn;
3130           asection *s;
3131
3132           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3133
3134           switch (dyn.d_tag)
3135             {
3136             default:
3137               continue;
3138
3139             case DT_PLTGOT:
3140               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3141               break;
3142
3143             case DT_JMPREL:
3144               s = htab->srelplt;
3145               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3146               break;
3147
3148             case DT_PLTRELSZ:
3149               s = htab->srelplt;
3150               dyn.d_un.d_val = s->_raw_size;
3151               break;
3152
3153             case DT_RELSZ:
3154               /* My reading of the SVR4 ABI indicates that the
3155                  procedure linkage table relocs (DT_JMPREL) should be
3156                  included in the overall relocs (DT_REL).  This is
3157                  what Solaris does.  However, UnixWare can not handle
3158                  that case.  Therefore, we override the DT_RELSZ entry
3159                  here to make it not include the JMPREL relocs.  */
3160               s = htab->srelplt;
3161               if (s == NULL)
3162                 continue;
3163               dyn.d_un.d_val -= s->_raw_size;
3164               break;
3165
3166             case DT_REL:
3167               /* We may not be using the standard ELF linker script.
3168                  If .rel.plt is the first .rel section, we adjust
3169                  DT_REL to not include it.  */
3170               s = htab->srelplt;
3171               if (s == NULL)
3172                 continue;
3173               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3174                 continue;
3175               dyn.d_un.d_ptr += s->_raw_size;
3176               break;
3177             }
3178
3179           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3180         }
3181
3182       /* Fill in the first entry in the procedure linkage table.  */
3183       if (htab->splt && htab->splt->_raw_size > 0)
3184         {
3185           if (info->shared)
3186             memcpy (htab->splt->contents,
3187                     elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
3188           else
3189             {
3190               memcpy (htab->splt->contents,
3191                       elf_i386_plt0_entry, PLT_ENTRY_SIZE);
3192               bfd_put_32 (output_bfd,
3193                           (htab->sgotplt->output_section->vma
3194                            + htab->sgotplt->output_offset
3195                            + 4),
3196                           htab->splt->contents + 2);
3197               bfd_put_32 (output_bfd,
3198                           (htab->sgotplt->output_section->vma
3199                            + htab->sgotplt->output_offset
3200                            + 8),
3201                           htab->splt->contents + 8);
3202             }
3203
3204           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3205              really seem like the right value.  */
3206           elf_section_data (htab->splt->output_section)
3207             ->this_hdr.sh_entsize = 4;
3208         }
3209     }
3210
3211   if (htab->sgotplt)
3212     {
3213       /* Fill in the first three entries in the global offset table.  */
3214       if (htab->sgotplt->_raw_size > 0)
3215         {
3216           bfd_put_32 (output_bfd,
3217                       (sdyn == NULL ? 0
3218                        : sdyn->output_section->vma + sdyn->output_offset),
3219                       htab->sgotplt->contents);
3220           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3221           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3222         }
3223
3224       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3225     }
3226   return TRUE;
3227 }
3228
3229 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3230 #define TARGET_LITTLE_NAME              "elf32-i386"
3231 #define ELF_ARCH                        bfd_arch_i386
3232 #define ELF_MACHINE_CODE                EM_386
3233 #define ELF_MAXPAGESIZE                 0x1000
3234
3235 #define elf_backend_can_gc_sections     1
3236 #define elf_backend_can_refcount        1
3237 #define elf_backend_want_got_plt        1
3238 #define elf_backend_plt_readonly        1
3239 #define elf_backend_want_plt_sym        0
3240 #define elf_backend_got_header_size     12
3241
3242 /* Support RELA for objdump of prelink objects.  */
3243 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3244 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3245
3246 #define bfd_elf32_mkobject                    elf_i386_mkobject
3247 #define elf_backend_object_p                  elf_i386_object_p
3248
3249 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3250 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3251 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3252
3253 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3254 #define elf_backend_check_relocs              elf_i386_check_relocs
3255 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3256 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3257 #define elf_backend_fake_sections             elf_i386_fake_sections
3258 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3259 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3260 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3261 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3262 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3263 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3264 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3265 #define elf_backend_relocate_section          elf_i386_relocate_section
3266 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3267
3268 #include "elf32-target.h"
3269
3270 /* FreeBSD support.  */
3271
3272 #undef  TARGET_LITTLE_SYM
3273 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3274 #undef  TARGET_LITTLE_NAME
3275 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3276
3277 /* The kernel recognizes executables as valid only if they carry a
3278    "FreeBSD" label in the ELF header.  So we put this label on all
3279    executables and (for simplicity) also all other object files.  */
3280
3281 static void
3282 elf_i386_post_process_headers (bfd *abfd,
3283                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3284 {
3285   Elf_Internal_Ehdr *i_ehdrp;
3286
3287   i_ehdrp = elf_elfheader (abfd);
3288
3289   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3290   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3291 #ifdef OLD_FREEBSD_ABI_LABEL
3292   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3293   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3294 #endif
3295 }
3296
3297 #undef  elf_backend_post_process_headers
3298 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3299 #undef  elf32_bed
3300 #define elf32_bed                               elf32_i386_fbsd_bed
3301
3302 #include "elf32-target.h"