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