bfd/elflink.c

   1 /* ELF linking support for BFD.
   2    Copyright 1995 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "bfdlink.h"
  23 #include "libbfd.h"
  24 #define ARCH_SIZE 0
  25 #include "elf-bfd.h"
  26
  27 boolean
  28 _bfd_elf_create_got_section (abfd, info)
  29      bfd *abfd;
  30      struct bfd_link_info *info;
  31 {
  32   flagword flags;
  33   register asection *s;
  34   struct elf_link_hash_entry *h;
  35   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  36
  37   /* This function may be called more than once.  */
  38   if (bfd_get_section_by_name (abfd, ".got") != NULL)
  39     return true;
  40
  41   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
  42            | SEC_LINKER_CREATED);
  43
  44   s = bfd_make_section (abfd, ".got");
  45   if (s == NULL
  46       || !bfd_set_section_flags (abfd, s, flags)
  47       || !bfd_set_section_alignment (abfd, s, 2))
  48     return false;
  49
  50   if (bed->want_got_plt)
  51     {
  52       s = bfd_make_section (abfd, ".got.plt");
  53       if (s == NULL
  54           || !bfd_set_section_flags (abfd, s, flags)
  55           || !bfd_set_section_alignment (abfd, s, 2))
  56         return false;
  57     }
  58
  59   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
  60      (or .got.plt) section.  We don't do this in the linker script
  61      because we don't want to define the symbol if we are not creating
  62      a global offset table.  */
  63   h = NULL;
  64   if (!(_bfd_generic_link_add_one_symbol
  65         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s, (bfd_vma) 0,
  66          (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
  67          (struct bfd_link_hash_entry **) &h)))
  68     return false;
  69   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
  70   h->type = STT_OBJECT;
  71
  72   if (info->shared
  73       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
  74     return false;
  75
  76   elf_hash_table (info)->hgot = h;
  77
  78   /* The first three global offset table entries are reserved.  */
  79   s->_raw_size += 3 * 4;
  80
  81   return true;
  82 }
  83 \f
  84
  85 /* Create dynamic sections when linking against a dynamic object.  */
  86
  87 boolean
  88 _bfd_elf_create_dynamic_sections (abfd, info)
  89      bfd *abfd;
  90      struct bfd_link_info *info;
  91 {
  92   flagword flags;
  93   register asection *s;
  94   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  95
  96   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
  97      .rel[a].bss sections.  */
  98
  99   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 100            | SEC_LINKER_CREATED);
 101
 102   s = bfd_make_section (abfd, ".plt");
 103   if (s == NULL
 104       || ! bfd_set_section_flags (abfd, s,
 105                                   (flags | SEC_CODE
 106                                    | (bed->plt_readonly ? SEC_READONLY : 0)))
 107       || ! bfd_set_section_alignment (abfd, s, 2))
 108     return false;
 109
 110   if (bed->want_plt_sym)
 111     {
 112       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
 113          .plt section.  */
 114       struct elf_link_hash_entry *h = NULL;
 115       if (! (_bfd_generic_link_add_one_symbol
 116              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
 117               (bfd_vma) 0, (const char *) NULL, false,
 118               get_elf_backend_data (abfd)->collect,
 119               (struct bfd_link_hash_entry **) &h)))
 120         return false;
 121       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 122       h->type = STT_OBJECT;
 123
 124       if (info->shared
 125           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 126         return false;
 127     }
 128
 129   s = bfd_make_section (abfd, bed->use_rela_p ? ".rela.plt" : ".rel.plt");
 130   if (s == NULL
 131       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 132       || ! bfd_set_section_alignment (abfd, s, 2))
 133     return false;
 134
 135   if (! _bfd_elf_create_got_section (abfd, info))
 136     return false;
 137
 138   /* The .dynbss section is a place to put symbols which are defined
 139      by dynamic objects, are referenced by regular objects, and are
 140      not functions.  We must allocate space for them in the process
 141      image and use a R_*_COPY reloc to tell the dynamic linker to
 142      initialize them at run time.  The linker script puts the .dynbss
 143      section into the .bss section of the final image.  */
 144   s = bfd_make_section (abfd, ".dynbss");
 145   if (s == NULL
 146       || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
 147     return false;
 148
 149   /* The .rel[a].bss section holds copy relocs.  This section is not
 150      normally needed.  We need to create it here, though, so that the
 151      linker will map it to an output section.  We can't just create it
 152      only if we need it, because we will not know whether we need it
 153      until we have seen all the input files, and the first time the
 154      main linker code calls BFD after examining all the input files
 155      (size_dynamic_sections) the input sections have already been
 156      mapped to the output sections.  If the section turns out not to
 157      be needed, we can discard it later.  We will never need this
 158      section when generating a shared object, since they do not use
 159      copy relocs.  */
 160   if (! info->shared)
 161     {
 162       s = bfd_make_section (abfd, bed->use_rela_p ? ".rela.bss" : ".rel.bss");
 163       if (s == NULL
 164           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 165           || ! bfd_set_section_alignment (abfd, s, 2))
 166         return false;
 167     }
 168
 169   return true;
 170 }
 171 \f
 172
 173 /* Record a new dynamic symbol.  We record the dynamic symbols as we
 174    read the input files, since we need to have a list of all of them
 175    before we can determine the final sizes of the output sections.
 176    Note that we may actually call this function even though we are not
 177    going to output any dynamic symbols; in some cases we know that a
 178    symbol should be in the dynamic symbol table, but only if there is
 179    one.  */
 180
 181 boolean
 182 _bfd_elf_link_record_dynamic_symbol (info, h)
 183      struct bfd_link_info *info;
 184      struct elf_link_hash_entry *h;
 185 {
 186   if (h->dynindx == -1)
 187     {
 188       struct bfd_strtab_hash *dynstr;
 189
 190       h->dynindx = elf_hash_table (info)->dynsymcount;
 191       ++elf_hash_table (info)->dynsymcount;
 192
 193       dynstr = elf_hash_table (info)->dynstr;
 194       if (dynstr == NULL)
 195         {
 196           /* Create a strtab to hold the dynamic symbol names.  */
 197           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_stringtab_init ();
 198           if (dynstr == NULL)
 199             return false;
 200         }
 201
 202       h->dynstr_index = ((unsigned long)
 203                          _bfd_stringtab_add (dynstr, h->root.root.string,
 204                                              true, false));
 205       if (h->dynstr_index == (unsigned long) -1)
 206         return false;
 207     }
 208
 209   return true;
 210 }
 211 \f
 212 /* Create a special linker section, or return a pointer to a linker section already created  */
 213
 214 elf_linker_section_t *
 215 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 216      bfd *abfd;
 217      struct bfd_link_info *info;
 218      enum elf_linker_section_enum which;
 219      elf_linker_section_t *defaults;
 220 {
 221   bfd *dynobj = elf_hash_table (info)->dynobj;
 222   elf_linker_section_t *lsect;
 223
 224   /* Record the first bfd section that needs the special section */
 225   if (!dynobj)
 226     dynobj = elf_hash_table (info)->dynobj = abfd;
 227
 228   /* If this is the first time, create the section */
 229   lsect = elf_linker_section (dynobj, which);
 230   if (!lsect)
 231     {
 232       asection *s;
 233
 234       lsect = (elf_linker_section_t *)
 235         bfd_alloc (dynobj, sizeof (elf_linker_section_t));
 236
 237       *lsect = *defaults;
 238       elf_linker_section (dynobj, which) = lsect;
 239       lsect->which = which;
 240       lsect->hole_written_p = false;
 241
 242       /* See if the sections already exist */
 243       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 244       if (!s || (s->flags & defaults->flags) != defaults->flags)
 245         {
 246           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 247
 248           if (s == NULL)
 249             return (elf_linker_section_t *)0;
 250
 251           bfd_set_section_flags (dynobj, s, defaults->flags);
 252           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 253         }
 254       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 255         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 256
 257       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 258
 259       /* Is there a hole we have to provide?  If so check whether the segment is
 260          too big already */
 261       if (lsect->hole_size)
 262         {
 263           lsect->hole_offset = s->_raw_size;
 264           s->_raw_size += lsect->hole_size;
 265           if (lsect->hole_offset > lsect->max_hole_offset)
 266             {
 267               (*_bfd_error_handler) ("%s: Section %s is already to large to put hole of %ld bytes in",
 268                                      bfd_get_filename (abfd),
 269                                      lsect->name,
 270                                      (long)lsect->hole_size);
 271
 272               bfd_set_error (bfd_error_bad_value);
 273               return (elf_linker_section_t *)0;
 274             }
 275         }
 276
 277 #ifdef DEBUG
 278       fprintf (stderr, "Creating section %s, current size = %ld\n",
 279                lsect->name, (long)s->_raw_size);
 280 #endif
 281
 282       if (lsect->sym_name)
 283         {
 284           struct elf_link_hash_entry *h = NULL;
 285 #ifdef DEBUG
 286           fprintf (stderr, "Adding %s to section %s\n",
 287                    lsect->sym_name,
 288                    lsect->name);
 289 #endif
 290           h = (struct elf_link_hash_entry *)
 291             bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
 292
 293           if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 294               && !(_bfd_generic_link_add_one_symbol (info,
 295                                                      abfd,
 296                                                      lsect->sym_name,
 297                                                      BSF_GLOBAL,
 298                                                      s,
 299                                                      ((lsect->hole_size)
 300                                                       ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 301                                                       : lsect->sym_offset),
 302                                                      (const char *) NULL,
 303                                                      false,
 304                                                      get_elf_backend_data (abfd)->collect,
 305                                                      (struct bfd_link_hash_entry **) &h)))
 306             return (elf_linker_section_t *)0;
 307
 308           if ((defaults->which != LINKER_SECTION_SDATA)
 309               && (defaults->which != LINKER_SECTION_SDATA2))
 310             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 311
 312           h->type = STT_OBJECT;
 313           lsect->sym_hash = h;
 314
 315           if (info->shared
 316               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 317             return (elf_linker_section_t *)0;
 318         }
 319     }
 320
 321   /* Find the related sections if they have been created */
 322   if (lsect->bss_name && !lsect->bss_section)
 323     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 324
 325   if (lsect->rel_name && !lsect->rel_section)
 326     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 327
 328   return lsect;
 329 }
 330
 331 \f
 332 /* Find a linker generated pointer with a given addend and type.  */
 333
 334 elf_linker_section_pointers_t *
 335 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 336      elf_linker_section_pointers_t *linker_pointers;
 337      bfd_signed_vma addend;
 338      elf_linker_section_enum_t which;
 339 {
 340   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 341     {
 342       if (which == linker_pointers->which && addend == linker_pointers->addend)
 343         return linker_pointers;
 344     }
 345
 346   return (elf_linker_section_pointers_t *)0;
 347 }
 348
 349 \f
 350 /* Make the .rela section corresponding to the generated linker section.  */
 351
 352 boolean
 353 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 354      bfd *dynobj;
 355      elf_linker_section_t *lsect;
 356      int alignment;
 357 {
 358   if (lsect->rel_section)
 359     return true;
 360
 361   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 362   if (lsect->rel_section == NULL)
 363     {
 364       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 365       if (lsect->rel_section == NULL
 366           || ! bfd_set_section_flags (dynobj,
 367                                       lsect->rel_section,
 368                                       (SEC_ALLOC
 369                                        | SEC_LOAD
 370                                        | SEC_HAS_CONTENTS
 371                                        | SEC_IN_MEMORY
 372                                        | SEC_LINKER_CREATED
 373                                        | SEC_READONLY))
 374           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 375         return false;
 376     }
 377
 378   return true;
 379 }