bfd/elflink.c

   1 /* ELF linking support for BFD.
   2    Copyright 1995, 1996, 1997, 1998, 1999 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   int ptralign;
  37
  38   /* This function may be called more than once.  */
  39   if (bfd_get_section_by_name (abfd, ".got") != NULL)
  40     return true;
  41
  42   switch (bed->s->arch_size)
  43     {
  44     case 32: ptralign = 2; break;
  45     case 64: ptralign = 3; break;
  46     default: abort();
  47     }
  48
  49   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
  50            | SEC_LINKER_CREATED);
  51
  52   s = bfd_make_section (abfd, ".got");
  53   if (s == NULL
  54       || !bfd_set_section_flags (abfd, s, flags)
  55       || !bfd_set_section_alignment (abfd, s, ptralign))
  56     return false;
  57
  58   if (bed->want_got_plt)
  59     {
  60       s = bfd_make_section (abfd, ".got.plt");
  61       if (s == NULL
  62           || !bfd_set_section_flags (abfd, s, flags)
  63           || !bfd_set_section_alignment (abfd, s, ptralign))
  64         return false;
  65     }
  66
  67   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
  68      (or .got.plt) section.  We don't do this in the linker script
  69      because we don't want to define the symbol if we are not creating
  70      a global offset table.  */
  71   h = NULL;
  72   if (!(_bfd_generic_link_add_one_symbol
  73         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
  74          bed->got_symbol_offset, (const char *) NULL, false,
  75          bed->collect, (struct bfd_link_hash_entry **) &h)))
  76     return false;
  77   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
  78   h->type = STT_OBJECT;
  79
  80   if (info->shared
  81       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
  82     return false;
  83
  84   elf_hash_table (info)->hgot = h;
  85
  86   /* The first bit of the global offset table is the header.  */
  87   s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
  88
  89   return true;
  90 }
  91 \f
  92
  93 /* Create dynamic sections when linking against a dynamic object.  */
  94
  95 boolean
  96 _bfd_elf_create_dynamic_sections (abfd, info)
  97      bfd *abfd;
  98      struct bfd_link_info *info;
  99 {
 100   flagword flags, pltflags;
 101   register asection *s;
 102   struct elf_backend_data *bed = get_elf_backend_data (abfd);
 103   int ptralign = 0;
 104
 105   switch (bed->s->arch_size)
 106     {
 107     case 32: ptralign = 2; break;
 108     case 64: ptralign = 3; break;
 109     default: abort();
 110     }
 111
 112   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
 113      .rel[a].bss sections.  */
 114
 115   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 116            | SEC_LINKER_CREATED);
 117
 118   pltflags = flags;
 119   pltflags |= SEC_CODE;
 120   if (bed->plt_not_loaded)
 121     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
 122   if (bed->plt_readonly)
 123     pltflags |= SEC_READONLY;
 124
 125   s = bfd_make_section (abfd, ".plt");
 126   if (s == NULL
 127       || ! bfd_set_section_flags (abfd, s, pltflags)
 128       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
 129     return false;
 130
 131   if (bed->want_plt_sym)
 132     {
 133       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
 134          .plt section.  */
 135       struct elf_link_hash_entry *h = NULL;
 136       if (! (_bfd_generic_link_add_one_symbol
 137              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
 138               (bfd_vma) 0, (const char *) NULL, false,
 139               get_elf_backend_data (abfd)->collect,
 140               (struct bfd_link_hash_entry **) &h)))
 141         return false;
 142       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 143       h->type = STT_OBJECT;
 144
 145       if (info->shared
 146           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 147         return false;
 148     }
 149
 150   s = bfd_make_section (abfd,
 151                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
 152   if (s == NULL
 153       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 154       || ! bfd_set_section_alignment (abfd, s, ptralign))
 155     return false;
 156
 157   if (! _bfd_elf_create_got_section (abfd, info))
 158     return false;
 159
 160   /* The .dynbss section is a place to put symbols which are defined
 161      by dynamic objects, are referenced by regular objects, and are
 162      not functions.  We must allocate space for them in the process
 163      image and use a R_*_COPY reloc to tell the dynamic linker to
 164      initialize them at run time.  The linker script puts the .dynbss
 165      section into the .bss section of the final image.  */
 166   s = bfd_make_section (abfd, ".dynbss");
 167   if (s == NULL
 168       || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
 169     return false;
 170
 171   /* The .rel[a].bss section holds copy relocs.  This section is not
 172      normally needed.  We need to create it here, though, so that the
 173      linker will map it to an output section.  We can't just create it
 174      only if we need it, because we will not know whether we need it
 175      until we have seen all the input files, and the first time the
 176      main linker code calls BFD after examining all the input files
 177      (size_dynamic_sections) the input sections have already been
 178      mapped to the output sections.  If the section turns out not to
 179      be needed, we can discard it later.  We will never need this
 180      section when generating a shared object, since they do not use
 181      copy relocs.  */
 182   if (! info->shared)
 183     {
 184       s = bfd_make_section (abfd,
 185                             (bed->default_use_rela_p
 186                              ? ".rela.bss" : ".rel.bss"));
 187       if (s == NULL
 188           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 189           || ! bfd_set_section_alignment (abfd, s, ptralign))
 190         return false;
 191     }
 192
 193   return true;
 194 }
 195 \f
 196
 197 /* Record a new dynamic symbol.  We record the dynamic symbols as we
 198    read the input files, since we need to have a list of all of them
 199    before we can determine the final sizes of the output sections.
 200    Note that we may actually call this function even though we are not
 201    going to output any dynamic symbols; in some cases we know that a
 202    symbol should be in the dynamic symbol table, but only if there is
 203    one.  */
 204
 205 boolean
 206 _bfd_elf_link_record_dynamic_symbol (info, h)
 207      struct bfd_link_info *info;
 208      struct elf_link_hash_entry *h;
 209 {
 210   if (h->dynindx == -1)
 211     {
 212       struct bfd_strtab_hash *dynstr;
 213       char *p, *alc;
 214       const char *name;
 215       boolean copy;
 216       bfd_size_type indx;
 217
 218       h->dynindx = elf_hash_table (info)->dynsymcount;
 219       ++elf_hash_table (info)->dynsymcount;
 220
 221       dynstr = elf_hash_table (info)->dynstr;
 222       if (dynstr == NULL)
 223         {
 224           /* Create a strtab to hold the dynamic symbol names.  */
 225           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_stringtab_init ();
 226           if (dynstr == NULL)
 227             return false;
 228         }
 229
 230       /* We don't put any version information in the dynamic string
 231          table.  */
 232       name = h->root.root.string;
 233       p = strchr (name, ELF_VER_CHR);
 234       if (p == NULL)
 235         {
 236           alc = NULL;
 237           copy = false;
 238         }
 239       else
 240         {
 241           alc = bfd_malloc (p - name + 1);
 242           if (alc == NULL)
 243             return false;
 244           strncpy (alc, name, p - name);
 245           alc[p - name] = '\0';
 246           name = alc;
 247           copy = true;
 248         }
 249
 250       indx = _bfd_stringtab_add (dynstr, name, true, copy);
 251
 252       if (alc != NULL)
 253         free (alc);
 254
 255       if (indx == (bfd_size_type) -1)
 256         return false;
 257       h->dynstr_index = indx;
 258     }
 259
 260   return true;
 261 }
 262
 263 /* Increase the index at which H will appear in the dynamic symbol
 264    table by INCREMENT (which is really an `int *').  Called via
 265    elf_link_hash_traverse.  */
 266
 267 boolean
 268 _bfd_elf_link_adjust_dynindx (h, increment)
 269      struct elf_link_hash_entry *h;
 270      PTR increment;
 271 {
 272   if (h->dynindx != -1)
 273     h->dynindx += *((int *) increment);
 274
 275   return true;
 276 }
 277 \f
 278 /* Create a special linker section, or return a pointer to a linker section already created  */
 279
 280 elf_linker_section_t *
 281 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 282      bfd *abfd;
 283      struct bfd_link_info *info;
 284      enum elf_linker_section_enum which;
 285      elf_linker_section_t *defaults;
 286 {
 287   bfd *dynobj = elf_hash_table (info)->dynobj;
 288   elf_linker_section_t *lsect;
 289
 290   /* Record the first bfd section that needs the special section */
 291   if (!dynobj)
 292     dynobj = elf_hash_table (info)->dynobj = abfd;
 293
 294   /* If this is the first time, create the section */
 295   lsect = elf_linker_section (dynobj, which);
 296   if (!lsect)
 297     {
 298       asection *s;
 299
 300       lsect = (elf_linker_section_t *)
 301         bfd_alloc (dynobj, sizeof (elf_linker_section_t));
 302
 303       *lsect = *defaults;
 304       elf_linker_section (dynobj, which) = lsect;
 305       lsect->which = which;
 306       lsect->hole_written_p = false;
 307
 308       /* See if the sections already exist */
 309       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 310       if (!s || (s->flags & defaults->flags) != defaults->flags)
 311         {
 312           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 313
 314           if (s == NULL)
 315             return (elf_linker_section_t *)0;
 316
 317           bfd_set_section_flags (dynobj, s, defaults->flags);
 318           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 319         }
 320       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 321         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 322
 323       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 324
 325       /* Is there a hole we have to provide?  If so check whether the segment is
 326          too big already */
 327       if (lsect->hole_size)
 328         {
 329           lsect->hole_offset = s->_raw_size;
 330           s->_raw_size += lsect->hole_size;
 331           if (lsect->hole_offset > lsect->max_hole_offset)
 332             {
 333               (*_bfd_error_handler) (_("%s: Section %s is already to large to put hole of %ld bytes in"),
 334                                      bfd_get_filename (abfd),
 335                                      lsect->name,
 336                                      (long)lsect->hole_size);
 337
 338               bfd_set_error (bfd_error_bad_value);
 339               return (elf_linker_section_t *)0;
 340             }
 341         }
 342
 343 #ifdef DEBUG
 344       fprintf (stderr, "Creating section %s, current size = %ld\n",
 345                lsect->name, (long)s->_raw_size);
 346 #endif
 347
 348       if (lsect->sym_name)
 349         {
 350           struct elf_link_hash_entry *h = NULL;
 351 #ifdef DEBUG
 352           fprintf (stderr, "Adding %s to section %s\n",
 353                    lsect->sym_name,
 354                    lsect->name);
 355 #endif
 356           h = (struct elf_link_hash_entry *)
 357             bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
 358
 359           if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 360               && !(_bfd_generic_link_add_one_symbol (info,
 361                                                      abfd,
 362                                                      lsect->sym_name,
 363                                                      BSF_GLOBAL,
 364                                                      s,
 365                                                      ((lsect->hole_size)
 366                                                       ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 367                                                       : lsect->sym_offset),
 368                                                      (const char *) NULL,
 369                                                      false,
 370                                                      get_elf_backend_data (abfd)->collect,
 371                                                      (struct bfd_link_hash_entry **) &h)))
 372             return (elf_linker_section_t *)0;
 373
 374           if ((defaults->which != LINKER_SECTION_SDATA)
 375               && (defaults->which != LINKER_SECTION_SDATA2))
 376             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 377
 378           h->type = STT_OBJECT;
 379           lsect->sym_hash = h;
 380
 381           if (info->shared
 382               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 383             return (elf_linker_section_t *)0;
 384         }
 385     }
 386
 387 #if 0
 388   /* This does not make sense.  The sections which may exist in the
 389      object file have nothing to do with the sections we want to
 390      create.  */
 391
 392   /* Find the related sections if they have been created */
 393   if (lsect->bss_name && !lsect->bss_section)
 394     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 395
 396   if (lsect->rel_name && !lsect->rel_section)
 397     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 398 #endif
 399
 400   return lsect;
 401 }
 402
 403 \f
 404 /* Find a linker generated pointer with a given addend and type.  */
 405
 406 elf_linker_section_pointers_t *
 407 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 408      elf_linker_section_pointers_t *linker_pointers;
 409      bfd_signed_vma addend;
 410      elf_linker_section_enum_t which;
 411 {
 412   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 413     {
 414       if (which == linker_pointers->which && addend == linker_pointers->addend)
 415         return linker_pointers;
 416     }
 417
 418   return (elf_linker_section_pointers_t *)0;
 419 }
 420
 421 \f
 422 /* Make the .rela section corresponding to the generated linker section.  */
 423
 424 boolean
 425 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 426      bfd *dynobj;
 427      elf_linker_section_t *lsect;
 428      int alignment;
 429 {
 430   if (lsect->rel_section)
 431     return true;
 432
 433   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 434   if (lsect->rel_section == NULL)
 435     {
 436       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 437       if (lsect->rel_section == NULL
 438           || ! bfd_set_section_flags (dynobj,
 439                                       lsect->rel_section,
 440                                       (SEC_ALLOC
 441                                        | SEC_LOAD
 442                                        | SEC_HAS_CONTENTS
 443                                        | SEC_IN_MEMORY
 444                                        | SEC_LINKER_CREATED
 445                                        | SEC_READONLY))
 446           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 447         return false;
 448     }
 449
 450   return true;
 451 }