bfd/elf32-i386.c

   1 /* Intel 80386/80486-specific support for 32-bit ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26
  27 /* 386 uses REL relocations instead of RELA.  */
  28 #define USE_REL 1
  29
  30 #include "elf/i386.h"
  31
  32 static reloc_howto_type elf_howto_table[]=
  33 {
  34   HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
  35         bfd_elf_generic_reloc, "R_386_NONE",
  36         TRUE, 0x00000000, 0x00000000, FALSE),
  37   HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  38         bfd_elf_generic_reloc, "R_386_32",
  39         TRUE, 0xffffffff, 0xffffffff, FALSE),
  40   HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  41         bfd_elf_generic_reloc, "R_386_PC32",
  42         TRUE, 0xffffffff, 0xffffffff, TRUE),
  43   HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  44         bfd_elf_generic_reloc, "R_386_GOT32",
  45         TRUE, 0xffffffff, 0xffffffff, FALSE),
  46   HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  47         bfd_elf_generic_reloc, "R_386_PLT32",
  48         TRUE, 0xffffffff, 0xffffffff, TRUE),
  49   HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  50         bfd_elf_generic_reloc, "R_386_COPY",
  51         TRUE, 0xffffffff, 0xffffffff, FALSE),
  52   HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  53         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
  54         TRUE, 0xffffffff, 0xffffffff, FALSE),
  55   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  56         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
  57         TRUE, 0xffffffff, 0xffffffff, FALSE),
  58   HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  59         bfd_elf_generic_reloc, "R_386_RELATIVE",
  60         TRUE, 0xffffffff, 0xffffffff, FALSE),
  61   HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  62         bfd_elf_generic_reloc, "R_386_GOTOFF",
  63         TRUE, 0xffffffff, 0xffffffff, FALSE),
  64   HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
  65         bfd_elf_generic_reloc, "R_386_GOTPC",
  66         TRUE, 0xffffffff, 0xffffffff, TRUE),
  67
  68   /* We have a gap in the reloc numbers here.
  69      R_386_standard counts the number up to this point, and
  70      R_386_ext_offset is the value to subtract from a reloc type of
  71      R_386_16 thru R_386_PC8 to form an index into this table.  */
  72 #define R_386_standard (R_386_GOTPC + 1)
  73 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
  74
  75   /* These relocs are a GNU extension.  */
  76   HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  77         bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
  78         TRUE, 0xffffffff, 0xffffffff, FALSE),
  79   HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  80         bfd_elf_generic_reloc, "R_386_TLS_IE",
  81         TRUE, 0xffffffff, 0xffffffff, FALSE),
  82   HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  83         bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
  84         TRUE, 0xffffffff, 0xffffffff, FALSE),
  85   HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  86         bfd_elf_generic_reloc, "R_386_TLS_LE",
  87         TRUE, 0xffffffff, 0xffffffff, FALSE),
  88   HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  89         bfd_elf_generic_reloc, "R_386_TLS_GD",
  90         TRUE, 0xffffffff, 0xffffffff, FALSE),
  91   HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  92         bfd_elf_generic_reloc, "R_386_TLS_LDM",
  93         TRUE, 0xffffffff, 0xffffffff, FALSE),
  94   HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  95         bfd_elf_generic_reloc, "R_386_16",
  96         TRUE, 0xffff, 0xffff, FALSE),
  97   HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  98         bfd_elf_generic_reloc, "R_386_PC16",
  99         TRUE, 0xffff, 0xffff, TRUE),
 100   HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
 101         bfd_elf_generic_reloc, "R_386_8",
 102         TRUE, 0xff, 0xff, FALSE),
 103   HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
 104         bfd_elf_generic_reloc, "R_386_PC8",
 105         TRUE, 0xff, 0xff, TRUE),
 106
 107 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
 108 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
 109   /* These are common with Solaris TLS implementation.  */
 110   HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 111         bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
 112         TRUE, 0xffffffff, 0xffffffff, FALSE),
 113   HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 114         bfd_elf_generic_reloc, "R_386_TLS_IE_32",
 115         TRUE, 0xffffffff, 0xffffffff, FALSE),
 116   HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 117         bfd_elf_generic_reloc, "R_386_TLS_LE_32",
 118         TRUE, 0xffffffff, 0xffffffff, FALSE),
 119   HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 120         bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
 121         TRUE, 0xffffffff, 0xffffffff, FALSE),
 122   HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 123         bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
 124         TRUE, 0xffffffff, 0xffffffff, FALSE),
 125   HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 126         bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
 127         TRUE, 0xffffffff, 0xffffffff, FALSE),
 128
 129   /* Another gap.  */
 130 #define R_386_tls (R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
 131 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_tls)
 132
 133 /* GNU extension to record C++ vtable hierarchy.  */
 134   HOWTO (R_386_GNU_VTINHERIT,   /* type */
 135          0,                     /* rightshift */
 136          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 137          0,                     /* bitsize */
 138          FALSE,                 /* pc_relative */
 139          0,                     /* bitpos */
 140          complain_overflow_dont, /* complain_on_overflow */
 141          NULL,                  /* special_function */
 142          "R_386_GNU_VTINHERIT", /* name */
 143          FALSE,                 /* partial_inplace */
 144          0,                     /* src_mask */
 145          0,                     /* dst_mask */
 146          FALSE),                /* pcrel_offset */
 147
 148 /* GNU extension to record C++ vtable member usage.  */
 149   HOWTO (R_386_GNU_VTENTRY,     /* type */
 150          0,                     /* rightshift */
 151          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 152          0,                     /* bitsize */
 153          FALSE,                 /* pc_relative */
 154          0,                     /* bitpos */
 155          complain_overflow_dont, /* complain_on_overflow */
 156          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 157          "R_386_GNU_VTENTRY",   /* name */
 158          FALSE,                 /* partial_inplace */
 159          0,                     /* src_mask */
 160          0,                     /* dst_mask */
 161          FALSE)                 /* pcrel_offset */
 162
 163 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
 164
 165 };
 166
 167 #ifdef DEBUG_GEN_RELOC
 168 #define TRACE(str) \
 169   fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 170 #else
 171 #define TRACE(str)
 172 #endif
 173
 174 static reloc_howto_type *
 175 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 176                             bfd_reloc_code_real_type code)
 177 {
 178   switch (code)
 179     {
 180     case BFD_RELOC_NONE:
 181       TRACE ("BFD_RELOC_NONE");
 182       return &elf_howto_table[R_386_NONE];
 183
 184     case BFD_RELOC_32:
 185       TRACE ("BFD_RELOC_32");
 186       return &elf_howto_table[R_386_32];
 187
 188     case BFD_RELOC_CTOR:
 189       TRACE ("BFD_RELOC_CTOR");
 190       return &elf_howto_table[R_386_32];
 191
 192     case BFD_RELOC_32_PCREL:
 193       TRACE ("BFD_RELOC_PC32");
 194       return &elf_howto_table[R_386_PC32];
 195
 196     case BFD_RELOC_386_GOT32:
 197       TRACE ("BFD_RELOC_386_GOT32");
 198       return &elf_howto_table[R_386_GOT32];
 199
 200     case BFD_RELOC_386_PLT32:
 201       TRACE ("BFD_RELOC_386_PLT32");
 202       return &elf_howto_table[R_386_PLT32];
 203
 204     case BFD_RELOC_386_COPY:
 205       TRACE ("BFD_RELOC_386_COPY");
 206       return &elf_howto_table[R_386_COPY];
 207
 208     case BFD_RELOC_386_GLOB_DAT:
 209       TRACE ("BFD_RELOC_386_GLOB_DAT");
 210       return &elf_howto_table[R_386_GLOB_DAT];
 211
 212     case BFD_RELOC_386_JUMP_SLOT:
 213       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 214       return &elf_howto_table[R_386_JUMP_SLOT];
 215
 216     case BFD_RELOC_386_RELATIVE:
 217       TRACE ("BFD_RELOC_386_RELATIVE");
 218       return &elf_howto_table[R_386_RELATIVE];
 219
 220     case BFD_RELOC_386_GOTOFF:
 221       TRACE ("BFD_RELOC_386_GOTOFF");
 222       return &elf_howto_table[R_386_GOTOFF];
 223
 224     case BFD_RELOC_386_GOTPC:
 225       TRACE ("BFD_RELOC_386_GOTPC");
 226       return &elf_howto_table[R_386_GOTPC];
 227
 228       /* These relocs are a GNU extension.  */
 229     case BFD_RELOC_386_TLS_TPOFF:
 230       TRACE ("BFD_RELOC_386_TLS_TPOFF");
 231       return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
 232
 233     case BFD_RELOC_386_TLS_IE:
 234       TRACE ("BFD_RELOC_386_TLS_IE");
 235       return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
 236
 237     case BFD_RELOC_386_TLS_GOTIE:
 238       TRACE ("BFD_RELOC_386_TLS_GOTIE");
 239       return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
 240
 241     case BFD_RELOC_386_TLS_LE:
 242       TRACE ("BFD_RELOC_386_TLS_LE");
 243       return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
 244
 245     case BFD_RELOC_386_TLS_GD:
 246       TRACE ("BFD_RELOC_386_TLS_GD");
 247       return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
 248
 249     case BFD_RELOC_386_TLS_LDM:
 250       TRACE ("BFD_RELOC_386_TLS_LDM");
 251       return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
 252
 253     case BFD_RELOC_16:
 254       TRACE ("BFD_RELOC_16");
 255       return &elf_howto_table[R_386_16 - R_386_ext_offset];
 256
 257     case BFD_RELOC_16_PCREL:
 258       TRACE ("BFD_RELOC_16_PCREL");
 259       return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
 260
 261     case BFD_RELOC_8:
 262       TRACE ("BFD_RELOC_8");
 263       return &elf_howto_table[R_386_8 - R_386_ext_offset];
 264
 265     case BFD_RELOC_8_PCREL:
 266       TRACE ("BFD_RELOC_8_PCREL");
 267       return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
 268
 269     /* Common with Sun TLS implementation.  */
 270     case BFD_RELOC_386_TLS_LDO_32:
 271       TRACE ("BFD_RELOC_386_TLS_LDO_32");
 272       return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
 273
 274     case BFD_RELOC_386_TLS_IE_32:
 275       TRACE ("BFD_RELOC_386_TLS_IE_32");
 276       return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
 277
 278     case BFD_RELOC_386_TLS_LE_32:
 279       TRACE ("BFD_RELOC_386_TLS_LE_32");
 280       return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
 281
 282     case BFD_RELOC_386_TLS_DTPMOD32:
 283       TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
 284       return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
 285
 286     case BFD_RELOC_386_TLS_DTPOFF32:
 287       TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
 288       return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
 289
 290     case BFD_RELOC_386_TLS_TPOFF32:
 291       TRACE ("BFD_RELOC_386_TLS_TPOFF32");
 292       return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
 293
 294     case BFD_RELOC_VTABLE_INHERIT:
 295       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 296       return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
 297
 298     case BFD_RELOC_VTABLE_ENTRY:
 299       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 300       return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
 301
 302     default:
 303       break;
 304     }
 305
 306   TRACE ("Unknown");
 307   return 0;
 308 }
 309
 310 static void
 311 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
 312                             arelent *cache_ptr,
 313                             Elf_Internal_Rela *dst)
 314 {
 315   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 316   unsigned int indx;
 317
 318   if ((indx = r_type) >= R_386_standard
 319       && ((indx = r_type - R_386_ext_offset) - R_386_standard
 320           >= R_386_ext - R_386_standard)
 321       && ((indx = r_type - R_386_tls_offset) - R_386_ext
 322           >= R_386_tls - R_386_ext)
 323       && ((indx = r_type - R_386_vt_offset) - R_386_tls
 324           >= R_386_vt - R_386_tls))
 325     {
 326       (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
 327                              bfd_archive_filename (abfd), (int) r_type);
 328       indx = R_386_NONE;
 329     }
 330   cache_ptr->howto = &elf_howto_table[indx];
 331 }
 332
 333 /* Return whether a symbol name implies a local label.  The UnixWare
 334    2.1 cc generates temporary symbols that start with .X, so we
 335    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
 336    If so, we should move the .X recognition into
 337    _bfd_elf_is_local_label_name.  */
 338
 339 static bfd_boolean
 340 elf_i386_is_local_label_name (bfd *abfd, const char *name)
 341 {
 342   if (name[0] == '.' && name[1] == 'X')
 343     return TRUE;
 344
 345   return _bfd_elf_is_local_label_name (abfd, name);
 346 }
 347 \f
 348 /* Support for core dump NOTE sections.  */
 349 static bfd_boolean
 350 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 351 {
 352   int offset;
 353   size_t raw_size;
 354
 355   switch (note->descsz)
 356     {
 357       default:
 358         return FALSE;
 359
 360       case 144:         /* Linux/i386 */
 361         /* pr_cursig */
 362         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
 363
 364         /* pr_pid */
 365         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
 366
 367         /* pr_reg */
 368         offset = 72;
 369         raw_size = 68;
 370
 371         break;
 372     }
 373
 374   /* Make a ".reg/999" section.  */
 375   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 376                                           raw_size, note->descpos + offset);
 377 }
 378
 379 static bfd_boolean
 380 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 381 {
 382   switch (note->descsz)
 383     {
 384       default:
 385         return FALSE;
 386
 387       case 124:         /* Linux/i386 elf_prpsinfo */
 388         elf_tdata (abfd)->core_program
 389           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 390         elf_tdata (abfd)->core_command
 391           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 392     }
 393
 394   /* Note that for some reason, a spurious space is tacked
 395      onto the end of the args in some (at least one anyway)
 396      implementations, so strip it off if it exists.  */
 397
 398   {
 399     char *command = elf_tdata (abfd)->core_command;
 400     int n = strlen (command);
 401
 402     if (0 < n && command[n - 1] == ' ')
 403       command[n - 1] = '\0';
 404   }
 405
 406   return TRUE;
 407 }
 408 \f
 409 /* Functions for the i386 ELF linker.
 410
 411    In order to gain some understanding of code in this file without
 412    knowing all the intricate details of the linker, note the
 413    following:
 414
 415    Functions named elf_i386_* are called by external routines, other
 416    functions are only called locally.  elf_i386_* functions appear
 417    in this file more or less in the order in which they are called
 418    from external routines.  eg. elf_i386_check_relocs is called
 419    early in the link process, elf_i386_finish_dynamic_sections is
 420    one of the last functions.  */
 421
 422
 423 /* The name of the dynamic interpreter.  This is put in the .interp
 424    section.  */
 425
 426 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 427
 428 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 429    copying dynamic variables from a shared lib into an app's dynbss
 430    section, and instead use a dynamic relocation to point into the
 431    shared lib.  */
 432 #define ELIMINATE_COPY_RELOCS 1
 433
 434 /* The size in bytes of an entry in the procedure linkage table.  */
 435
 436 #define PLT_ENTRY_SIZE 16
 437
 438 /* The first entry in an absolute procedure linkage table looks like
 439    this.  See the SVR4 ABI i386 supplement to see how this works.  */
 440
 441 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
 442 {
 443   0xff, 0x35,   /* pushl contents of address */
 444   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 445   0xff, 0x25,   /* jmp indirect */
 446   0, 0, 0, 0,   /* replaced with address of .got + 8.  */
 447   0, 0, 0, 0    /* pad out to 16 bytes.  */
 448 };
 449
 450 /* Subsequent entries in an absolute procedure linkage table look like
 451    this.  */
 452
 453 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
 454 {
 455   0xff, 0x25,   /* jmp indirect */
 456   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 457   0x68,         /* pushl immediate */
 458   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 459   0xe9,         /* jmp relative */
 460   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 461 };
 462
 463 /* The first entry in a PIC procedure linkage table look like this.  */
 464
 465 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
 466 {
 467   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 468   0xff, 0xa3, 8, 0, 0, 0,       /* jmp *8(%ebx) */
 469   0, 0, 0, 0                    /* pad out to 16 bytes.  */
 470 };
 471
 472 /* Subsequent entries in a PIC procedure linkage table look like this.  */
 473
 474 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
 475 {
 476   0xff, 0xa3,   /* jmp *offset(%ebx) */
 477   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 478   0x68,         /* pushl immediate */
 479   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 480   0xe9,         /* jmp relative */
 481   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 482 };
 483
 484 /* The i386 linker needs to keep track of the number of relocs that it
 485    decides to copy as dynamic relocs in check_relocs for each symbol.
 486    This is so that it can later discard them if they are found to be
 487    unnecessary.  We store the information in a field extending the
 488    regular ELF linker hash table.  */
 489
 490 struct elf_i386_dyn_relocs
 491 {
 492   struct elf_i386_dyn_relocs *next;
 493
 494   /* The input section of the reloc.  */
 495   asection *sec;
 496
 497   /* Total number of relocs copied for the input section.  */
 498   bfd_size_type count;
 499
 500   /* Number of pc-relative relocs copied for the input section.  */
 501   bfd_size_type pc_count;
 502 };
 503
 504 /* i386 ELF linker hash entry.  */
 505
 506 struct elf_i386_link_hash_entry
 507 {
 508   struct elf_link_hash_entry elf;
 509
 510   /* Track dynamic relocs copied for this symbol.  */
 511   struct elf_i386_dyn_relocs *dyn_relocs;
 512
 513 #define GOT_UNKNOWN     0
 514 #define GOT_NORMAL      1
 515 #define GOT_TLS_GD      2
 516 #define GOT_TLS_IE      4
 517 #define GOT_TLS_IE_POS  5
 518 #define GOT_TLS_IE_NEG  6
 519 #define GOT_TLS_IE_BOTH 7
 520   unsigned char tls_type;
 521 };
 522
 523 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
 524
 525 struct elf_i386_obj_tdata
 526 {
 527   struct elf_obj_tdata root;
 528
 529   /* tls_type for each local got entry.  */
 530   char *local_got_tls_type;
 531 };
 532
 533 #define elf_i386_tdata(abfd) \
 534   ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
 535
 536 #define elf_i386_local_got_tls_type(abfd) \
 537   (elf_i386_tdata (abfd)->local_got_tls_type)
 538
 539 static bfd_boolean
 540 elf_i386_mkobject (bfd *abfd)
 541 {
 542   bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
 543   abfd->tdata.any = bfd_zalloc (abfd, amt);
 544   if (abfd->tdata.any == NULL)
 545     return FALSE;
 546   return TRUE;
 547 }
 548
 549 static bfd_boolean
 550 elf_i386_object_p (bfd *abfd)
 551 {
 552   /* Allocate our special target data.  */
 553   struct elf_i386_obj_tdata *new_tdata;
 554   bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
 555   new_tdata = bfd_zalloc (abfd, amt);
 556   if (new_tdata == NULL)
 557     return FALSE;
 558   new_tdata->root = *abfd->tdata.elf_obj_data;
 559   abfd->tdata.any = new_tdata;
 560   return TRUE;
 561 }
 562
 563 /* i386 ELF linker hash table.  */
 564
 565 struct elf_i386_link_hash_table
 566 {
 567   struct elf_link_hash_table elf;
 568
 569   /* Short-cuts to get to dynamic linker sections.  */
 570   asection *sgot;
 571   asection *sgotplt;
 572   asection *srelgot;
 573   asection *splt;
 574   asection *srelplt;
 575   asection *sdynbss;
 576   asection *srelbss;
 577
 578   union {
 579     bfd_signed_vma refcount;
 580     bfd_vma offset;
 581   } tls_ldm_got;
 582
 583   /* Small local sym to section mapping cache.  */
 584   struct sym_sec_cache sym_sec;
 585 };
 586
 587 /* Get the i386 ELF linker hash table from a link_info structure.  */
 588
 589 #define elf_i386_hash_table(p) \
 590   ((struct elf_i386_link_hash_table *) ((p)->hash))
 591
 592 /* Create an entry in an i386 ELF linker hash table.  */
 593
 594 static struct bfd_hash_entry *
 595 link_hash_newfunc (struct bfd_hash_entry *entry,
 596                    struct bfd_hash_table *table,
 597                    const char *string)
 598 {
 599   /* Allocate the structure if it has not already been allocated by a
 600      subclass.  */
 601   if (entry == NULL)
 602     {
 603       entry = bfd_hash_allocate (table,
 604                                  sizeof (struct elf_i386_link_hash_entry));
 605       if (entry == NULL)
 606         return entry;
 607     }
 608
 609   /* Call the allocation method of the superclass.  */
 610   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 611   if (entry != NULL)
 612     {
 613       struct elf_i386_link_hash_entry *eh;
 614
 615       eh = (struct elf_i386_link_hash_entry *) entry;
 616       eh->dyn_relocs = NULL;
 617       eh->tls_type = GOT_UNKNOWN;
 618     }
 619
 620   return entry;
 621 }
 622
 623 /* Create an i386 ELF linker hash table.  */
 624
 625 static struct bfd_link_hash_table *
 626 elf_i386_link_hash_table_create (bfd *abfd)
 627 {
 628   struct elf_i386_link_hash_table *ret;
 629   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
 630
 631   ret = bfd_malloc (amt);
 632   if (ret == NULL)
 633     return NULL;
 634
 635   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
 636     {
 637       free (ret);
 638       return NULL;
 639     }
 640
 641   ret->sgot = NULL;
 642   ret->sgotplt = NULL;
 643   ret->srelgot = NULL;
 644   ret->splt = NULL;
 645   ret->srelplt = NULL;
 646   ret->sdynbss = NULL;
 647   ret->srelbss = NULL;
 648   ret->tls_ldm_got.refcount = 0;
 649   ret->sym_sec.abfd = NULL;
 650
 651   return &ret->elf.root;
 652 }
 653
 654 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
 655    shortcuts to them in our hash table.  */
 656
 657 static bfd_boolean
 658 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 659 {
 660   struct elf_i386_link_hash_table *htab;
 661
 662   if (! _bfd_elf_create_got_section (dynobj, info))
 663     return FALSE;
 664
 665   htab = elf_i386_hash_table (info);
 666   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 667   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 668   if (!htab->sgot || !htab->sgotplt)
 669     abort ();
 670
 671   htab->srelgot = bfd_make_section (dynobj, ".rel.got");
 672   if (htab->srelgot == NULL
 673       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 674                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 675                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 676                                    | SEC_READONLY))
 677       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 678     return FALSE;
 679   return TRUE;
 680 }
 681
 682 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 683    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 684    hash table.  */
 685
 686 static bfd_boolean
 687 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 688 {
 689   struct elf_i386_link_hash_table *htab;
 690
 691   htab = elf_i386_hash_table (info);
 692   if (!htab->sgot && !create_got_section (dynobj, info))
 693     return FALSE;
 694
 695   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 696     return FALSE;
 697
 698   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 699   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
 700   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 701   if (!info->shared)
 702     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
 703
 704   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 705       || (!info->shared && !htab->srelbss))
 706     abort ();
 707
 708   return TRUE;
 709 }
 710
 711 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 712
 713 static void
 714 elf_i386_copy_indirect_symbol (struct elf_backend_data *bed,
 715                                struct elf_link_hash_entry *dir,
 716                                struct elf_link_hash_entry *ind)
 717 {
 718   struct elf_i386_link_hash_entry *edir, *eind;
 719
 720   edir = (struct elf_i386_link_hash_entry *) dir;
 721   eind = (struct elf_i386_link_hash_entry *) ind;
 722
 723   if (eind->dyn_relocs != NULL)
 724     {
 725       if (edir->dyn_relocs != NULL)
 726         {
 727           struct elf_i386_dyn_relocs **pp;
 728           struct elf_i386_dyn_relocs *p;
 729
 730           if (ind->root.type == bfd_link_hash_indirect)
 731             abort ();
 732
 733           /* Add reloc counts against the weak sym to the strong sym
 734              list.  Merge any entries against the same section.  */
 735           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 736             {
 737               struct elf_i386_dyn_relocs *q;
 738
 739               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 740                 if (q->sec == p->sec)
 741                   {
 742                     q->pc_count += p->pc_count;
 743                     q->count += p->count;
 744                     *pp = p->next;
 745                     break;
 746                   }
 747               if (q == NULL)
 748                 pp = &p->next;
 749             }
 750           *pp = edir->dyn_relocs;
 751         }
 752
 753       edir->dyn_relocs = eind->dyn_relocs;
 754       eind->dyn_relocs = NULL;
 755     }
 756
 757   if (ind->root.type == bfd_link_hash_indirect
 758       && dir->got.refcount <= 0)
 759     {
 760       edir->tls_type = eind->tls_type;
 761       eind->tls_type = GOT_UNKNOWN;
 762     }
 763
 764   if (ELIMINATE_COPY_RELOCS
 765       && ind->root.type != bfd_link_hash_indirect
 766       && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
 767     /* If called to transfer flags for a weakdef during processing
 768        of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
 769        We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 770     dir->elf_link_hash_flags |=
 771       (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
 772                                    | ELF_LINK_HASH_REF_REGULAR
 773                                    | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
 774   else
 775     _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 776 }
 777
 778 static int
 779 elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
 780 {
 781   if (info->shared)
 782     return r_type;
 783
 784   switch (r_type)
 785     {
 786     case R_386_TLS_GD:
 787     case R_386_TLS_IE_32:
 788       if (is_local)
 789         return R_386_TLS_LE_32;
 790       return R_386_TLS_IE_32;
 791     case R_386_TLS_IE:
 792     case R_386_TLS_GOTIE:
 793       if (is_local)
 794         return R_386_TLS_LE_32;
 795       return r_type;
 796     case R_386_TLS_LDM:
 797       return R_386_TLS_LE_32;
 798     }
 799
 800   return r_type;
 801 }
 802
 803 /* Look through the relocs for a section during the first phase, and
 804    calculate needed space in the global offset table, procedure linkage
 805    table, and dynamic reloc sections.  */
 806
 807 static bfd_boolean
 808 elf_i386_check_relocs (bfd *abfd,
 809                        struct bfd_link_info *info,
 810                        asection *sec,
 811                        const Elf_Internal_Rela *relocs)
 812 {
 813   struct elf_i386_link_hash_table *htab;
 814   Elf_Internal_Shdr *symtab_hdr;
 815   struct elf_link_hash_entry **sym_hashes;
 816   const Elf_Internal_Rela *rel;
 817   const Elf_Internal_Rela *rel_end;
 818   asection *sreloc;
 819
 820   if (info->relocateable)
 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->relocateable)
2038         {
2039           bfd_vma val;
2040           bfd_byte *where;
2041
2042           /* This is a relocatable link.  We don't have to change
2043              anything, unless the reloc is against a section symbol,
2044              in which case we have to adjust according to where the
2045              section symbol winds up in the output section.  */
2046           if (r_symndx >= symtab_hdr->sh_info)
2047             continue;
2048
2049           sym = local_syms + r_symndx;
2050           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2051             continue;
2052
2053           sec = local_sections[r_symndx];
2054           val = sec->output_offset;
2055           if (val == 0)
2056             continue;
2057
2058           where = contents + rel->r_offset;
2059           switch (howto->size)
2060             {
2061               /* FIXME: overflow checks.  */
2062             case 0:
2063               val += bfd_get_8 (input_bfd, where);
2064               bfd_put_8 (input_bfd, val, where);
2065               break;
2066             case 1:
2067               val += bfd_get_16 (input_bfd, where);
2068               bfd_put_16 (input_bfd, val, where);
2069               break;
2070             case 2:
2071               val += bfd_get_32 (input_bfd, where);
2072               bfd_put_32 (input_bfd, val, where);
2073               break;
2074             default:
2075               abort ();
2076             }
2077           continue;
2078         }
2079
2080       /* This is a final link.  */
2081       h = NULL;
2082       sym = NULL;
2083       sec = NULL;
2084       unresolved_reloc = FALSE;
2085       if (r_symndx < symtab_hdr->sh_info)
2086         {
2087           sym = local_syms + r_symndx;
2088           sec = local_sections[r_symndx];
2089           relocation = (sec->output_section->vma
2090                         + sec->output_offset
2091                         + sym->st_value);
2092           if ((sec->flags & SEC_MERGE)
2093               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2094             {
2095               asection *msec;
2096               bfd_vma addend;
2097               bfd_byte *where = contents + rel->r_offset;
2098
2099               switch (howto->size)
2100                 {
2101                 case 0:
2102                   addend = bfd_get_8 (input_bfd, where);
2103                   if (howto->pc_relative)
2104                     {
2105                       addend = (addend ^ 0x80) - 0x80;
2106                       addend += 1;
2107                     }
2108                   break;
2109                 case 1:
2110                   addend = bfd_get_16 (input_bfd, where);
2111                   if (howto->pc_relative)
2112                     {
2113                       addend = (addend ^ 0x8000) - 0x8000;
2114                       addend += 2;
2115                     }
2116                   break;
2117                 case 2:
2118                   addend = bfd_get_32 (input_bfd, where);
2119                   if (howto->pc_relative)
2120                     {
2121                       addend = (addend ^ 0x80000000) - 0x80000000;
2122                       addend += 4;
2123                     }
2124                   break;
2125                 default:
2126                   abort ();
2127                 }
2128
2129               msec = sec;
2130               addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2131               addend -= relocation;
2132               addend += msec->output_section->vma + msec->output_offset;
2133
2134               switch (howto->size)
2135                 {
2136                 case 0:
2137                   /* FIXME: overflow checks.  */
2138                   if (howto->pc_relative)
2139                     addend -= 1;
2140                   bfd_put_8 (input_bfd, addend, where);
2141                   break;
2142                 case 1:
2143                   if (howto->pc_relative)
2144                     addend -= 2;
2145                   bfd_put_16 (input_bfd, addend, where);
2146                   break;
2147                 case 2:
2148                   if (howto->pc_relative)
2149                     addend -= 4;
2150                   bfd_put_32 (input_bfd, addend, where);
2151                   break;
2152                 }
2153             }
2154         }
2155       else
2156         {
2157           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2158           while (h->root.type == bfd_link_hash_indirect
2159                  || h->root.type == bfd_link_hash_warning)
2160             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2161
2162           relocation = 0;
2163           if (h->root.type == bfd_link_hash_defined
2164               || h->root.type == bfd_link_hash_defweak)
2165             {
2166               sec = h->root.u.def.section;
2167               if (sec->output_section == NULL)
2168                 /* Set a flag that will be cleared later if we find a
2169                    relocation value for this symbol.  output_section
2170                    is typically NULL for symbols satisfied by a shared
2171                    library.  */
2172                 unresolved_reloc = TRUE;
2173               else
2174                 relocation = (h->root.u.def.value
2175                               + sec->output_section->vma
2176                               + sec->output_offset);
2177             }
2178           else if (h->root.type == bfd_link_hash_undefweak)
2179             ;
2180           else if (info->shared
2181                    && !info->no_undefined
2182                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2183             ;
2184           else
2185             {
2186               if (! ((*info->callbacks->undefined_symbol)
2187                      (info, h->root.root.string, input_bfd,
2188                       input_section, rel->r_offset,
2189                       (!info->shared || info->no_undefined
2190                        || ELF_ST_VISIBILITY (h->other)))))
2191                 return FALSE;
2192             }
2193         }
2194
2195       switch (r_type)
2196         {
2197         case R_386_GOT32:
2198           /* Relocation is to the entry for this symbol in the global
2199              offset table.  */
2200           if (htab->sgot == NULL)
2201             abort ();
2202
2203           if (h != NULL)
2204             {
2205               bfd_boolean dyn;
2206
2207               off = h->got.offset;
2208               dyn = htab->elf.dynamic_sections_created;
2209               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2210                   || (info->shared
2211                       && SYMBOL_REFERENCES_LOCAL (info, h))
2212                   || (ELF_ST_VISIBILITY (h->other)
2213                       && h->root.type == bfd_link_hash_undefweak))
2214                 {
2215                   /* This is actually a static link, or it is a
2216                      -Bsymbolic link and the symbol is defined
2217                      locally, or the symbol was forced to be local
2218                      because of a version file.  We must initialize
2219                      this entry in the global offset table.  Since the
2220                      offset must always be a multiple of 4, we use the
2221                      least significant bit to record whether we have
2222                      initialized it already.
2223
2224                      When doing a dynamic link, we create a .rel.got
2225                      relocation entry to initialize the value.  This
2226                      is done in the finish_dynamic_symbol routine.  */
2227                   if ((off & 1) != 0)
2228                     off &= ~1;
2229                   else
2230                     {
2231                       bfd_put_32 (output_bfd, relocation,
2232                                   htab->sgot->contents + off);
2233                       h->got.offset |= 1;
2234                     }
2235                 }
2236               else
2237                 unresolved_reloc = FALSE;
2238             }
2239           else
2240             {
2241               if (local_got_offsets == NULL)
2242                 abort ();
2243
2244               off = local_got_offsets[r_symndx];
2245
2246               /* The offset must always be a multiple of 4.  We use
2247                  the least significant bit to record whether we have
2248                  already generated the necessary reloc.  */
2249               if ((off & 1) != 0)
2250                 off &= ~1;
2251               else
2252                 {
2253                   bfd_put_32 (output_bfd, relocation,
2254                               htab->sgot->contents + off);
2255
2256                   if (info->shared)
2257                     {
2258                       asection *s;
2259                       Elf_Internal_Rela outrel;
2260                       bfd_byte *loc;
2261
2262                       s = htab->srelgot;
2263                       if (s == NULL)
2264                         abort ();
2265
2266                       outrel.r_offset = (htab->sgot->output_section->vma
2267                                          + htab->sgot->output_offset
2268                                          + off);
2269                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2270                       loc = s->contents;
2271                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2272                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2273                     }
2274
2275                   local_got_offsets[r_symndx] |= 1;
2276                 }
2277             }
2278
2279           if (off >= (bfd_vma) -2)
2280             abort ();
2281
2282           relocation = htab->sgot->output_offset + off;
2283           break;
2284
2285         case R_386_GOTOFF:
2286           /* Relocation is relative to the start of the global offset
2287              table.  */
2288
2289           /* Note that sgot->output_offset is not involved in this
2290              calculation.  We always want the start of .got.  If we
2291              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2292              permitted by the ABI, we might have to change this
2293              calculation.  */
2294           relocation -= htab->sgot->output_section->vma;
2295           break;
2296
2297         case R_386_GOTPC:
2298           /* Use global offset table as symbol value.  */
2299           relocation = htab->sgot->output_section->vma;
2300           unresolved_reloc = FALSE;
2301           break;
2302
2303         case R_386_PLT32:
2304           /* Relocation is to the entry for this symbol in the
2305              procedure linkage table.  */
2306
2307           /* Resolve a PLT32 reloc against a local symbol directly,
2308              without using the procedure linkage table.  */
2309           if (h == NULL)
2310             break;
2311
2312           if (h->plt.offset == (bfd_vma) -1
2313               || htab->splt == NULL)
2314             {
2315               /* We didn't make a PLT entry for this symbol.  This
2316                  happens when statically linking PIC code, or when
2317                  using -Bsymbolic.  */
2318               break;
2319             }
2320
2321           relocation = (htab->splt->output_section->vma
2322                         + htab->splt->output_offset
2323                         + h->plt.offset);
2324           unresolved_reloc = FALSE;
2325           break;
2326
2327         case R_386_32:
2328         case R_386_PC32:
2329           /* r_symndx will be zero only for relocs against symbols
2330              from removed linkonce sections, or sections discarded by
2331              a linker script.  */
2332           if (r_symndx == 0
2333               || (input_section->flags & SEC_ALLOC) == 0)
2334             break;
2335
2336           if ((info->shared
2337                && (h == NULL
2338                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2339                    || h->root.type != bfd_link_hash_undefweak)
2340                && (r_type != R_386_PC32
2341                    || (h != NULL
2342                        && !SYMBOL_CALLS_LOCAL (info, h))))
2343               || (ELIMINATE_COPY_RELOCS
2344                   && !info->shared
2345                   && h != NULL
2346                   && h->dynindx != -1
2347                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2348                   && (((h->elf_link_hash_flags
2349                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2350                        && (h->elf_link_hash_flags
2351                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2352                       || h->root.type == bfd_link_hash_undefweak
2353                       || h->root.type == bfd_link_hash_undefined)))
2354             {
2355               Elf_Internal_Rela outrel;
2356               bfd_byte *loc;
2357               bfd_boolean skip, relocate;
2358               asection *sreloc;
2359
2360               /* When generating a shared object, these relocations
2361                  are copied into the output file to be resolved at run
2362                  time.  */
2363
2364               skip = FALSE;
2365               relocate = FALSE;
2366
2367               outrel.r_offset =
2368                 _bfd_elf_section_offset (output_bfd, info, input_section,
2369                                          rel->r_offset);
2370               if (outrel.r_offset == (bfd_vma) -1)
2371                 skip = TRUE;
2372               else if (outrel.r_offset == (bfd_vma) -2)
2373                 skip = TRUE, relocate = TRUE;
2374               outrel.r_offset += (input_section->output_section->vma
2375                                   + input_section->output_offset);
2376
2377               if (skip)
2378                 memset (&outrel, 0, sizeof outrel);
2379               else if (h != NULL
2380                        && h->dynindx != -1
2381                        && (r_type == R_386_PC32
2382                            || !info->shared
2383                            || !info->symbolic
2384                            || (h->elf_link_hash_flags
2385                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2386                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2387               else
2388                 {
2389                   /* This symbol is local, or marked to become local.  */
2390                   relocate = TRUE;
2391                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2392                 }
2393
2394               sreloc = elf_section_data (input_section)->sreloc;
2395               if (sreloc == NULL)
2396                 abort ();
2397
2398               loc = sreloc->contents;
2399               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2400               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2401
2402               /* If this reloc is against an external symbol, we do
2403                  not want to fiddle with the addend.  Otherwise, we
2404                  need to include the symbol value so that it becomes
2405                  an addend for the dynamic reloc.  */
2406               if (! relocate)
2407                 continue;
2408             }
2409           break;
2410
2411         case R_386_TLS_IE:
2412           if (info->shared)
2413             {
2414               Elf_Internal_Rela outrel;
2415               bfd_byte *loc;
2416               asection *sreloc;
2417
2418               outrel.r_offset = rel->r_offset
2419                                 + input_section->output_section->vma
2420                                 + input_section->output_offset;
2421               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2422               sreloc = elf_section_data (input_section)->sreloc;
2423               if (sreloc == NULL)
2424                 abort ();
2425               loc = sreloc->contents;
2426               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2427               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2428             }
2429           /* Fall through */
2430
2431         case R_386_TLS_GD:
2432         case R_386_TLS_IE_32:
2433         case R_386_TLS_GOTIE:
2434           r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2435           tls_type = GOT_UNKNOWN;
2436           if (h == NULL && local_got_offsets)
2437             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2438           else if (h != NULL)
2439             {
2440               tls_type = elf_i386_hash_entry(h)->tls_type;
2441               if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2442                 r_type = R_386_TLS_LE_32;
2443             }
2444           if (tls_type == GOT_TLS_IE)
2445             tls_type = GOT_TLS_IE_NEG;
2446           if (r_type == R_386_TLS_GD)
2447             {
2448               if (tls_type == GOT_TLS_IE_POS)
2449                 r_type = R_386_TLS_GOTIE;
2450               else if (tls_type & GOT_TLS_IE)
2451                 r_type = R_386_TLS_IE_32;
2452             }
2453
2454           if (r_type == R_386_TLS_LE_32)
2455             {
2456               BFD_ASSERT (! unresolved_reloc);
2457               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2458                 {
2459                   unsigned int val, type;
2460                   bfd_vma roff;
2461
2462                   /* GD->LE transition.  */
2463                   BFD_ASSERT (rel->r_offset >= 2);
2464                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2465                   BFD_ASSERT (type == 0x8d || type == 0x04);
2466                   BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2467                   BFD_ASSERT (bfd_get_8 (input_bfd,
2468                                          contents + rel->r_offset + 4)
2469                               == 0xe8);
2470                   BFD_ASSERT (rel + 1 < relend);
2471                   BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2472                   roff = rel->r_offset + 5;
2473                   val = bfd_get_8 (input_bfd,
2474                                    contents + rel->r_offset - 1);
2475                   if (type == 0x04)
2476                     {
2477                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2478                          Change it into:
2479                          movl %gs:0, %eax; subl $foo@tpoff, %eax
2480                          (6 byte form of subl).  */
2481                       BFD_ASSERT (rel->r_offset >= 3);
2482                       BFD_ASSERT (bfd_get_8 (input_bfd,
2483                                              contents + rel->r_offset - 3)
2484                                   == 0x8d);
2485                       BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2486                       memcpy (contents + rel->r_offset - 3,
2487                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2488                     }
2489                   else
2490                     {
2491                       BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2492                       if (rel->r_offset + 10 <= input_section->_raw_size
2493                           && bfd_get_8 (input_bfd,
2494                                         contents + rel->r_offset + 9) == 0x90)
2495                         {
2496                           /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2497                              Change it into:
2498                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2499                              (6 byte form of subl).  */
2500                           memcpy (contents + rel->r_offset - 2,
2501                                   "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2502                           roff = rel->r_offset + 6;
2503                         }
2504                       else
2505                         {
2506                           /* leal foo(%reg), %eax; call ___tls_get_addr
2507                              Change it into:
2508                              movl %gs:0, %eax; subl $foo@tpoff, %eax
2509                              (5 byte form of subl).  */
2510                           memcpy (contents + rel->r_offset - 2,
2511                                   "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2512                         }
2513                     }
2514                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2515                               contents + roff);
2516                   /* Skip R_386_PLT32.  */
2517                   rel++;
2518                   continue;
2519                 }
2520               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2521                 {
2522                   unsigned int val, type;
2523
2524                   /* IE->LE transition:
2525                      Originally it can be one of:
2526                      movl foo, %eax
2527                      movl foo, %reg
2528                      addl foo, %reg
2529                      We change it into:
2530                      movl $foo, %eax
2531                      movl $foo, %reg
2532                      addl $foo, %reg.  */
2533                   BFD_ASSERT (rel->r_offset >= 1);
2534                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2535                   BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2536                   if (val == 0xa1)
2537                     {
2538                       /* movl foo, %eax.  */
2539                       bfd_put_8 (output_bfd, 0xb8,
2540                                  contents + rel->r_offset - 1);
2541                     }
2542                   else
2543                     {
2544                       BFD_ASSERT (rel->r_offset >= 2);
2545                       type = bfd_get_8 (input_bfd,
2546                                         contents + rel->r_offset - 2);
2547                       switch (type)
2548                         {
2549                         case 0x8b:
2550                           /* movl */
2551                           BFD_ASSERT ((val & 0xc7) == 0x05);
2552                           bfd_put_8 (output_bfd, 0xc7,
2553                                      contents + rel->r_offset - 2);
2554                           bfd_put_8 (output_bfd,
2555                                      0xc0 | ((val >> 3) & 7),
2556                                      contents + rel->r_offset - 1);
2557                           break;
2558                         case 0x03:
2559                           /* addl */
2560                           BFD_ASSERT ((val & 0xc7) == 0x05);
2561                           bfd_put_8 (output_bfd, 0x81,
2562                                      contents + rel->r_offset - 2);
2563                           bfd_put_8 (output_bfd,
2564                                      0xc0 | ((val >> 3) & 7),
2565                                      contents + rel->r_offset - 1);
2566                           break;
2567                         default:
2568                           BFD_FAIL ();
2569                           break;
2570                         }
2571                     }
2572                   bfd_put_32 (output_bfd, -tpoff (info, relocation),
2573                               contents + rel->r_offset);
2574                   continue;
2575                 }
2576               else
2577                 {
2578                   unsigned int val, type;
2579
2580                   /* {IE_32,GOTIE}->LE transition:
2581                      Originally it can be one of:
2582                      subl foo(%reg1), %reg2
2583                      movl foo(%reg1), %reg2
2584                      addl foo(%reg1), %reg2
2585                      We change it into:
2586                      subl $foo, %reg2
2587                      movl $foo, %reg2 (6 byte form)
2588                      addl $foo, %reg2.  */
2589                   BFD_ASSERT (rel->r_offset >= 2);
2590                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2591                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2592                   BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2593                   BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2594                   if (type == 0x8b)
2595                     {
2596                       /* movl */
2597                       bfd_put_8 (output_bfd, 0xc7,
2598                                  contents + rel->r_offset - 2);
2599                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2600                                  contents + rel->r_offset - 1);
2601                     }
2602                   else if (type == 0x2b)
2603                     {
2604                       /* subl */
2605                       bfd_put_8 (output_bfd, 0x81,
2606                                  contents + rel->r_offset - 2);
2607                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2608                                  contents + rel->r_offset - 1);
2609                     }
2610                   else if (type == 0x03)
2611                     {
2612                       /* addl */
2613                       bfd_put_8 (output_bfd, 0x81,
2614                                  contents + rel->r_offset - 2);
2615                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2616                                  contents + rel->r_offset - 1);
2617                     }
2618                   else
2619                     BFD_FAIL ();
2620                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2621                     bfd_put_32 (output_bfd, -tpoff (info, relocation),
2622                                 contents + rel->r_offset);
2623                   else
2624                     bfd_put_32 (output_bfd, tpoff (info, relocation),
2625                                 contents + rel->r_offset);
2626                   continue;
2627                 }
2628             }
2629
2630           if (htab->sgot == NULL)
2631             abort ();
2632
2633           if (h != NULL)
2634             off = h->got.offset;
2635           else
2636             {
2637               if (local_got_offsets == NULL)
2638                 abort ();
2639
2640               off = local_got_offsets[r_symndx];
2641             }
2642
2643           if ((off & 1) != 0)
2644             off &= ~1;
2645           else
2646             {
2647               Elf_Internal_Rela outrel;
2648               bfd_byte *loc;
2649               int dr_type, indx;
2650
2651               if (htab->srelgot == NULL)
2652                 abort ();
2653
2654               outrel.r_offset = (htab->sgot->output_section->vma
2655                                  + htab->sgot->output_offset + off);
2656
2657               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2658               if (r_type == R_386_TLS_GD)
2659                 dr_type = R_386_TLS_DTPMOD32;
2660               else if (tls_type == GOT_TLS_IE_POS)
2661                 dr_type = R_386_TLS_TPOFF;
2662               else
2663                 dr_type = R_386_TLS_TPOFF32;
2664               if (dr_type == R_386_TLS_TPOFF && indx == 0)
2665                 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2666                             htab->sgot->contents + off);
2667               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2668                 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
2669                             htab->sgot->contents + off);
2670               else
2671                 bfd_put_32 (output_bfd, 0,
2672                             htab->sgot->contents + off);
2673               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2674               loc = htab->srelgot->contents;
2675               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2676               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2677
2678               if (r_type == R_386_TLS_GD)
2679                 {
2680                   if (indx == 0)
2681                     {
2682                       BFD_ASSERT (! unresolved_reloc);
2683                       bfd_put_32 (output_bfd,
2684                                   relocation - dtpoff_base (info),
2685                                   htab->sgot->contents + off + 4);
2686                     }
2687                   else
2688                     {
2689                       bfd_put_32 (output_bfd, 0,
2690                                   htab->sgot->contents + off + 4);
2691                       outrel.r_info = ELF32_R_INFO (indx,
2692                                                     R_386_TLS_DTPOFF32);
2693                       outrel.r_offset += 4;
2694                       htab->srelgot->reloc_count++;
2695                       loc += sizeof (Elf32_External_Rel);
2696                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2697                     }
2698                 }
2699               else if (tls_type == GOT_TLS_IE_BOTH)
2700                 {
2701                   bfd_put_32 (output_bfd,
2702                               indx == 0 ? relocation - dtpoff_base (info) : 0,
2703                               htab->sgot->contents + off + 4);
2704                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2705                   outrel.r_offset += 4;
2706                   htab->srelgot->reloc_count++;
2707                   loc += sizeof (Elf32_External_Rel);
2708                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2709                 }
2710
2711               if (h != NULL)
2712                 h->got.offset |= 1;
2713               else
2714                 local_got_offsets[r_symndx] |= 1;
2715             }
2716
2717           if (off >= (bfd_vma) -2)
2718             abort ();
2719           if (r_type == ELF32_R_TYPE (rel->r_info))
2720             {
2721               relocation = htab->sgot->output_offset + off;
2722               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2723                   && tls_type == GOT_TLS_IE_BOTH)
2724                 relocation += 4;
2725               if (r_type == R_386_TLS_IE)
2726                 relocation += htab->sgot->output_section->vma;
2727               unresolved_reloc = FALSE;
2728             }
2729           else
2730             {
2731               unsigned int val, type;
2732               bfd_vma roff;
2733
2734               /* GD->IE transition.  */
2735               BFD_ASSERT (rel->r_offset >= 2);
2736               type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2737               BFD_ASSERT (type == 0x8d || type == 0x04);
2738               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2739               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2740                           == 0xe8);
2741               BFD_ASSERT (rel + 1 < relend);
2742               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2743               roff = rel->r_offset - 3;
2744               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2745               if (type == 0x04)
2746                 {
2747                   /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2748                      Change it into:
2749                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2750                   BFD_ASSERT (rel->r_offset >= 3);
2751                   BFD_ASSERT (bfd_get_8 (input_bfd,
2752                                          contents + rel->r_offset - 3)
2753                               == 0x8d);
2754                   BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2755                   val >>= 3;
2756                 }
2757               else
2758                 {
2759                   /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2760                      Change it into:
2761                      movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
2762                   BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2763                   BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2764                   BFD_ASSERT (bfd_get_8 (input_bfd,
2765                                          contents + rel->r_offset + 9)
2766                               == 0x90);
2767                   roff = rel->r_offset - 2;
2768                 }
2769               memcpy (contents + roff,
2770                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2771               contents[roff + 7] = 0x80 | (val & 7);
2772               /* If foo is used only with foo@gotntpoff(%reg) and
2773                  foo@indntpoff, but not with foo@gottpoff(%reg), change
2774                  subl $foo@gottpoff(%reg), %eax
2775                  into:
2776                  addl $foo@gotntpoff(%reg), %eax.  */
2777               if (r_type == R_386_TLS_GOTIE)
2778                 {
2779                   contents[roff + 6] = 0x03;
2780                   if (tls_type == GOT_TLS_IE_BOTH)
2781                     off += 4;
2782                 }
2783               bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2784                           contents + roff + 8);
2785               /* Skip R_386_PLT32.  */
2786               rel++;
2787               continue;
2788             }
2789           break;
2790
2791         case R_386_TLS_LDM:
2792           if (! info->shared)
2793             {
2794               unsigned int val;
2795
2796               /* LD->LE transition:
2797                  Ensure it is:
2798                  leal foo(%reg), %eax; call ___tls_get_addr.
2799                  We change it into:
2800                  movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
2801               BFD_ASSERT (rel->r_offset >= 2);
2802               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2803                           == 0x8d);
2804               val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2805               BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2806               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2807               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2808                           == 0xe8);
2809               BFD_ASSERT (rel + 1 < relend);
2810               BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2811               memcpy (contents + rel->r_offset - 2,
2812                       "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2813               /* Skip R_386_PLT32.  */
2814               rel++;
2815               continue;
2816             }
2817
2818           if (htab->sgot == NULL)
2819             abort ();
2820
2821           off = htab->tls_ldm_got.offset;
2822           if (off & 1)
2823             off &= ~1;
2824           else
2825             {
2826               Elf_Internal_Rela outrel;
2827               bfd_byte *loc;
2828
2829               if (htab->srelgot == NULL)
2830                 abort ();
2831
2832               outrel.r_offset = (htab->sgot->output_section->vma
2833                                  + htab->sgot->output_offset + off);
2834
2835               bfd_put_32 (output_bfd, 0,
2836                           htab->sgot->contents + off);
2837               bfd_put_32 (output_bfd, 0,
2838                           htab->sgot->contents + off + 4);
2839               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2840               loc = htab->srelgot->contents;
2841               loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2842               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2843               htab->tls_ldm_got.offset |= 1;
2844             }
2845           relocation = htab->sgot->output_offset + off;
2846           unresolved_reloc = FALSE;
2847           break;
2848
2849         case R_386_TLS_LDO_32:
2850           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2851             relocation -= dtpoff_base (info);
2852           else
2853             /* When converting LDO to LE, we must negate.  */
2854             relocation = -tpoff (info, relocation);
2855           break;
2856
2857         case R_386_TLS_LE_32:
2858         case R_386_TLS_LE:
2859           if (info->shared)
2860             {
2861               Elf_Internal_Rela outrel;
2862               asection *sreloc;
2863               bfd_byte *loc;
2864               int indx;
2865
2866               outrel.r_offset = rel->r_offset
2867                                 + input_section->output_section->vma
2868                                 + input_section->output_offset;
2869               if (h != NULL && h->dynindx != -1)
2870                 indx = h->dynindx;
2871               else
2872                 indx = 0;
2873               if (r_type == R_386_TLS_LE_32)
2874                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2875               else
2876                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2877               sreloc = elf_section_data (input_section)->sreloc;
2878               if (sreloc == NULL)
2879                 abort ();
2880               loc = sreloc->contents;
2881               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2882               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2883               if (indx)
2884                 continue;
2885               else if (r_type == R_386_TLS_LE_32)
2886                 relocation = dtpoff_base (info) - relocation;
2887               else
2888                 relocation -= dtpoff_base (info);
2889             }
2890           else if (r_type == R_386_TLS_LE_32)
2891             relocation = tpoff (info, relocation);
2892           else
2893             relocation = -tpoff (info, relocation);
2894           break;
2895
2896         default:
2897           break;
2898         }
2899
2900       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2901          because such sections are not SEC_ALLOC and thus ld.so will
2902          not process them.  */
2903       if (unresolved_reloc
2904           && !((input_section->flags & SEC_DEBUGGING) != 0
2905                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2906         {
2907           (*_bfd_error_handler)
2908             (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2909              bfd_archive_filename (input_bfd),
2910              bfd_get_section_name (input_bfd, input_section),
2911              (long) rel->r_offset,
2912              h->root.root.string);
2913           return FALSE;
2914         }
2915
2916       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2917                                     contents, rel->r_offset,
2918                                     relocation, 0);
2919
2920       if (r != bfd_reloc_ok)
2921         {
2922           const char *name;
2923
2924           if (h != NULL)
2925             name = h->root.root.string;
2926           else
2927             {
2928               name = bfd_elf_string_from_elf_section (input_bfd,
2929                                                       symtab_hdr->sh_link,
2930                                                       sym->st_name);
2931               if (name == NULL)
2932                 return FALSE;
2933               if (*name == '\0')
2934                 name = bfd_section_name (input_bfd, sec);
2935             }
2936
2937           if (r == bfd_reloc_overflow)
2938             {
2939               if (! ((*info->callbacks->reloc_overflow)
2940                      (info, name, howto->name, 0,
2941                       input_bfd, input_section, rel->r_offset)))
2942                 return FALSE;
2943             }
2944           else
2945             {
2946               (*_bfd_error_handler)
2947                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2948                  bfd_archive_filename (input_bfd),
2949                  bfd_get_section_name (input_bfd, input_section),
2950                  (long) rel->r_offset, name, (int) r);
2951               return FALSE;
2952             }
2953         }
2954     }
2955
2956   return TRUE;
2957 }
2958
2959 /* Finish up dynamic symbol handling.  We set the contents of various
2960    dynamic sections here.  */
2961
2962 static bfd_boolean
2963 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
2964                                 struct bfd_link_info *info,
2965                                 struct elf_link_hash_entry *h,
2966                                 Elf_Internal_Sym *sym)
2967 {
2968   struct elf_i386_link_hash_table *htab;
2969
2970   htab = elf_i386_hash_table (info);
2971
2972   if (h->plt.offset != (bfd_vma) -1)
2973     {
2974       bfd_vma plt_index;
2975       bfd_vma got_offset;
2976       Elf_Internal_Rela rel;
2977       bfd_byte *loc;
2978
2979       /* This symbol has an entry in the procedure linkage table.  Set
2980          it up.  */
2981
2982       if (h->dynindx == -1
2983           || htab->splt == NULL
2984           || htab->sgotplt == NULL
2985           || htab->srelplt == NULL)
2986         abort ();
2987
2988       /* Get the index in the procedure linkage table which
2989          corresponds to this symbol.  This is the index of this symbol
2990          in all the symbols for which we are making plt entries.  The
2991          first entry in the procedure linkage table is reserved.  */
2992       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2993
2994       /* Get the offset into the .got table of the entry that
2995          corresponds to this function.  Each .got entry is 4 bytes.
2996          The first three are reserved.  */
2997       got_offset = (plt_index + 3) * 4;
2998
2999       /* Fill in the entry in the procedure linkage table.  */
3000       if (! info->shared)
3001         {
3002           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3003                   PLT_ENTRY_SIZE);
3004           bfd_put_32 (output_bfd,
3005                       (htab->sgotplt->output_section->vma
3006                        + htab->sgotplt->output_offset
3007                        + got_offset),
3008                       htab->splt->contents + h->plt.offset + 2);
3009         }
3010       else
3011         {
3012           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3013                   PLT_ENTRY_SIZE);
3014           bfd_put_32 (output_bfd, got_offset,
3015                       htab->splt->contents + h->plt.offset + 2);
3016         }
3017
3018       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3019                   htab->splt->contents + h->plt.offset + 7);
3020       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3021                   htab->splt->contents + h->plt.offset + 12);
3022
3023       /* Fill in the entry in the global offset table.  */
3024       bfd_put_32 (output_bfd,
3025                   (htab->splt->output_section->vma
3026                    + htab->splt->output_offset
3027                    + h->plt.offset
3028                    + 6),
3029                   htab->sgotplt->contents + got_offset);
3030
3031       /* Fill in the entry in the .rel.plt section.  */
3032       rel.r_offset = (htab->sgotplt->output_section->vma
3033                       + htab->sgotplt->output_offset
3034                       + got_offset);
3035       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3036       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3037       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3038
3039       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3040         {
3041           /* Mark the symbol as undefined, rather than as defined in
3042              the .plt section.  Leave the value alone.  This is a clue
3043              for the dynamic linker, to make function pointer
3044              comparisons work between an application and shared
3045              library.  */
3046           sym->st_shndx = SHN_UNDEF;
3047         }
3048     }
3049
3050   if (h->got.offset != (bfd_vma) -1
3051       && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
3052       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3053     {
3054       Elf_Internal_Rela rel;
3055       bfd_byte *loc;
3056
3057       /* This symbol has an entry in the global offset table.  Set it
3058          up.  */
3059
3060       if (htab->sgot == NULL || htab->srelgot == NULL)
3061         abort ();
3062
3063       rel.r_offset = (htab->sgot->output_section->vma
3064                       + htab->sgot->output_offset
3065                       + (h->got.offset & ~(bfd_vma) 1));
3066
3067       /* If this is a static link, or it is a -Bsymbolic link and the
3068          symbol is defined locally or was forced to be local because
3069          of a version file, we just want to emit a RELATIVE reloc.
3070          The entry in the global offset table will already have been
3071          initialized in the relocate_section function.  */
3072       if (info->shared
3073           && SYMBOL_REFERENCES_LOCAL (info, h))
3074         {
3075           BFD_ASSERT((h->got.offset & 1) != 0);
3076           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3077         }
3078       else
3079         {
3080           BFD_ASSERT((h->got.offset & 1) == 0);
3081           bfd_put_32 (output_bfd, (bfd_vma) 0,
3082                       htab->sgot->contents + h->got.offset);
3083           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3084         }
3085
3086       loc = htab->srelgot->contents;
3087       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3088       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3089     }
3090
3091   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3092     {
3093       Elf_Internal_Rela rel;
3094       bfd_byte *loc;
3095
3096       /* This symbol needs a copy reloc.  Set it up.  */
3097
3098       if (h->dynindx == -1
3099           || (h->root.type != bfd_link_hash_defined
3100               && h->root.type != bfd_link_hash_defweak)
3101           || htab->srelbss == NULL)
3102         abort ();
3103
3104       rel.r_offset = (h->root.u.def.value
3105                       + h->root.u.def.section->output_section->vma
3106                       + h->root.u.def.section->output_offset);
3107       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3108       loc = htab->srelbss->contents;
3109       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3110       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3111     }
3112
3113   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3114   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3115       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3116     sym->st_shndx = SHN_ABS;
3117
3118   return TRUE;
3119 }
3120
3121 /* Used to decide how to sort relocs in an optimal manner for the
3122    dynamic linker, before writing them out.  */
3123
3124 static enum elf_reloc_type_class
3125 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3126 {
3127   switch (ELF32_R_TYPE (rela->r_info))
3128     {
3129     case R_386_RELATIVE:
3130       return reloc_class_relative;
3131     case R_386_JUMP_SLOT:
3132       return reloc_class_plt;
3133     case R_386_COPY:
3134       return reloc_class_copy;
3135     default:
3136       return reloc_class_normal;
3137     }
3138 }
3139
3140 /* Finish up the dynamic sections.  */
3141
3142 static bfd_boolean
3143 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3144                                   struct bfd_link_info *info)
3145 {
3146   struct elf_i386_link_hash_table *htab;
3147   bfd *dynobj;
3148   asection *sdyn;
3149
3150   htab = elf_i386_hash_table (info);
3151   dynobj = htab->elf.dynobj;
3152   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3153
3154   if (htab->elf.dynamic_sections_created)
3155     {
3156       Elf32_External_Dyn *dyncon, *dynconend;
3157
3158       if (sdyn == NULL || htab->sgot == NULL)
3159         abort ();
3160
3161       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3162       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3163       for (; dyncon < dynconend; dyncon++)
3164         {
3165           Elf_Internal_Dyn dyn;
3166           asection *s;
3167
3168           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3169
3170           switch (dyn.d_tag)
3171             {
3172             default:
3173               continue;
3174
3175             case DT_PLTGOT:
3176               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3177               break;
3178
3179             case DT_JMPREL:
3180               s = htab->srelplt;
3181               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3182               break;
3183
3184             case DT_PLTRELSZ:
3185               s = htab->srelplt;
3186               dyn.d_un.d_val = s->_raw_size;
3187               break;
3188
3189             case DT_RELSZ:
3190               /* My reading of the SVR4 ABI indicates that the
3191                  procedure linkage table relocs (DT_JMPREL) should be
3192                  included in the overall relocs (DT_REL).  This is
3193                  what Solaris does.  However, UnixWare can not handle
3194                  that case.  Therefore, we override the DT_RELSZ entry
3195                  here to make it not include the JMPREL relocs.  */
3196               s = htab->srelplt;
3197               if (s == NULL)
3198                 continue;
3199               dyn.d_un.d_val -= s->_raw_size;
3200               break;
3201
3202             case DT_REL:
3203               /* We may not be using the standard ELF linker script.
3204                  If .rel.plt is the first .rel section, we adjust
3205                  DT_REL to not include it.  */
3206               s = htab->srelplt;
3207               if (s == NULL)
3208                 continue;
3209               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3210                 continue;
3211               dyn.d_un.d_ptr += s->_raw_size;
3212               break;
3213             }
3214
3215           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3216         }
3217
3218       /* Fill in the first entry in the procedure linkage table.  */
3219       if (htab->splt && htab->splt->_raw_size > 0)
3220         {
3221           if (info->shared)
3222             memcpy (htab->splt->contents,
3223                     elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
3224           else
3225             {
3226               memcpy (htab->splt->contents,
3227                       elf_i386_plt0_entry, PLT_ENTRY_SIZE);
3228               bfd_put_32 (output_bfd,
3229                           (htab->sgotplt->output_section->vma
3230                            + htab->sgotplt->output_offset
3231                            + 4),
3232                           htab->splt->contents + 2);
3233               bfd_put_32 (output_bfd,
3234                           (htab->sgotplt->output_section->vma
3235                            + htab->sgotplt->output_offset
3236                            + 8),
3237                           htab->splt->contents + 8);
3238             }
3239
3240           /* UnixWare sets the entsize of .plt to 4, although that doesn't
3241              really seem like the right value.  */
3242           elf_section_data (htab->splt->output_section)
3243             ->this_hdr.sh_entsize = 4;
3244         }
3245     }
3246
3247   if (htab->sgotplt)
3248     {
3249       /* Fill in the first three entries in the global offset table.  */
3250       if (htab->sgotplt->_raw_size > 0)
3251         {
3252           bfd_put_32 (output_bfd,
3253                       (sdyn == NULL ? 0
3254                        : sdyn->output_section->vma + sdyn->output_offset),
3255                       htab->sgotplt->contents);
3256           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3257           bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
3258         }
3259
3260       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3261     }
3262   return TRUE;
3263 }
3264
3265 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
3266 #define TARGET_LITTLE_NAME              "elf32-i386"
3267 #define ELF_ARCH                        bfd_arch_i386
3268 #define ELF_MACHINE_CODE                EM_386
3269 #define ELF_MAXPAGESIZE                 0x1000
3270
3271 #define elf_backend_can_gc_sections     1
3272 #define elf_backend_can_refcount        1
3273 #define elf_backend_want_got_plt        1
3274 #define elf_backend_plt_readonly        1
3275 #define elf_backend_want_plt_sym        0
3276 #define elf_backend_got_header_size     12
3277 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3278
3279 /* Support RELA for objdump of prelink objects.  */
3280 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
3281 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
3282
3283 #define bfd_elf32_mkobject                    elf_i386_mkobject
3284 #define elf_backend_object_p                  elf_i386_object_p
3285
3286 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3287 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3288 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
3289
3290 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3291 #define elf_backend_check_relocs              elf_i386_check_relocs
3292 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
3293 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
3294 #define elf_backend_fake_sections             elf_i386_fake_sections
3295 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
3296 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
3297 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
3298 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
3299 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
3300 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
3301 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
3302 #define elf_backend_relocate_section          elf_i386_relocate_section
3303 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
3304
3305 #include "elf32-target.h"
3306
3307 /* FreeBSD support.  */
3308
3309 #undef  TARGET_LITTLE_SYM
3310 #define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3311 #undef  TARGET_LITTLE_NAME
3312 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
3313
3314 /* The kernel recognizes executables as valid only if they carry a
3315    "FreeBSD" label in the ELF header.  So we put this label on all
3316    executables and (for simplicity) also all other object files.  */
3317
3318 static void
3319 elf_i386_post_process_headers (bfd *abfd,
3320                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
3321 {
3322   Elf_Internal_Ehdr *i_ehdrp;
3323
3324   i_ehdrp = elf_elfheader (abfd);
3325
3326   /* Put an ABI label supported by FreeBSD >= 4.1.  */
3327   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3328 #ifdef OLD_FREEBSD_ABI_LABEL
3329   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3330   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3331 #endif
3332 }
3333
3334 #undef  elf_backend_post_process_headers
3335 #define elf_backend_post_process_headers        elf_i386_post_process_headers
3336 #undef  elf32_bed
3337 #define elf32_bed                               elf32_i386_fbsd_bed
3338
3339 #include "elf32-target.h"