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
   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 static reloc_howto_type *elf_i386_reloc_type_lookup
  28   PARAMS ((bfd *, bfd_reloc_code_real_type));
  29 static void elf_i386_info_to_howto
  30   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
  31 static void elf_i386_info_to_howto_rel
  32   PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
  33 static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
  34 static struct bfd_hash_entry *elf_i386_link_hash_newfunc
  35   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  36 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
  37   PARAMS ((bfd *));
  38 static boolean create_got_section PARAMS((bfd *, struct bfd_link_info *));
  39 static boolean elf_i386_create_dynamic_sections
  40   PARAMS((bfd *, struct bfd_link_info *));
  41 static boolean elf_i386_check_relocs
  42   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  43            const Elf_Internal_Rela *));
  44 static asection *elf_i386_gc_mark_hook
  45   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
  46            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  47 static boolean elf_i386_gc_sweep_hook
  48   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  49            const Elf_Internal_Rela *));
  50 static boolean elf_i386_adjust_dynamic_symbol
  51   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  52 static boolean allocate_dynrelocs
  53   PARAMS ((struct elf_link_hash_entry *, PTR));
  54 static boolean readonly_dynrelocs
  55   PARAMS ((struct elf_link_hash_entry *, PTR));
  56 static boolean elf_i386_size_dynamic_sections
  57   PARAMS ((bfd *, struct bfd_link_info *));
  58 static boolean elf_i386_relocate_section
  59   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  60            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  61 static boolean elf_i386_finish_dynamic_symbol
  62   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  63            Elf_Internal_Sym *));
  64 static boolean elf_i386_finish_dynamic_sections
  65   PARAMS ((bfd *, struct bfd_link_info *));
  66 static boolean elf_i386_fake_sections
  67   PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
  68 static enum elf_reloc_type_class elf_i386_reloc_type_class
  69   PARAMS ((const Elf_Internal_Rela *));
  70 static boolean elf_i386_grok_prstatus
  71   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
  72 static boolean elf_i386_grok_psinfo
  73   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
  74
  75 #define USE_REL 1               /* 386 uses REL relocations instead of RELA */
  76
  77 #include "elf/i386.h"
  78
  79 static reloc_howto_type elf_howto_table[]=
  80 {
  81   HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
  82         bfd_elf_generic_reloc, "R_386_NONE",
  83         true, 0x00000000, 0x00000000, false),
  84   HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
  85         bfd_elf_generic_reloc, "R_386_32",
  86         true, 0xffffffff, 0xffffffff, false),
  87   HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
  88         bfd_elf_generic_reloc, "R_386_PC32",
  89         true, 0xffffffff, 0xffffffff, true),
  90   HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
  91         bfd_elf_generic_reloc, "R_386_GOT32",
  92         true, 0xffffffff, 0xffffffff, false),
  93   HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
  94         bfd_elf_generic_reloc, "R_386_PLT32",
  95         true, 0xffffffff, 0xffffffff, true),
  96   HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
  97         bfd_elf_generic_reloc, "R_386_COPY",
  98         true, 0xffffffff, 0xffffffff, false),
  99   HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
 100         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
 101         true, 0xffffffff, 0xffffffff, false),
 102   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
 103         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
 104         true, 0xffffffff, 0xffffffff, false),
 105   HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
 106         bfd_elf_generic_reloc, "R_386_RELATIVE",
 107         true, 0xffffffff, 0xffffffff, false),
 108   HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
 109         bfd_elf_generic_reloc, "R_386_GOTOFF",
 110         true, 0xffffffff, 0xffffffff, false),
 111   HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
 112         bfd_elf_generic_reloc, "R_386_GOTPC",
 113         true, 0xffffffff, 0xffffffff, true),
 114
 115   /* We have a gap in the reloc numbers here.
 116      R_386_standard counts the number up to this point, and
 117      R_386_ext_offset is the value to subtract from a reloc type of
 118      R_386_16 thru R_386_PC8 to form an index into this table.  */
 119 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
 120 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
 121
 122   /* The remaining relocs are a GNU extension.  */
 123   HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
 124         bfd_elf_generic_reloc, "R_386_16",
 125         true, 0xffff, 0xffff, false),
 126   HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
 127         bfd_elf_generic_reloc, "R_386_PC16",
 128         true, 0xffff, 0xffff, true),
 129   HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
 130         bfd_elf_generic_reloc, "R_386_8",
 131         true, 0xff, 0xff, false),
 132   HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
 133         bfd_elf_generic_reloc, "R_386_PC8",
 134         true, 0xff, 0xff, true),
 135
 136   /* Another gap.  */
 137 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
 138 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
 139
 140 /* GNU extension to record C++ vtable hierarchy.  */
 141   HOWTO (R_386_GNU_VTINHERIT,   /* type */
 142          0,                     /* rightshift */
 143          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 144          0,                     /* bitsize */
 145          false,                 /* pc_relative */
 146          0,                     /* bitpos */
 147          complain_overflow_dont, /* complain_on_overflow */
 148          NULL,                  /* special_function */
 149          "R_386_GNU_VTINHERIT", /* name */
 150          false,                 /* partial_inplace */
 151          0,                     /* src_mask */
 152          0,                     /* dst_mask */
 153          false),
 154
 155 /* GNU extension to record C++ vtable member usage.  */
 156   HOWTO (R_386_GNU_VTENTRY,     /* type */
 157          0,                     /* rightshift */
 158          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 159          0,                     /* bitsize */
 160          false,                 /* pc_relative */
 161          0,                     /* bitpos */
 162          complain_overflow_dont, /* complain_on_overflow */
 163          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 164          "R_386_GNU_VTENTRY",   /* name */
 165          false,                 /* partial_inplace */
 166          0,                     /* src_mask */
 167          0,                     /* dst_mask */
 168          false)
 169
 170 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
 171
 172 };
 173
 174 #ifdef DEBUG_GEN_RELOC
 175 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 176 #else
 177 #define TRACE(str)
 178 #endif
 179
 180 static reloc_howto_type *
 181 elf_i386_reloc_type_lookup (abfd, code)
 182      bfd *abfd ATTRIBUTE_UNUSED;
 183      bfd_reloc_code_real_type code;
 184 {
 185   switch (code)
 186     {
 187     case BFD_RELOC_NONE:
 188       TRACE ("BFD_RELOC_NONE");
 189       return &elf_howto_table[(unsigned int) R_386_NONE ];
 190
 191     case BFD_RELOC_32:
 192       TRACE ("BFD_RELOC_32");
 193       return &elf_howto_table[(unsigned int) R_386_32 ];
 194
 195     case BFD_RELOC_CTOR:
 196       TRACE ("BFD_RELOC_CTOR");
 197       return &elf_howto_table[(unsigned int) R_386_32 ];
 198
 199     case BFD_RELOC_32_PCREL:
 200       TRACE ("BFD_RELOC_PC32");
 201       return &elf_howto_table[(unsigned int) R_386_PC32 ];
 202
 203     case BFD_RELOC_386_GOT32:
 204       TRACE ("BFD_RELOC_386_GOT32");
 205       return &elf_howto_table[(unsigned int) R_386_GOT32 ];
 206
 207     case BFD_RELOC_386_PLT32:
 208       TRACE ("BFD_RELOC_386_PLT32");
 209       return &elf_howto_table[(unsigned int) R_386_PLT32 ];
 210
 211     case BFD_RELOC_386_COPY:
 212       TRACE ("BFD_RELOC_386_COPY");
 213       return &elf_howto_table[(unsigned int) R_386_COPY ];
 214
 215     case BFD_RELOC_386_GLOB_DAT:
 216       TRACE ("BFD_RELOC_386_GLOB_DAT");
 217       return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
 218
 219     case BFD_RELOC_386_JUMP_SLOT:
 220       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 221       return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
 222
 223     case BFD_RELOC_386_RELATIVE:
 224       TRACE ("BFD_RELOC_386_RELATIVE");
 225       return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
 226
 227     case BFD_RELOC_386_GOTOFF:
 228       TRACE ("BFD_RELOC_386_GOTOFF");
 229       return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
 230
 231     case BFD_RELOC_386_GOTPC:
 232       TRACE ("BFD_RELOC_386_GOTPC");
 233       return &elf_howto_table[(unsigned int) R_386_GOTPC ];
 234
 235       /* The remaining relocs are a GNU extension.  */
 236     case BFD_RELOC_16:
 237       TRACE ("BFD_RELOC_16");
 238       return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
 239
 240     case BFD_RELOC_16_PCREL:
 241       TRACE ("BFD_RELOC_16_PCREL");
 242       return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
 243
 244     case BFD_RELOC_8:
 245       TRACE ("BFD_RELOC_8");
 246       return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
 247
 248     case BFD_RELOC_8_PCREL:
 249       TRACE ("BFD_RELOC_8_PCREL");
 250       return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
 251
 252     case BFD_RELOC_VTABLE_INHERIT:
 253       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 254       return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
 255                              - R_386_vt_offset];
 256
 257     case BFD_RELOC_VTABLE_ENTRY:
 258       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 259       return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
 260                              - R_386_vt_offset];
 261
 262     default:
 263       break;
 264     }
 265
 266   TRACE ("Unknown");
 267   return 0;
 268 }
 269
 270 static void
 271 elf_i386_info_to_howto (abfd, cache_ptr, dst)
 272      bfd                *abfd ATTRIBUTE_UNUSED;
 273      arelent            *cache_ptr ATTRIBUTE_UNUSED;
 274      Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
 275 {
 276   abort ();
 277 }
 278
 279 static void
 280 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
 281      bfd *abfd ATTRIBUTE_UNUSED;
 282      arelent *cache_ptr;
 283      Elf32_Internal_Rel *dst;
 284 {
 285   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 286   unsigned int indx;
 287
 288   if ((indx = r_type) >= R_386_standard
 289       && ((indx = r_type - R_386_ext_offset) - R_386_standard
 290           >= R_386_ext - R_386_standard)
 291       && ((indx = r_type - R_386_vt_offset) - R_386_ext
 292           >= R_386_vt - R_386_ext))
 293     {
 294       (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
 295                              bfd_archive_filename (abfd), (int) r_type);
 296       indx = (unsigned int) R_386_NONE;
 297     }
 298   cache_ptr->howto = &elf_howto_table[indx];
 299 }
 300
 301 /* Return whether a symbol name implies a local label.  The UnixWare
 302    2.1 cc generates temporary symbols that start with .X, so we
 303    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
 304    If so, we should move the .X recognition into
 305    _bfd_elf_is_local_label_name.  */
 306
 307 static boolean
 308 elf_i386_is_local_label_name (abfd, name)
 309      bfd *abfd;
 310      const char *name;
 311 {
 312   if (name[0] == '.' && name[1] == 'X')
 313     return true;
 314
 315   return _bfd_elf_is_local_label_name (abfd, name);
 316 }
 317 \f
 318 /* Functions for the i386 ELF linker.  */
 319
 320 /* The name of the dynamic interpreter.  This is put in the .interp
 321    section.  */
 322
 323 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 324
 325 /* The size in bytes of an entry in the procedure linkage table.  */
 326
 327 #define PLT_ENTRY_SIZE 16
 328
 329 /* The first entry in an absolute procedure linkage table looks like
 330    this.  See the SVR4 ABI i386 supplement to see how this works.  */
 331
 332 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
 333 {
 334   0xff, 0x35,   /* pushl contents of address */
 335   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 336   0xff, 0x25,   /* jmp indirect */
 337   0, 0, 0, 0,   /* replaced with address of .got + 8.  */
 338   0, 0, 0, 0    /* pad out to 16 bytes.  */
 339 };
 340
 341 /* Subsequent entries in an absolute procedure linkage table look like
 342    this.  */
 343
 344 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
 345 {
 346   0xff, 0x25,   /* jmp indirect */
 347   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 348   0x68,         /* pushl immediate */
 349   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 350   0xe9,         /* jmp relative */
 351   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 352 };
 353
 354 /* The first entry in a PIC procedure linkage table look like this.  */
 355
 356 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
 357 {
 358   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 359   0xff, 0xa3, 8, 0, 0, 0,       /* jmp *8(%ebx) */
 360   0, 0, 0, 0                    /* pad out to 16 bytes.  */
 361 };
 362
 363 /* Subsequent entries in a PIC procedure linkage table look like this.  */
 364
 365 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
 366 {
 367   0xff, 0xa3,   /* jmp *offset(%ebx) */
 368   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 369   0x68,         /* pushl immediate */
 370   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 371   0xe9,         /* jmp relative */
 372   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 373 };
 374
 375 /* The i386 linker needs to keep track of the number of relocs that it
 376    decides to copy as dynamic relocs in check_relocs for each symbol.
 377    This is so that it can later discard them if they are found to be
 378    unnecessary.  We store the information in a field extending the
 379    regular ELF linker hash table.  */
 380
 381 struct elf_i386_dyn_relocs
 382 {
 383   struct elf_i386_dyn_relocs *next;
 384
 385   /* The input section of the reloc.  */
 386   asection *sec;
 387
 388   /* Total number of relocs copied for the input section.  */
 389   bfd_size_type count;
 390
 391   /* Number of pc-relative relocs copied for the input section.  */
 392   bfd_size_type pc_count;
 393 };
 394
 395 /* i386 ELF linker hash entry.  */
 396
 397 struct elf_i386_link_hash_entry
 398 {
 399   struct elf_link_hash_entry root;
 400
 401   /* Track dynamic relocs copied for this symbol.  */
 402   struct elf_i386_dyn_relocs *dyn_relocs;
 403 };
 404
 405 /* i386 ELF linker hash table.  */
 406
 407 struct elf_i386_link_hash_table
 408 {
 409   struct elf_link_hash_table root;
 410
 411   /* Short-cuts to get to dynamic linker sections.  */
 412   asection *sgot;
 413   asection *sgotplt;
 414   asection *srelgot;
 415   asection *splt;
 416   asection *srelplt;
 417   asection *sdynbss;
 418   asection *srelbss;
 419 };
 420
 421 /* Get the i386 ELF linker hash table from a link_info structure.  */
 422
 423 #define elf_i386_hash_table(p) \
 424   ((struct elf_i386_link_hash_table *) ((p)->hash))
 425
 426 /* Create an entry in an i386 ELF linker hash table.  */
 427
 428 static struct bfd_hash_entry *
 429 elf_i386_link_hash_newfunc (entry, table, string)
 430      struct bfd_hash_entry *entry;
 431      struct bfd_hash_table *table;
 432      const char *string;
 433 {
 434   struct elf_i386_link_hash_entry *ret =
 435     (struct elf_i386_link_hash_entry *) entry;
 436
 437   /* Allocate the structure if it has not already been allocated by a
 438      subclass.  */
 439   if (ret == (struct elf_i386_link_hash_entry *) NULL)
 440     ret = ((struct elf_i386_link_hash_entry *)
 441            bfd_hash_allocate (table,
 442                               sizeof (struct elf_i386_link_hash_entry)));
 443   if (ret == (struct elf_i386_link_hash_entry *) NULL)
 444     return (struct bfd_hash_entry *) ret;
 445
 446   /* Call the allocation method of the superclass.  */
 447   ret = ((struct elf_i386_link_hash_entry *)
 448          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 449                                      table, string));
 450   if (ret != (struct elf_i386_link_hash_entry *) NULL)
 451     {
 452       ret->dyn_relocs = NULL;
 453     }
 454
 455   return (struct bfd_hash_entry *) ret;
 456 }
 457
 458 /* Create an i386 ELF linker hash table.  */
 459
 460 static struct bfd_link_hash_table *
 461 elf_i386_link_hash_table_create (abfd)
 462      bfd *abfd;
 463 {
 464   struct elf_i386_link_hash_table *ret;
 465   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
 466
 467   ret = (struct elf_i386_link_hash_table *) bfd_alloc (abfd, amt);
 468   if (ret == (struct elf_i386_link_hash_table *) NULL)
 469     return NULL;
 470
 471   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
 472                                        elf_i386_link_hash_newfunc))
 473     {
 474       bfd_release (abfd, ret);
 475       return NULL;
 476     }
 477
 478   ret->sgot = NULL;
 479   ret->sgotplt = NULL;
 480   ret->srelgot = NULL;
 481   ret->splt = NULL;
 482   ret->srelplt = NULL;
 483   ret->sdynbss = NULL;
 484   ret->srelbss = NULL;
 485
 486   return &ret->root.root;
 487 }
 488
 489 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
 490    shortcuts to them in our hash table.  */
 491
 492 static boolean
 493 create_got_section (dynobj, info)
 494      bfd *dynobj;
 495      struct bfd_link_info *info;
 496 {
 497   struct elf_i386_link_hash_table *htab;
 498
 499   if (! _bfd_elf_create_got_section (dynobj, info))
 500     return false;
 501
 502   htab = elf_i386_hash_table (info);
 503   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 504   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 505   if (!htab->sgot || !htab->sgotplt)
 506     abort ();
 507
 508   htab->srelgot = bfd_make_section (dynobj, ".rel.got");
 509   if (htab->srelgot == NULL
 510       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 511                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 512                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 513                                    | SEC_READONLY))
 514       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 515     return false;
 516   return true;
 517 }
 518
 519 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 520    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 521    hash table.  */
 522
 523 static boolean
 524 elf_i386_create_dynamic_sections (dynobj, info)
 525      bfd *dynobj;
 526      struct bfd_link_info *info;
 527 {
 528   struct elf_i386_link_hash_table *htab;
 529
 530   htab = elf_i386_hash_table (info);
 531   if (!htab->sgot && !create_got_section (dynobj, info))
 532     return false;
 533
 534   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 535     return false;
 536
 537   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 538   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
 539   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 540   if (!info->shared)
 541     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
 542
 543   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 544       || (!info->shared && !htab->srelbss))
 545     abort ();
 546
 547   return true;
 548 }
 549
 550 /* Look through the relocs for a section during the first phase, and
 551    allocate space in the global offset table or procedure linkage
 552    table.  */
 553
 554 static boolean
 555 elf_i386_check_relocs (abfd, info, sec, relocs)
 556      bfd *abfd;
 557      struct bfd_link_info *info;
 558      asection *sec;
 559      const Elf_Internal_Rela *relocs;
 560 {
 561   struct elf_i386_link_hash_table *htab;
 562   bfd *dynobj;
 563   Elf_Internal_Shdr *symtab_hdr;
 564   struct elf_link_hash_entry **sym_hashes;
 565   bfd_signed_vma *local_got_refcounts;
 566   const Elf_Internal_Rela *rel;
 567   const Elf_Internal_Rela *rel_end;
 568   asection *sreloc;
 569
 570   if (info->relocateable)
 571     return true;
 572
 573   htab = elf_i386_hash_table (info);
 574   dynobj = htab->root.dynobj;
 575   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 576   sym_hashes = elf_sym_hashes (abfd);
 577   local_got_refcounts = elf_local_got_refcounts (abfd);
 578
 579   sreloc = NULL;
 580
 581   rel_end = relocs + sec->reloc_count;
 582   for (rel = relocs; rel < rel_end; rel++)
 583     {
 584       unsigned long r_symndx;
 585       struct elf_link_hash_entry *h;
 586
 587       r_symndx = ELF32_R_SYM (rel->r_info);
 588
 589       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 590         {
 591           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
 592                                  bfd_archive_filename (abfd),
 593                                  r_symndx);
 594           return false;
 595         }
 596
 597       if (r_symndx < symtab_hdr->sh_info)
 598         h = NULL;
 599       else
 600         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 601
 602       /* Some relocs require a global offset table.  */
 603       if (htab->sgot == NULL)
 604         {
 605           switch (ELF32_R_TYPE (rel->r_info))
 606             {
 607             case R_386_GOT32:
 608             case R_386_GOTOFF:
 609             case R_386_GOTPC:
 610               if (dynobj == NULL)
 611                 htab->root.dynobj = dynobj = abfd;
 612               if (!create_got_section (dynobj, info))
 613                 return false;
 614               break;
 615
 616             default:
 617               break;
 618             }
 619         }
 620
 621       switch (ELF32_R_TYPE (rel->r_info))
 622         {
 623         case R_386_GOT32:
 624           /* This symbol requires a global offset table entry.  */
 625           if (h != NULL)
 626             {
 627               if (h->got.refcount == -1)
 628                 h->got.refcount = 1;
 629               else
 630                 h->got.refcount += 1;
 631             }
 632           else
 633             {
 634               /* This is a global offset table entry for a local symbol.  */
 635               if (local_got_refcounts == NULL)
 636                 {
 637                   bfd_size_type size;
 638
 639                   size = symtab_hdr->sh_info;
 640                   size *= sizeof (bfd_signed_vma);
 641                   local_got_refcounts = ((bfd_signed_vma *)
 642                                          bfd_alloc (abfd, size));
 643                   if (local_got_refcounts == NULL)
 644                     return false;
 645                   elf_local_got_refcounts (abfd) = local_got_refcounts;
 646                   memset (local_got_refcounts, -1, (size_t) size);
 647                 }
 648               if (local_got_refcounts[r_symndx] == -1)
 649                 local_got_refcounts[r_symndx] = 1;
 650               else
 651                 local_got_refcounts[r_symndx] += 1;
 652             }
 653           break;
 654
 655         case R_386_PLT32:
 656           /* This symbol requires a procedure linkage table entry.  We
 657              actually build the entry in adjust_dynamic_symbol,
 658              because this might be a case of linking PIC code which is
 659              never referenced by a dynamic object, in which case we
 660              don't need to generate a procedure linkage table entry
 661              after all.  */
 662
 663           /* If this is a local symbol, we resolve it directly without
 664              creating a procedure linkage table entry.  */
 665           if (h == NULL)
 666             continue;
 667
 668           if (h->plt.refcount == -1)
 669             {
 670               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 671               h->plt.refcount = 1;
 672             }
 673           else
 674             h->plt.refcount += 1;
 675           break;
 676
 677         case R_386_32:
 678         case R_386_PC32:
 679           if (h != NULL && !info->shared)
 680             {
 681               /* If this reloc is in a read-only section, we might
 682                  need a copy reloc.  */
 683               if ((sec->flags & SEC_READONLY) != 0)
 684                 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 685
 686               /* We may need a .plt entry if the function this reloc
 687                  refers to is in a shared lib.  */
 688               if (h->plt.refcount == -1)
 689                 h->plt.refcount = 1;
 690               else
 691                 h->plt.refcount += 1;
 692             }
 693
 694           /* If we are creating a shared library, and this is a reloc
 695              against a global symbol, or a non PC relative reloc
 696              against a local symbol, then we need to copy the reloc
 697              into the shared library.  However, if we are linking with
 698              -Bsymbolic, we do not need to copy a reloc against a
 699              global symbol which is defined in an object we are
 700              including in the link (i.e., DEF_REGULAR is set).  At
 701              this point we have not seen all the input files, so it is
 702              possible that DEF_REGULAR is not set now but will be set
 703              later (it is never cleared).  In case of a weak definition,
 704              DEF_REGULAR may be cleared later by a strong definition in
 705              a shared library. We account for that possibility below by
 706              storing information in the relocs_copied field of the hash
 707              table entry.  A similar situation occurs when creating
 708              shared libraries and symbol visibility changes render the
 709              symbol local.
 710
 711              If on the other hand, we are creating an executable, we
 712              may need to keep relocations for symbols satisfied by a
 713              dynamic library if we manage to avoid copy relocs for the
 714              symbol.  */
 715           if ((info->shared
 716                && (sec->flags & SEC_ALLOC) != 0
 717                && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
 718                    || (h != NULL
 719                        && (! info->symbolic
 720                            || h->root.type == bfd_link_hash_defweak
 721                            || (h->elf_link_hash_flags
 722                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 723               || (!info->shared
 724                   && (sec->flags & SEC_ALLOC) != 0
 725                   && h != NULL
 726                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
 727                   && (h->root.type == bfd_link_hash_defweak
 728                       || (h->elf_link_hash_flags
 729                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
 730             {
 731               /* We must copy these reloc types into the output file.
 732                  Create a reloc section in dynobj and make room for
 733                  this reloc.  */
 734               if (dynobj == NULL)
 735                 htab->root.dynobj = dynobj = abfd;
 736
 737               if (sreloc == NULL)
 738                 {
 739                   const char *name;
 740
 741                   name = (bfd_elf_string_from_elf_section
 742                           (abfd,
 743                            elf_elfheader (abfd)->e_shstrndx,
 744                            elf_section_data (sec)->rel_hdr.sh_name));
 745                   if (name == NULL)
 746                     return false;
 747
 748                   if (strncmp (name, ".rel", 4) != 0
 749                       || strcmp (bfd_get_section_name (abfd, sec),
 750                                  name + 4) != 0)
 751                     {
 752                       (*_bfd_error_handler)
 753                         (_("%s: bad relocation section name `%s\'"),
 754                          bfd_archive_filename (abfd), name);
 755                     }
 756
 757                   sreloc = bfd_get_section_by_name (dynobj, name);
 758                   if (sreloc == NULL)
 759                     {
 760                       flagword flags;
 761
 762                       sreloc = bfd_make_section (dynobj, name);
 763                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 764                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 765                       if ((sec->flags & SEC_ALLOC) != 0)
 766                         flags |= SEC_ALLOC | SEC_LOAD;
 767                       if (sreloc == NULL
 768                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 769                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 770                         return false;
 771                     }
 772                   elf_section_data (sec)->sreloc = sreloc;
 773                 }
 774
 775               /* If this is a global symbol, we count the number of
 776                  relocations we need for this symbol.  */
 777               if (h != NULL)
 778                 {
 779                   struct elf_i386_link_hash_entry *eh;
 780                   struct elf_i386_dyn_relocs *p;
 781
 782                   eh = (struct elf_i386_link_hash_entry *) h;
 783                   p = eh->dyn_relocs;
 784
 785                   if (p == NULL || p->sec != sec)
 786                     {
 787                       p = ((struct elf_i386_dyn_relocs *)
 788                            bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
 789                       if (p == NULL)
 790                         return false;
 791                       p->next = eh->dyn_relocs;
 792                       eh->dyn_relocs = p;
 793                       p->sec = sec;
 794                       p->count = 0;
 795                       p->pc_count = 0;
 796                     }
 797
 798                   p->count += 1;
 799                   if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
 800                     p->pc_count += 1;
 801                 }
 802               else
 803                 {
 804                   /* Track dynamic relocs needed for local syms too.  */
 805                   elf_section_data (sec)->local_dynrel += 1;
 806                 }
 807             }
 808
 809           break;
 810
 811           /* This relocation describes the C++ object vtable hierarchy.
 812              Reconstruct it for later use during GC.  */
 813         case R_386_GNU_VTINHERIT:
 814           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 815             return false;
 816           break;
 817
 818           /* This relocation describes which C++ vtable entries are actually
 819              used.  Record for later use during GC.  */
 820         case R_386_GNU_VTENTRY:
 821           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
 822             return false;
 823           break;
 824
 825         default:
 826           break;
 827         }
 828     }
 829
 830   return true;
 831 }
 832
 833 /* Return the section that should be marked against GC for a given
 834    relocation.  */
 835
 836 static asection *
 837 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
 838      bfd *abfd;
 839      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 840      Elf_Internal_Rela *rel;
 841      struct elf_link_hash_entry *h;
 842      Elf_Internal_Sym *sym;
 843 {
 844   if (h != NULL)
 845     {
 846       switch (ELF32_R_TYPE (rel->r_info))
 847         {
 848         case R_386_GNU_VTINHERIT:
 849         case R_386_GNU_VTENTRY:
 850           break;
 851
 852         default:
 853           switch (h->root.type)
 854             {
 855             case bfd_link_hash_defined:
 856             case bfd_link_hash_defweak:
 857               return h->root.u.def.section;
 858
 859             case bfd_link_hash_common:
 860               return h->root.u.c.p->section;
 861
 862             default:
 863               break;
 864             }
 865         }
 866     }
 867   else
 868     {
 869       if (!(elf_bad_symtab (abfd)
 870             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 871           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 872                 && sym->st_shndx != SHN_COMMON))
 873         {
 874           return bfd_section_from_elf_index (abfd, sym->st_shndx);
 875         }
 876     }
 877
 878   return NULL;
 879 }
 880
 881 /* Update the got entry reference counts for the section being removed.  */
 882
 883 static boolean
 884 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
 885      bfd *abfd;
 886      struct bfd_link_info *info;
 887      asection *sec;
 888      const Elf_Internal_Rela *relocs;
 889 {
 890   Elf_Internal_Shdr *symtab_hdr;
 891   struct elf_link_hash_entry **sym_hashes;
 892   bfd_signed_vma *local_got_refcounts;
 893   const Elf_Internal_Rela *rel, *relend;
 894   unsigned long r_symndx;
 895   struct elf_link_hash_entry *h;
 896   bfd *dynobj;
 897
 898   elf_section_data (sec)->local_dynrel = 0;
 899
 900   dynobj = elf_hash_table (info)->dynobj;
 901   if (dynobj == NULL)
 902     return true;
 903
 904   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 905   sym_hashes = elf_sym_hashes (abfd);
 906   local_got_refcounts = elf_local_got_refcounts (abfd);
 907
 908   relend = relocs + sec->reloc_count;
 909   for (rel = relocs; rel < relend; rel++)
 910     switch (ELF32_R_TYPE (rel->r_info))
 911       {
 912       case R_386_GOT32:
 913       case R_386_GOTOFF:
 914       case R_386_GOTPC:
 915         r_symndx = ELF32_R_SYM (rel->r_info);
 916         if (r_symndx >= symtab_hdr->sh_info)
 917           {
 918             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 919             if (h->got.refcount > 0)
 920               h->got.refcount -= 1;
 921           }
 922         else if (local_got_refcounts != NULL)
 923           {
 924             if (local_got_refcounts[r_symndx] > 0)
 925               local_got_refcounts[r_symndx] -= 1;
 926           }
 927         break;
 928
 929       case R_386_32:
 930       case R_386_PC32:
 931         r_symndx = ELF32_R_SYM (rel->r_info);
 932         if (r_symndx >= symtab_hdr->sh_info)
 933           {
 934             struct elf_i386_link_hash_entry *eh;
 935             struct elf_i386_dyn_relocs **pp;
 936             struct elf_i386_dyn_relocs *p;
 937
 938             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 939
 940             if (!info->shared && h->plt.refcount > 0)
 941               h->plt.refcount -= 1;
 942
 943             eh = (struct elf_i386_link_hash_entry *) h;
 944
 945             for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
 946               if (p->sec == sec)
 947                 {
 948                   if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
 949                     p->pc_count -= 1;
 950                   p->count -= 1;
 951                   if (p->count == 0)
 952                     *pp = p->next;
 953                   break;
 954                 }
 955           }
 956         break;
 957
 958       case R_386_PLT32:
 959         r_symndx = ELF32_R_SYM (rel->r_info);
 960         if (r_symndx >= symtab_hdr->sh_info)
 961           {
 962             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 963             if (h->plt.refcount > 0)
 964               h->plt.refcount -= 1;
 965           }
 966         break;
 967
 968       default:
 969         break;
 970       }
 971
 972   return true;
 973 }
 974
 975 /* Adjust a symbol defined by a dynamic object and referenced by a
 976    regular object.  The current definition is in some section of the
 977    dynamic object, but we're not including those sections.  We have to
 978    change the definition to something the rest of the link can
 979    understand.  */
 980
 981 static boolean
 982 elf_i386_adjust_dynamic_symbol (info, h)
 983      struct bfd_link_info *info;
 984      struct elf_link_hash_entry *h;
 985 {
 986   struct elf_i386_link_hash_table *htab;
 987   bfd *dynobj;
 988   asection *s;
 989   unsigned int power_of_two;
 990
 991   htab = elf_i386_hash_table (info);
 992   dynobj = htab->root.dynobj;
 993
 994   /* If this is a function, put it in the procedure linkage table.  We
 995      will fill in the contents of the procedure linkage table later,
 996      when we know the address of the .got section.  */
 997   if (h->type == STT_FUNC
 998       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
 999     {
1000       if (h->plt.refcount <= 0
1001           || (! info->shared
1002               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1003               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
1004         {
1005           /* This case can occur if we saw a PLT32 reloc in an input
1006              file, but the symbol was never referred to by a dynamic
1007              object, or if all references were garbage collected.  In
1008              such a case, we don't actually need to build a procedure
1009              linkage table, and we can just do a PC32 reloc instead.  */
1010           h->plt.refcount = (bfd_vma) -1;
1011           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1012         }
1013
1014       return true;
1015     }
1016   else
1017     /* It's possible that we incorrectly decided a .plt reloc was
1018        needed for an R_386_PC32 reloc to a non-function sym in
1019        check_relocs.  We can't decide accurately between function and
1020        non-function syms in check-relocs;  Objects loaded later in
1021        the link may change h->type.  So fix it now.  */
1022     h->plt.refcount = (bfd_vma) -1;
1023
1024   /* If this is a weak symbol, and there is a real definition, the
1025      processor independent code will have arranged for us to see the
1026      real definition first, and we can just use the same value.  */
1027   if (h->weakdef != NULL)
1028     {
1029       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1030                   || h->weakdef->root.type == bfd_link_hash_defweak);
1031       h->root.u.def.section = h->weakdef->root.u.def.section;
1032       h->root.u.def.value = h->weakdef->root.u.def.value;
1033       return true;
1034     }
1035
1036   /* This is a reference to a symbol defined by a dynamic object which
1037      is not a function.  */
1038
1039   /* If we are creating a shared library, we must presume that the
1040      only references to the symbol are via the global offset table.
1041      For such cases we need not do anything here; the relocations will
1042      be handled correctly by relocate_section.  */
1043   if (info->shared)
1044     return true;
1045
1046   /* If there are no references to this symbol that do not use the
1047      GOT, we don't need to generate a copy reloc.  */
1048   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1049     return true;
1050
1051   /* We must allocate the symbol in our .dynbss section, which will
1052      become part of the .bss section of the executable.  There will be
1053      an entry for this symbol in the .dynsym section.  The dynamic
1054      object will contain position independent code, so all references
1055      from the dynamic object to this symbol will go through the global
1056      offset table.  The dynamic linker will use the .dynsym entry to
1057      determine the address it must put in the global offset table, so
1058      both the dynamic object and the regular object will refer to the
1059      same memory location for the variable.  */
1060
1061   s = htab->sdynbss;
1062   if (s == NULL)
1063     abort ();
1064
1065   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1066      copy the initial value out of the dynamic object and into the
1067      runtime process image.  We need to remember the offset into the
1068      .rel.bss section we are going to use.  */
1069   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1070     {
1071       asection *srel;
1072
1073       srel = htab->srelbss;
1074       if (srel == NULL)
1075         abort ();
1076       srel->_raw_size += sizeof (Elf32_External_Rel);
1077       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1078     }
1079
1080   /* We need to figure out the alignment required for this symbol.  I
1081      have no idea how ELF linkers handle this.  */
1082   power_of_two = bfd_log2 (h->size);
1083   if (power_of_two > 3)
1084     power_of_two = 3;
1085
1086   /* Apply the required alignment.  */
1087   s->_raw_size = BFD_ALIGN (s->_raw_size,
1088                             (bfd_size_type) (1 << power_of_two));
1089   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1090     {
1091       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1092         return false;
1093     }
1094
1095   /* Define the symbol as being at this point in the section.  */
1096   h->root.u.def.section = s;
1097   h->root.u.def.value = s->_raw_size;
1098
1099   /* Increment the section size to make room for the symbol.  */
1100   s->_raw_size += h->size;
1101
1102   return true;
1103 }
1104
1105 /* This is the condition under which elf_i386_finish_dynamic_symbol
1106    will be called from elflink.h.  If elflink.h doesn't call our
1107    finish_dynamic_symbol routine, we'll need to do something about
1108    initializing any .plt and .got entries in elf_i386_relocate_section.  */
1109 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1110   ((DYN)                                                                \
1111    && ((INFO)->shared                                                   \
1112        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
1113    && ((H)->dynindx != -1                                               \
1114        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1115
1116 /* Allocate space in .plt, .got and associated reloc sections for
1117    dynamic relocs.  */
1118
1119 static boolean
1120 allocate_dynrelocs (h, inf)
1121      struct elf_link_hash_entry *h;
1122      PTR inf;
1123 {
1124   struct bfd_link_info *info;
1125   struct elf_i386_link_hash_table *htab;
1126   asection *s;
1127   struct elf_i386_link_hash_entry *eh;
1128   struct elf_i386_dyn_relocs *p;
1129
1130   if (h->root.type == bfd_link_hash_indirect
1131       || h->root.type == bfd_link_hash_warning)
1132     return true;
1133
1134   info = (struct bfd_link_info *) inf;
1135   htab = elf_i386_hash_table (info);
1136
1137   if (htab->root.dynamic_sections_created
1138       && h->plt.refcount > 0)
1139     {
1140       /* Make sure this symbol is output as a dynamic symbol.
1141          Undefined weak syms won't yet be marked as dynamic.  */
1142       if (h->dynindx == -1
1143           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1144         {
1145           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1146             return false;
1147         }
1148
1149       s = htab->splt;
1150       if (s == NULL)
1151         abort ();
1152
1153       /* If this is the first .plt entry, make room for the special
1154          first entry.  */
1155       if (s->_raw_size == 0)
1156         s->_raw_size += PLT_ENTRY_SIZE;
1157
1158       h->plt.offset = s->_raw_size;
1159
1160       /* If this symbol is not defined in a regular file, and we are
1161          not generating a shared library, then set the symbol to this
1162          location in the .plt.  This is required to make function
1163          pointers compare as equal between the normal executable and
1164          the shared library.  */
1165       if (! info->shared
1166           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1167         {
1168           h->root.u.def.section = s;
1169           h->root.u.def.value = h->plt.offset;
1170         }
1171
1172       /* Make room for this entry.  */
1173       s->_raw_size += PLT_ENTRY_SIZE;
1174
1175       /* We also need to make an entry in the .got.plt section, which
1176          will be placed in the .got section by the linker script.  */
1177       s = htab->sgotplt;
1178       if (s == NULL)
1179         abort ();
1180       s->_raw_size += 4;
1181
1182       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1183         {
1184           /* We also need to make an entry in the .rel.plt section.  */
1185           s = htab->srelplt;
1186           if (s == NULL)
1187             abort ();
1188           s->_raw_size += sizeof (Elf32_External_Rel);
1189         }
1190     }
1191   else
1192     {
1193       h->plt.offset = (bfd_vma) -1;
1194       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1195     }
1196
1197   if (h->got.refcount > 0)
1198     {
1199       boolean dyn;
1200
1201       /* Make sure this symbol is output as a dynamic symbol.
1202          Undefined weak syms won't yet be marked as dynamic.  */
1203       if (h->dynindx == -1
1204           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1205         {
1206           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1207             return false;
1208         }
1209
1210       s = htab->sgot;
1211       h->got.offset = s->_raw_size;
1212       s->_raw_size += 4;
1213       dyn = htab->root.dynamic_sections_created;
1214       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1215         htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1216     }
1217   else
1218     h->got.offset = (bfd_vma) -1;
1219
1220   eh = (struct elf_i386_link_hash_entry *) h;
1221   if (eh->dyn_relocs == NULL)
1222     return true;
1223
1224   /* In the shared -Bsymbolic case, discard space allocated for
1225      dynamic pc-relative relocs against symbols which turn out to be
1226      defined in regular objects.  For the normal shared case, discard
1227      space for relocs that have become local due to symbol visibility
1228      changes.  */
1229
1230   if (info->shared)
1231     {
1232       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1233           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1234               || info->symbolic))
1235         {
1236           struct elf_i386_dyn_relocs **pp;
1237
1238           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1239             {
1240               p->count -= p->pc_count;
1241               p->pc_count = 0;
1242               if (p->count == 0)
1243                 *pp = p->next;
1244               else
1245                 pp = &p->next;
1246             }
1247         }
1248     }
1249   else
1250     {
1251       /* For the non-shared case, discard space for relocs against
1252          symbols which turn out to need copy relocs or are not
1253          dynamic.  */
1254
1255       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1256           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1257                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1258               || (htab->root.dynamic_sections_created
1259                   && (h->root.type == bfd_link_hash_undefweak
1260                       || h->root.type == bfd_link_hash_undefined))))
1261         {
1262           /* Make sure this symbol is output as a dynamic symbol.
1263              Undefined weak syms won't yet be marked as dynamic.  */
1264           if (h->dynindx == -1
1265               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1266             {
1267               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1268                 return false;
1269             }
1270
1271           /* If that succeeded, we know we'll be keeping all the
1272              relocs.  */
1273           if (h->dynindx != -1)
1274             goto keep;
1275         }
1276
1277       eh->dyn_relocs = NULL;
1278
1279     keep:
1280     }
1281
1282   /* Finally, allocate space.  */
1283   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1284     {
1285       asection *sreloc = elf_section_data (p->sec)->sreloc;
1286       sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1287     }
1288
1289   return true;
1290 }
1291
1292 /* Find any dynamic relocs that apply to read-only sections.  */
1293
1294 static boolean
1295 readonly_dynrelocs (h, inf)
1296      struct elf_link_hash_entry *h;
1297      PTR inf;
1298 {
1299   struct elf_i386_link_hash_entry *eh;
1300   struct elf_i386_dyn_relocs *p;
1301
1302   eh = (struct elf_i386_link_hash_entry *) h;
1303   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1304     {
1305       asection *s = p->sec->output_section;
1306
1307       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1308         {
1309           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1310
1311           info->flags |= DF_TEXTREL;
1312
1313           /* Not an error, just cut short the traversal.  */
1314           return false;
1315         }
1316     }
1317   return true;
1318 }
1319
1320 /* Set the sizes of the dynamic sections.  */
1321
1322 static boolean
1323 elf_i386_size_dynamic_sections (output_bfd, info)
1324      bfd *output_bfd ATTRIBUTE_UNUSED;
1325      struct bfd_link_info *info;
1326 {
1327   struct elf_i386_link_hash_table *htab;
1328   bfd *dynobj;
1329   asection *s;
1330   boolean relocs;
1331   bfd *ibfd;
1332
1333   htab = elf_i386_hash_table (info);
1334   dynobj = htab->root.dynobj;
1335   if (dynobj == NULL)
1336     abort ();
1337
1338   if (htab->root.dynamic_sections_created)
1339     {
1340       /* Set the contents of the .interp section to the interpreter.  */
1341       if (! info->shared)
1342         {
1343           s = bfd_get_section_by_name (dynobj, ".interp");
1344           if (s == NULL)
1345             abort ();
1346           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1347           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1348         }
1349     }
1350
1351   /* Set up .got offsets for local syms, and space for local dynamic
1352      relocs.  */
1353   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1354     {
1355       bfd_signed_vma *local_got;
1356       bfd_signed_vma *end_local_got;
1357       bfd_size_type locsymcount;
1358       Elf_Internal_Shdr *symtab_hdr;
1359       asection *srel;
1360
1361       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1362         continue;
1363
1364       for (s = ibfd->sections; s != NULL; s = s->next)
1365         {
1366           bfd_size_type count = elf_section_data (s)->local_dynrel;
1367
1368           if (count != 0)
1369             {
1370               srel = elf_section_data (s)->sreloc;
1371               srel->_raw_size += count * sizeof (Elf32_External_Rel);
1372             }
1373         }
1374
1375       local_got = elf_local_got_refcounts (ibfd);
1376       if (!local_got)
1377         continue;
1378
1379       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1380       locsymcount = symtab_hdr->sh_info;
1381       end_local_got = local_got + locsymcount;
1382       s = htab->sgot;
1383       srel = htab->srelgot;
1384       for (; local_got < end_local_got; ++local_got)
1385         {
1386           if (*local_got > 0)
1387             {
1388               *local_got = s->_raw_size;
1389               s->_raw_size += 4;
1390               if (info->shared)
1391                 srel->_raw_size += sizeof (Elf32_External_Rel);
1392             }
1393           else
1394             *local_got = (bfd_vma) -1;
1395         }
1396     }
1397
1398   /* Allocate global sym .plt and .got entries, and space for global
1399      sym dynamic relocs.  */
1400   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
1401
1402   /* We now have determined the sizes of the various dynamic sections.
1403      Allocate memory for them.  */
1404   relocs = false;
1405   for (s = dynobj->sections; s != NULL; s = s->next)
1406     {
1407       if ((s->flags & SEC_LINKER_CREATED) == 0)
1408         continue;
1409
1410       if (s == htab->splt
1411           || s == htab->sgot
1412           || s == htab->sgotplt)
1413         {
1414           /* Strip this section if we don't need it; see the
1415              comment below.  */
1416         }
1417       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1418         {
1419           if (s->_raw_size == 0)
1420             {
1421               /* If we don't need this section, strip it from the
1422                  output file.  This is mostly to handle .rel.bss and
1423                  .rel.plt.  We must create both sections in
1424                  create_dynamic_sections, because they must be created
1425                  before the linker maps input sections to output
1426                  sections.  The linker does that before
1427                  adjust_dynamic_symbol is called, and it is that
1428                  function which decides whether anything needs to go
1429                  into these sections.  */
1430             }
1431           else
1432             {
1433               if (s != htab->srelplt)
1434                 relocs = true;
1435
1436               /* We use the reloc_count field as a counter if we need
1437                  to copy relocs into the output file.  */
1438               s->reloc_count = 0;
1439             }
1440         }
1441       else
1442         {
1443           /* It's not one of our sections, so don't allocate space.  */
1444           continue;
1445         }
1446
1447       if (s->_raw_size == 0)
1448         {
1449           _bfd_strip_section_from_output (info, s);
1450           continue;
1451         }
1452
1453       /* Allocate memory for the section contents.  We use bfd_zalloc
1454          here in case unused entries are not reclaimed before the
1455          section's contents are written out.  This should not happen,
1456          but this way if it does, we get a R_386_NONE reloc instead
1457          of garbage.  */
1458       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1459       if (s->contents == NULL)
1460         return false;
1461     }
1462
1463   if (htab->root.dynamic_sections_created)
1464     {
1465       /* Add some entries to the .dynamic section.  We fill in the
1466          values later, in elf_i386_finish_dynamic_sections, but we
1467          must add the entries now so that we get the correct size for
1468          the .dynamic section.  The DT_DEBUG entry is filled in by the
1469          dynamic linker and used by the debugger.  */
1470 #define add_dynamic_entry(TAG, VAL) \
1471   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1472
1473       if (! info->shared)
1474         {
1475           if (!add_dynamic_entry (DT_DEBUG, 0))
1476             return false;
1477         }
1478
1479       if (htab->splt->_raw_size != 0)
1480         {
1481           if (!add_dynamic_entry (DT_PLTGOT, 0)
1482               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1483               || !add_dynamic_entry (DT_PLTREL, DT_REL)
1484               || !add_dynamic_entry (DT_JMPREL, 0))
1485             return false;
1486         }
1487
1488       if (relocs)
1489         {
1490           if (!add_dynamic_entry (DT_REL, 0)
1491               || !add_dynamic_entry (DT_RELSZ, 0)
1492               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1493             return false;
1494
1495           /* If any dynamic relocs apply to a read-only section,
1496              then we need a DT_TEXTREL entry.  */
1497           elf_link_hash_traverse (&htab->root, readonly_dynrelocs, (PTR) info);
1498
1499           if ((info->flags & DF_TEXTREL) != 0)
1500             {
1501               if (!add_dynamic_entry (DT_TEXTREL, 0))
1502                 return false;
1503             }
1504         }
1505     }
1506 #undef add_dynamic_entry
1507
1508   return true;
1509 }
1510
1511 /* Relocate an i386 ELF section.  */
1512
1513 static boolean
1514 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1515                            contents, relocs, local_syms, local_sections)
1516      bfd *output_bfd;
1517      struct bfd_link_info *info;
1518      bfd *input_bfd;
1519      asection *input_section;
1520      bfd_byte *contents;
1521      Elf_Internal_Rela *relocs;
1522      Elf_Internal_Sym *local_syms;
1523      asection **local_sections;
1524 {
1525   struct elf_i386_link_hash_table *htab;
1526   bfd *dynobj;
1527   Elf_Internal_Shdr *symtab_hdr;
1528   struct elf_link_hash_entry **sym_hashes;
1529   bfd_vma *local_got_offsets;
1530   Elf_Internal_Rela *rel;
1531   Elf_Internal_Rela *relend;
1532
1533   htab = elf_i386_hash_table (info);
1534   dynobj = htab->root.dynobj;
1535   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1536   sym_hashes = elf_sym_hashes (input_bfd);
1537   local_got_offsets = elf_local_got_offsets (input_bfd);
1538
1539   rel = relocs;
1540   relend = relocs + input_section->reloc_count;
1541   for (; rel < relend; rel++)
1542     {
1543       int r_type;
1544       reloc_howto_type *howto;
1545       unsigned long r_symndx;
1546       struct elf_link_hash_entry *h;
1547       Elf_Internal_Sym *sym;
1548       asection *sec;
1549       bfd_vma off;
1550       bfd_vma relocation;
1551       boolean unresolved_reloc;
1552       bfd_reloc_status_type r;
1553       unsigned int indx;
1554
1555       r_type = ELF32_R_TYPE (rel->r_info);
1556       if (r_type == (int) R_386_GNU_VTINHERIT
1557           || r_type == (int) R_386_GNU_VTENTRY)
1558         continue;
1559
1560       if ((indx = (unsigned) r_type) >= R_386_standard
1561           && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1562               >= R_386_ext - R_386_standard))
1563         {
1564           bfd_set_error (bfd_error_bad_value);
1565           return false;
1566         }
1567       howto = elf_howto_table + indx;
1568
1569       r_symndx = ELF32_R_SYM (rel->r_info);
1570
1571       if (info->relocateable)
1572         {
1573           /* This is a relocateable link.  We don't have to change
1574              anything, unless the reloc is against a section symbol,
1575              in which case we have to adjust according to where the
1576              section symbol winds up in the output section.  */
1577           if (r_symndx < symtab_hdr->sh_info)
1578             {
1579               sym = local_syms + r_symndx;
1580               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1581                 {
1582                   bfd_vma val;
1583
1584                   sec = local_sections[r_symndx];
1585                   val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1586                   val += sec->output_offset + sym->st_value;
1587                   bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1588                 }
1589             }
1590
1591           continue;
1592         }
1593
1594       /* This is a final link.  */
1595       h = NULL;
1596       sym = NULL;
1597       sec = NULL;
1598       unresolved_reloc = false;
1599       if (r_symndx < symtab_hdr->sh_info)
1600         {
1601           sym = local_syms + r_symndx;
1602           sec = local_sections[r_symndx];
1603           relocation = (sec->output_section->vma
1604                         + sec->output_offset
1605                         + sym->st_value);
1606         }
1607       else
1608         {
1609           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1610           while (h->root.type == bfd_link_hash_indirect
1611                  || h->root.type == bfd_link_hash_warning)
1612             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1613
1614           relocation = 0;
1615           if (h->root.type == bfd_link_hash_defined
1616               || h->root.type == bfd_link_hash_defweak)
1617             {
1618               sec = h->root.u.def.section;
1619               if (sec->output_section == NULL)
1620                 /* Set a flag that will be cleared later if we find a
1621                    relocation value for this symbol.  output_section
1622                    is typically NULL for symbols satisfied by a shared
1623                    library.  */
1624                 unresolved_reloc = true;
1625               else
1626                 relocation = (h->root.u.def.value
1627                               + sec->output_section->vma
1628                               + sec->output_offset);
1629             }
1630           else if (h->root.type == bfd_link_hash_undefweak)
1631             ;
1632           else if (info->shared
1633                    && (!info->symbolic || info->allow_shlib_undefined)
1634                    && !info->no_undefined
1635                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1636             ;
1637           else
1638             {
1639               if (! ((*info->callbacks->undefined_symbol)
1640                      (info, h->root.root.string, input_bfd,
1641                       input_section, rel->r_offset,
1642                       (!info->shared || info->no_undefined
1643                        || ELF_ST_VISIBILITY (h->other)))))
1644                 return false;
1645             }
1646         }
1647
1648       switch (r_type)
1649         {
1650         case R_386_GOT32:
1651           /* Relocation is to the entry for this symbol in the global
1652              offset table.  */
1653           if (htab->sgot == NULL)
1654             abort ();
1655
1656           if (h != NULL)
1657             {
1658               boolean dyn;
1659
1660               off = h->got.offset;
1661               dyn = htab->root.dynamic_sections_created;
1662               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1663                   || (info->shared
1664                       && (info->symbolic
1665                           || h->dynindx == -1
1666                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1667                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1668                 {
1669                   /* This is actually a static link, or it is a
1670                      -Bsymbolic link and the symbol is defined
1671                      locally, or the symbol was forced to be local
1672                      because of a version file.  We must initialize
1673                      this entry in the global offset table.  Since the
1674                      offset must always be a multiple of 4, we use the
1675                      least significant bit to record whether we have
1676                      initialized it already.
1677
1678                      When doing a dynamic link, we create a .rel.got
1679                      relocation entry to initialize the value.  This
1680                      is done in the finish_dynamic_symbol routine.  */
1681                   if ((off & 1) != 0)
1682                     off &= ~1;
1683                   else
1684                     {
1685                       bfd_put_32 (output_bfd, relocation,
1686                                   htab->sgot->contents + off);
1687                       h->got.offset |= 1;
1688                     }
1689                 }
1690               else
1691                 unresolved_reloc = false;
1692             }
1693           else
1694             {
1695               if (local_got_offsets == NULL)
1696                 abort ();
1697
1698               off = local_got_offsets[r_symndx];
1699
1700               /* The offset must always be a multiple of 4.  We use
1701                  the least significant bit to record whether we have
1702                  already generated the necessary reloc.  */
1703               if ((off & 1) != 0)
1704                 off &= ~1;
1705               else
1706                 {
1707                   bfd_put_32 (output_bfd, relocation,
1708                               htab->sgot->contents + off);
1709
1710                   if (info->shared)
1711                     {
1712                       asection *srelgot;
1713                       Elf_Internal_Rel outrel;
1714
1715                       srelgot = htab->srelgot;
1716                       if (srelgot == NULL)
1717                         abort ();
1718
1719                       outrel.r_offset = (htab->sgot->output_section->vma
1720                                          + htab->sgot->output_offset
1721                                          + off);
1722                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1723                       bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1724                                                 (((Elf32_External_Rel *)
1725                                                   srelgot->contents)
1726                                                  + srelgot->reloc_count));
1727                       ++srelgot->reloc_count;
1728                     }
1729
1730                   local_got_offsets[r_symndx] |= 1;
1731                 }
1732             }
1733
1734           if (off >= (bfd_vma) -2)
1735             abort ();
1736
1737           relocation = htab->sgot->output_offset + off;
1738           break;
1739
1740         case R_386_GOTOFF:
1741           /* Relocation is relative to the start of the global offset
1742              table.  */
1743
1744           /* Note that sgot->output_offset is not involved in this
1745              calculation.  We always want the start of .got.  If we
1746              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1747              permitted by the ABI, we might have to change this
1748              calculation.  */
1749           relocation -= htab->sgot->output_section->vma;
1750           break;
1751
1752         case R_386_GOTPC:
1753           /* Use global offset table as symbol value.  */
1754           relocation = htab->sgot->output_section->vma;
1755           unresolved_reloc = false;
1756           break;
1757
1758         case R_386_PLT32:
1759           /* Relocation is to the entry for this symbol in the
1760              procedure linkage table.  */
1761
1762           /* Resolve a PLT32 reloc against a local symbol directly,
1763              without using the procedure linkage table.  */
1764           if (h == NULL)
1765             break;
1766
1767           if (h->plt.offset == (bfd_vma) -1
1768               || htab->splt == NULL)
1769             {
1770               /* We didn't make a PLT entry for this symbol.  This
1771                  happens when statically linking PIC code, or when
1772                  using -Bsymbolic.  */
1773               break;
1774             }
1775
1776           relocation = (htab->splt->output_section->vma
1777                         + htab->splt->output_offset
1778                         + h->plt.offset);
1779           unresolved_reloc = false;
1780           break;
1781
1782         case R_386_32:
1783         case R_386_PC32:
1784           if ((info->shared
1785                && (input_section->flags & SEC_ALLOC) != 0
1786                && (r_type != R_386_PC32
1787                    || (h != NULL
1788                        && h->dynindx != -1
1789                        && (! info->symbolic
1790                            || (h->elf_link_hash_flags
1791                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1792               || (!info->shared
1793                   && (input_section->flags & SEC_ALLOC) != 0
1794                   && h != NULL
1795                   && h->dynindx != -1
1796                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1797                   && (((h->elf_link_hash_flags
1798                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1799                        && (h->elf_link_hash_flags
1800                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
1801                       || h->root.type == bfd_link_hash_undefweak
1802                       || h->root.type == bfd_link_hash_undefined)))
1803             {
1804               Elf_Internal_Rel outrel;
1805               boolean skip, relocate;
1806               asection *sreloc;
1807               Elf32_External_Rel *loc;
1808
1809               /* When generating a shared object, these relocations
1810                  are copied into the output file to be resolved at run
1811                  time.  */
1812
1813               skip = false;
1814
1815               if (elf_section_data (input_section)->stab_info == NULL)
1816                 outrel.r_offset = rel->r_offset;
1817               else
1818                 {
1819                   off = (_bfd_stab_section_offset
1820                          (output_bfd, htab->root.stab_info, input_section,
1821                           &elf_section_data (input_section)->stab_info,
1822                           rel->r_offset));
1823                   if (off == (bfd_vma) -1)
1824                     skip = true;
1825                   outrel.r_offset = off;
1826                 }
1827
1828               outrel.r_offset += (input_section->output_section->vma
1829                                   + input_section->output_offset);
1830
1831               if (skip)
1832                 {
1833                   memset (&outrel, 0, sizeof outrel);
1834                   relocate = false;
1835                 }
1836               else if (h != NULL
1837                        && h->dynindx != -1
1838                        && (r_type == R_386_PC32
1839                            || !info->shared
1840                            || !info->symbolic
1841                            || (h->elf_link_hash_flags
1842                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1843
1844                 {
1845                   relocate = false;
1846                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1847                 }
1848               else
1849                 {
1850                   /* This symbol is local, or marked to become local.  */
1851                   relocate = true;
1852                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1853                 }
1854
1855               sreloc = elf_section_data (input_section)->sreloc;
1856               if (sreloc == NULL)
1857                 abort ();
1858
1859               loc = ((Elf32_External_Rel *) sreloc->contents
1860                      + sreloc->reloc_count);
1861               sreloc->reloc_count += 1;
1862               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
1863
1864               /* If this reloc is against an external symbol, we do
1865                  not want to fiddle with the addend.  Otherwise, we
1866                  need to include the symbol value so that it becomes
1867                  an addend for the dynamic reloc.  */
1868               if (! relocate)
1869                 continue;
1870             }
1871
1872           break;
1873
1874         default:
1875           break;
1876         }
1877
1878       /* FIXME: Why do we allow debugging sections to escape this error?
1879          More importantly, why do we not emit dynamic relocs for
1880          R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1881          If we had emitted the dynamic reloc, we could remove the
1882          fudge here.  */
1883       if (unresolved_reloc
1884           && !(info->shared
1885                && (input_section->flags & SEC_DEBUGGING) != 0
1886                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1887         (*_bfd_error_handler)
1888           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1889            bfd_archive_filename (input_bfd),
1890            bfd_get_section_name (input_bfd, input_section),
1891            (long) rel->r_offset,
1892            h->root.root.string);
1893
1894       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1895                                     contents, rel->r_offset,
1896                                     relocation, (bfd_vma) 0);
1897
1898       switch (r)
1899         {
1900         case bfd_reloc_ok:
1901           break;
1902
1903         case bfd_reloc_overflow:
1904           {
1905             const char *name;
1906
1907             if (h != NULL)
1908               name = h->root.root.string;
1909             else
1910               {
1911                 name = bfd_elf_string_from_elf_section (input_bfd,
1912                                                         symtab_hdr->sh_link,
1913                                                         sym->st_name);
1914                 if (name == NULL)
1915                   return false;
1916                 if (*name == '\0')
1917                   name = bfd_section_name (input_bfd, sec);
1918               }
1919             if (! ((*info->callbacks->reloc_overflow)
1920                    (info, name, howto->name, (bfd_vma) 0,
1921                     input_bfd, input_section, rel->r_offset)))
1922               return false;
1923           }
1924           break;
1925
1926         default:
1927         case bfd_reloc_outofrange:
1928           abort ();
1929           break;
1930         }
1931     }
1932
1933   return true;
1934 }
1935
1936 /* Finish up dynamic symbol handling.  We set the contents of various
1937    dynamic sections here.  */
1938
1939 static boolean
1940 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1941      bfd *output_bfd;
1942      struct bfd_link_info *info;
1943      struct elf_link_hash_entry *h;
1944      Elf_Internal_Sym *sym;
1945 {
1946   struct elf_i386_link_hash_table *htab;
1947   bfd *dynobj;
1948
1949   htab = elf_i386_hash_table (info);
1950   dynobj = htab->root.dynobj;
1951
1952   if (h->plt.offset != (bfd_vma) -1)
1953     {
1954       bfd_vma plt_index;
1955       bfd_vma got_offset;
1956       Elf_Internal_Rel rel;
1957
1958       /* This symbol has an entry in the procedure linkage table.  Set
1959          it up.  */
1960
1961       if (h->dynindx == -1
1962           || htab->splt == NULL
1963           || htab->sgotplt == NULL
1964           || htab->srelplt == NULL)
1965         abort ();
1966
1967       /* Get the index in the procedure linkage table which
1968          corresponds to this symbol.  This is the index of this symbol
1969          in all the symbols for which we are making plt entries.  The
1970          first entry in the procedure linkage table is reserved.  */
1971       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1972
1973       /* Get the offset into the .got table of the entry that
1974          corresponds to this function.  Each .got entry is 4 bytes.
1975          The first three are reserved.  */
1976       got_offset = (plt_index + 3) * 4;
1977
1978       /* Fill in the entry in the procedure linkage table.  */
1979       if (! info->shared)
1980         {
1981           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
1982                   PLT_ENTRY_SIZE);
1983           bfd_put_32 (output_bfd,
1984                       (htab->sgotplt->output_section->vma
1985                        + htab->sgotplt->output_offset
1986                        + got_offset),
1987                       htab->splt->contents + h->plt.offset + 2);
1988         }
1989       else
1990         {
1991           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1992                   PLT_ENTRY_SIZE);
1993           bfd_put_32 (output_bfd, got_offset,
1994                       htab->splt->contents + h->plt.offset + 2);
1995         }
1996
1997       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1998                   htab->splt->contents + h->plt.offset + 7);
1999       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2000                   htab->splt->contents + h->plt.offset + 12);
2001
2002       /* Fill in the entry in the global offset table.  */
2003       bfd_put_32 (output_bfd,
2004                   (htab->splt->output_section->vma
2005                    + htab->splt->output_offset
2006                    + h->plt.offset
2007                    + 6),
2008                   htab->sgotplt->contents + got_offset);
2009
2010       /* Fill in the entry in the .rel.plt section.  */
2011       rel.r_offset = (htab->sgotplt->output_section->vma
2012                       + htab->sgotplt->output_offset
2013                       + got_offset);
2014       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
2015       bfd_elf32_swap_reloc_out (output_bfd, &rel,
2016                                 ((Elf32_External_Rel *) htab->srelplt->contents
2017                                  + plt_index));
2018
2019       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2020         {
2021           /* Mark the symbol as undefined, rather than as defined in
2022              the .plt section.  Leave the value alone.  */
2023           sym->st_shndx = SHN_UNDEF;
2024         }
2025     }
2026
2027   if (h->got.offset != (bfd_vma) -1)
2028     {
2029       Elf_Internal_Rel rel;
2030
2031       /* This symbol has an entry in the global offset table.  Set it
2032          up.  */
2033
2034       if (htab->sgot == NULL || htab->srelgot == NULL)
2035         abort ();
2036
2037       rel.r_offset = (htab->sgot->output_section->vma
2038                       + htab->sgot->output_offset
2039                       + (h->got.offset & ~(bfd_vma) 1));
2040
2041       /* If this is a static link, or it is a -Bsymbolic link and the
2042          symbol is defined locally or was forced to be local because
2043          of a version file, we just want to emit a RELATIVE reloc.
2044          The entry in the global offset table will already have been
2045          initialized in the relocate_section function.  */
2046       if (info->shared
2047           && (info->symbolic
2048               || h->dynindx == -1
2049               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2050           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2051         {
2052           BFD_ASSERT((h->got.offset & 1) != 0);
2053           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2054         }
2055       else
2056         {
2057           BFD_ASSERT((h->got.offset & 1) == 0);
2058           bfd_put_32 (output_bfd, (bfd_vma) 0,
2059                       htab->sgot->contents + h->got.offset);
2060           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2061         }
2062
2063       bfd_elf32_swap_reloc_out (output_bfd, &rel,
2064                                 ((Elf32_External_Rel *) htab->srelgot->contents
2065                                  + htab->srelgot->reloc_count));
2066       ++htab->srelgot->reloc_count;
2067     }
2068
2069   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2070     {
2071       Elf_Internal_Rel rel;
2072
2073       /* This symbol needs a copy reloc.  Set it up.  */
2074
2075       if (h->dynindx == -1
2076           || (h->root.type != bfd_link_hash_defined
2077               && h->root.type != bfd_link_hash_defweak)
2078           || htab->srelbss == NULL)
2079         abort ();
2080
2081       rel.r_offset = (h->root.u.def.value
2082                       + h->root.u.def.section->output_section->vma
2083                       + h->root.u.def.section->output_offset);
2084       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2085       bfd_elf32_swap_reloc_out (output_bfd, &rel,
2086                                 ((Elf32_External_Rel *) htab->srelbss->contents
2087                                  + htab->srelbss->reloc_count));
2088       ++htab->srelbss->reloc_count;
2089     }
2090
2091   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2092   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2093       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2094     sym->st_shndx = SHN_ABS;
2095
2096   return true;
2097 }
2098
2099 /* Finish up the dynamic sections.  */
2100
2101 static boolean
2102 elf_i386_finish_dynamic_sections (output_bfd, info)
2103      bfd *output_bfd;
2104      struct bfd_link_info *info;
2105 {
2106   struct elf_i386_link_hash_table *htab;
2107   bfd *dynobj;
2108   asection *sdyn;
2109
2110   htab = elf_i386_hash_table (info);
2111   dynobj = htab->root.dynobj;
2112   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2113
2114   if (htab->root.dynamic_sections_created)
2115     {
2116       Elf32_External_Dyn *dyncon, *dynconend;
2117
2118       if (sdyn == NULL || htab->sgot == NULL)
2119         abort ();
2120
2121       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2122       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2123       for (; dyncon < dynconend; dyncon++)
2124         {
2125           Elf_Internal_Dyn dyn;
2126
2127           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2128
2129           switch (dyn.d_tag)
2130             {
2131             default:
2132               break;
2133
2134             case DT_PLTGOT:
2135               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2136               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2137               break;
2138
2139             case DT_JMPREL:
2140               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2141               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2142               break;
2143
2144             case DT_PLTRELSZ:
2145               if (htab->srelplt->output_section->_cooked_size != 0)
2146                 dyn.d_un.d_val = htab->srelplt->output_section->_cooked_size;
2147               else
2148                 dyn.d_un.d_val = htab->srelplt->output_section->_raw_size;
2149               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2150               break;
2151
2152             case DT_RELSZ:
2153               /* My reading of the SVR4 ABI indicates that the
2154                  procedure linkage table relocs (DT_JMPREL) should be
2155                  included in the overall relocs (DT_REL).  This is
2156                  what Solaris does.  However, UnixWare can not handle
2157                  that case.  Therefore, we override the DT_RELSZ entry
2158                  here to make it not include the JMPREL relocs.  Since
2159                  the linker script arranges for .rel.plt to follow all
2160                  other relocation sections, we don't have to worry
2161                  about changing the DT_REL entry.  */
2162               if (htab->srelplt != NULL)
2163                 {
2164                   if (htab->srelplt->output_section->_cooked_size != 0)
2165                     dyn.d_un.d_val -= htab->srelplt->output_section->_cooked_size;
2166                   else
2167                     dyn.d_un.d_val -= htab->srelplt->output_section->_raw_size;
2168                 }
2169               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2170               break;
2171             }
2172         }
2173
2174       /* Fill in the first entry in the procedure linkage table.  */
2175       if (htab->splt && htab->splt->_raw_size > 0)
2176         {
2177           if (info->shared)
2178             memcpy (htab->splt->contents,
2179                     elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2180           else
2181             {
2182               memcpy (htab->splt->contents,
2183                       elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2184               bfd_put_32 (output_bfd,
2185                           (htab->sgotplt->output_section->vma
2186                            + htab->sgotplt->output_offset
2187                            + 4),
2188                           htab->splt->contents + 2);
2189               bfd_put_32 (output_bfd,
2190                           (htab->sgotplt->output_section->vma
2191                            + htab->sgotplt->output_offset
2192                            + 8),
2193                           htab->splt->contents + 8);
2194             }
2195
2196           /* UnixWare sets the entsize of .plt to 4, although that doesn't
2197              really seem like the right value.  */
2198           elf_section_data (htab->splt->output_section)
2199             ->this_hdr.sh_entsize = 4;
2200         }
2201     }
2202
2203   if (htab->sgotplt)
2204     {
2205       /* Fill in the first three entries in the global offset table.  */
2206       if (htab->sgotplt->_raw_size > 0)
2207         {
2208           bfd_put_32 (output_bfd,
2209                       (sdyn == NULL ? (bfd_vma) 0
2210                        : sdyn->output_section->vma + sdyn->output_offset),
2211                       htab->sgotplt->contents);
2212           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
2213           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2214         }
2215
2216       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
2217     }
2218   return true;
2219 }
2220
2221 /* Set the correct type for an x86 ELF section.  We do this by the
2222    section name, which is a hack, but ought to work.  */
2223
2224 static boolean
2225 elf_i386_fake_sections (abfd, hdr, sec)
2226      bfd *abfd ATTRIBUTE_UNUSED;
2227      Elf32_Internal_Shdr *hdr;
2228      asection *sec;
2229 {
2230   register const char *name;
2231
2232   name = bfd_get_section_name (abfd, sec);
2233
2234   if (strcmp (name, ".reloc") == 0)
2235     /*
2236      * This is an ugly, but unfortunately necessary hack that is
2237      * needed when producing EFI binaries on x86. It tells
2238      * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2239      * containing ELF relocation info.  We need this hack in order to
2240      * be able to generate ELF binaries that can be translated into
2241      * EFI applications (which are essentially COFF objects).  Those
2242      * files contain a COFF ".reloc" section inside an ELFNN object,
2243      * which would normally cause BFD to segfault because it would
2244      * attempt to interpret this section as containing relocation
2245      * entries for section "oc".  With this hack enabled, ".reloc"
2246      * will be treated as a normal data section, which will avoid the
2247      * segfault.  However, you won't be able to create an ELFNN binary
2248      * with a section named "oc" that needs relocations, but that's
2249      * the kind of ugly side-effects you get when detecting section
2250      * types based on their names...  In practice, this limitation is
2251      * unlikely to bite.
2252      */
2253     hdr->sh_type = SHT_PROGBITS;
2254
2255   return true;
2256 }
2257
2258 static enum elf_reloc_type_class
2259 elf_i386_reloc_type_class (rela)
2260      const Elf_Internal_Rela *rela;
2261 {
2262   switch ((int) ELF32_R_TYPE (rela->r_info))
2263     {
2264     case R_386_RELATIVE:
2265       return reloc_class_relative;
2266     case R_386_JUMP_SLOT:
2267       return reloc_class_plt;
2268     case R_386_COPY:
2269       return reloc_class_copy;
2270     default:
2271       return reloc_class_normal;
2272     }
2273 }
2274
2275 /* Support for core dump NOTE sections */
2276 static boolean
2277 elf_i386_grok_prstatus (abfd, note)
2278      bfd *abfd;
2279      Elf_Internal_Note *note;
2280 {
2281   int offset;
2282   size_t raw_size;
2283
2284   switch (note->descsz)
2285     {
2286       default:
2287         return false;
2288
2289       case 144:         /* Linux/i386 */
2290         /* pr_cursig */
2291         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2292
2293         /* pr_pid */
2294         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
2295
2296         /* pr_reg */
2297         offset = 72;
2298         raw_size = 68;
2299
2300         break;
2301     }
2302
2303   /* Make a ".reg/999" section.  */
2304   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2305                                           raw_size, note->descpos + offset);
2306 }
2307
2308 static boolean
2309 elf_i386_grok_psinfo (abfd, note)
2310      bfd *abfd;
2311      Elf_Internal_Note *note;
2312 {
2313   switch (note->descsz)
2314     {
2315       default:
2316         return false;
2317
2318       case 128:         /* Linux/MIPS elf_prpsinfo */
2319         elf_tdata (abfd)->core_program
2320          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
2321         elf_tdata (abfd)->core_command
2322          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
2323     }
2324
2325   /* Note that for some reason, a spurious space is tacked
2326      onto the end of the args in some (at least one anyway)
2327      implementations, so strip it off if it exists.  */
2328
2329   {
2330     char *command = elf_tdata (abfd)->core_command;
2331     int n = strlen (command);
2332
2333     if (0 < n && command[n - 1] == ' ')
2334       command[n - 1] = '\0';
2335   }
2336
2337   return true;
2338 }
2339
2340 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
2341 #define TARGET_LITTLE_NAME              "elf32-i386"
2342 #define ELF_ARCH                        bfd_arch_i386
2343 #define ELF_MACHINE_CODE                EM_386
2344 #define ELF_MAXPAGESIZE                 0x1000
2345
2346 #define elf_backend_can_gc_sections     1
2347 #define elf_backend_want_got_plt        1
2348 #define elf_backend_plt_readonly        1
2349 #define elf_backend_want_plt_sym        0
2350 #define elf_backend_got_header_size     12
2351 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
2352
2353 #define elf_info_to_howto                     elf_i386_info_to_howto
2354 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
2355
2356 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
2357 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
2358 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
2359
2360 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
2361 #define elf_backend_check_relocs              elf_i386_check_relocs
2362 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
2363 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
2364 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
2365 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
2366 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
2367 #define elf_backend_relocate_section          elf_i386_relocate_section
2368 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
2369 #define elf_backend_fake_sections             elf_i386_fake_sections
2370 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
2371 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
2372 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
2373
2374 #include "elf32-target.h"