bfd/elflink.c

   1 /* ELF linking support for BFD.
   2    Copyright 1995, 1996, 1997, 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;
 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 \f
 263 /* Create a special linker section, or return a pointer to a linker section already created  */
 264
 265 elf_linker_section_t *
 266 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 267      bfd *abfd;
 268      struct bfd_link_info *info;
 269      enum elf_linker_section_enum which;
 270      elf_linker_section_t *defaults;
 271 {
 272   bfd *dynobj = elf_hash_table (info)->dynobj;
 273   elf_linker_section_t *lsect;
 274
 275   /* Record the first bfd section that needs the special section */
 276   if (!dynobj)
 277     dynobj = elf_hash_table (info)->dynobj = abfd;
 278
 279   /* If this is the first time, create the section */
 280   lsect = elf_linker_section (dynobj, which);
 281   if (!lsect)
 282     {
 283       asection *s;
 284
 285       lsect = (elf_linker_section_t *)
 286         bfd_alloc (dynobj, sizeof (elf_linker_section_t));
 287
 288       *lsect = *defaults;
 289       elf_linker_section (dynobj, which) = lsect;
 290       lsect->which = which;
 291       lsect->hole_written_p = false;
 292
 293       /* See if the sections already exist */
 294       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 295       if (!s || (s->flags & defaults->flags) != defaults->flags)
 296         {
 297           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 298
 299           if (s == NULL)
 300             return (elf_linker_section_t *)0;
 301
 302           bfd_set_section_flags (dynobj, s, defaults->flags);
 303           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 304         }
 305       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 306         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 307
 308       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 309
 310       /* Is there a hole we have to provide?  If so check whether the segment is
 311          too big already */
 312       if (lsect->hole_size)
 313         {
 314           lsect->hole_offset = s->_raw_size;
 315           s->_raw_size += lsect->hole_size;
 316           if (lsect->hole_offset > lsect->max_hole_offset)
 317             {
 318               (*_bfd_error_handler) (_("%s: Section %s is already to large to put hole of %ld bytes in"),
 319                                      bfd_get_filename (abfd),
 320                                      lsect->name,
 321                                      (long)lsect->hole_size);
 322
 323               bfd_set_error (bfd_error_bad_value);
 324               return (elf_linker_section_t *)0;
 325             }
 326         }
 327
 328 #ifdef DEBUG
 329       fprintf (stderr, "Creating section %s, current size = %ld\n",
 330                lsect->name, (long)s->_raw_size);
 331 #endif
 332
 333       if (lsect->sym_name)
 334         {
 335           struct elf_link_hash_entry *h = NULL;
 336 #ifdef DEBUG
 337           fprintf (stderr, "Adding %s to section %s\n",
 338                    lsect->sym_name,
 339                    lsect->name);
 340 #endif
 341           h = (struct elf_link_hash_entry *)
 342             bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
 343
 344           if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 345               && !(_bfd_generic_link_add_one_symbol (info,
 346                                                      abfd,
 347                                                      lsect->sym_name,
 348                                                      BSF_GLOBAL,
 349                                                      s,
 350                                                      ((lsect->hole_size)
 351                                                       ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 352                                                       : lsect->sym_offset),
 353                                                      (const char *) NULL,
 354                                                      false,
 355                                                      get_elf_backend_data (abfd)->collect,
 356                                                      (struct bfd_link_hash_entry **) &h)))
 357             return (elf_linker_section_t *)0;
 358
 359           if ((defaults->which != LINKER_SECTION_SDATA)
 360               && (defaults->which != LINKER_SECTION_SDATA2))
 361             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 362
 363           h->type = STT_OBJECT;
 364           lsect->sym_hash = h;
 365
 366           if (info->shared
 367               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 368             return (elf_linker_section_t *)0;
 369         }
 370     }
 371
 372 #if 0
 373   /* This does not make sense.  The sections which may exist in the
 374      object file have nothing to do with the sections we want to
 375      create.  */
 376
 377   /* Find the related sections if they have been created */
 378   if (lsect->bss_name && !lsect->bss_section)
 379     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 380
 381   if (lsect->rel_name && !lsect->rel_section)
 382     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 383 #endif
 384
 385   return lsect;
 386 }
 387
 388 \f
 389 /* Find a linker generated pointer with a given addend and type.  */
 390
 391 elf_linker_section_pointers_t *
 392 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 393      elf_linker_section_pointers_t *linker_pointers;
 394      bfd_signed_vma addend;
 395      elf_linker_section_enum_t which;
 396 {
 397   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 398     {
 399       if (which == linker_pointers->which && addend == linker_pointers->addend)
 400         return linker_pointers;
 401     }
 402
 403   return (elf_linker_section_pointers_t *)0;
 404 }
 405
 406 \f
 407 /* Make the .rela section corresponding to the generated linker section.  */
 408
 409 boolean
 410 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 411      bfd *dynobj;
 412      elf_linker_section_t *lsect;
 413      int alignment;
 414 {
 415   if (lsect->rel_section)
 416     return true;
 417
 418   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 419   if (lsect->rel_section == NULL)
 420     {
 421       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 422       if (lsect->rel_section == NULL
 423           || ! bfd_set_section_flags (dynobj,
 424                                       lsect->rel_section,
 425                                       (SEC_ALLOC
 426                                        | SEC_LOAD
 427                                        | SEC_HAS_CONTENTS
 428                                        | SEC_IN_MEMORY
 429                                        | SEC_LINKER_CREATED
 430                                        | SEC_READONLY))
 431           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 432         return false;
 433     }
 434
 435   return true;
 436 }