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