bfd/elflink.c

   1 /* ELF linking support for BFD.
   2    Copyright 1995, 96, 97, 98, 99, 2000 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   if (bed->want_dynbss)
 161     {
 162       /* The .dynbss section is a place to put symbols which are defined
 163          by dynamic objects, are referenced by regular objects, and are
 164          not functions.  We must allocate space for them in the process
 165          image and use a R_*_COPY reloc to tell the dynamic linker to
 166          initialize them at run time.  The linker script puts the .dynbss
 167          section into the .bss section of the final image.  */
 168       s = bfd_make_section (abfd, ".dynbss");
 169       if (s == NULL
 170           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
 171         return false;
 172
 173       /* The .rel[a].bss section holds copy relocs.  This section is not
 174      normally needed.  We need to create it here, though, so that the
 175      linker will map it to an output section.  We can't just create it
 176      only if we need it, because we will not know whether we need it
 177      until we have seen all the input files, and the first time the
 178      main linker code calls BFD after examining all the input files
 179      (size_dynamic_sections) the input sections have already been
 180      mapped to the output sections.  If the section turns out not to
 181      be needed, we can discard it later.  We will never need this
 182      section when generating a shared object, since they do not use
 183      copy relocs.  */
 184       if (! info->shared)
 185         {
 186           s = bfd_make_section (abfd,
 187                                 (bed->default_use_rela_p
 188                                  ? ".rela.bss" : ".rel.bss"));
 189           if (s == NULL
 190               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 191               || ! bfd_set_section_alignment (abfd, s, ptralign))
 192             return false;
 193         }
 194     }
 195
 196   return true;
 197 }
 198 \f
 199
 200 /* Record a new dynamic symbol.  We record the dynamic symbols as we
 201    read the input files, since we need to have a list of all of them
 202    before we can determine the final sizes of the output sections.
 203    Note that we may actually call this function even though we are not
 204    going to output any dynamic symbols; in some cases we know that a
 205    symbol should be in the dynamic symbol table, but only if there is
 206    one.  */
 207
 208 boolean
 209 _bfd_elf_link_record_dynamic_symbol (info, h)
 210      struct bfd_link_info *info;
 211      struct elf_link_hash_entry *h;
 212 {
 213   if (h->dynindx == -1)
 214     {
 215       struct bfd_strtab_hash *dynstr;
 216       char *p, *alc;
 217       const char *name;
 218       boolean copy;
 219       bfd_size_type indx;
 220
 221       /* XXX: The ABI draft says the linker must turn hidden and
 222          internal symbols into STB_LOCAL symbols when producing the
 223          DSO. However, if ld.so honors st_other in the dynamic table,
 224          this would not be necessary.  */
 225       switch (ELF_ST_VISIBILITY (h->other))
 226         {
 227         case STV_INTERNAL:
 228         case STV_HIDDEN:
 229           if (h->root.type != bfd_link_hash_undefined
 230               && h->root.type != bfd_link_hash_undefweak)
 231             {
 232               h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
 233               return true;
 234             }
 235
 236         default:
 237           break;
 238         }
 239
 240       h->dynindx = elf_hash_table (info)->dynsymcount;
 241       ++elf_hash_table (info)->dynsymcount;
 242
 243       dynstr = elf_hash_table (info)->dynstr;
 244       if (dynstr == NULL)
 245         {
 246           /* Create a strtab to hold the dynamic symbol names.  */
 247           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_stringtab_init ();
 248           if (dynstr == NULL)
 249             return false;
 250         }
 251
 252       /* We don't put any version information in the dynamic string
 253          table.  */
 254       name = h->root.root.string;
 255       p = strchr (name, ELF_VER_CHR);
 256       if (p == NULL)
 257         {
 258           alc = NULL;
 259           copy = false;
 260         }
 261       else
 262         {
 263           alc = bfd_malloc (p - name + 1);
 264           if (alc == NULL)
 265             return false;
 266           strncpy (alc, name, p - name);
 267           alc[p - name] = '\0';
 268           name = alc;
 269           copy = true;
 270         }
 271
 272       indx = _bfd_stringtab_add (dynstr, name, true, copy);
 273
 274       if (alc != NULL)
 275         free (alc);
 276
 277       if (indx == (bfd_size_type) -1)
 278         return false;
 279       h->dynstr_index = indx;
 280     }
 281
 282   return true;
 283 }
 284
 285 /* Return the dynindex of a local dynamic symbol.  */
 286
 287 long
 288 _bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
 289      struct bfd_link_info *info;
 290      bfd *input_bfd;
 291      long input_indx;
 292 {
 293   struct elf_link_local_dynamic_entry *e;
 294
 295   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
 296     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
 297       return e->dynindx;
 298   return -1;
 299 }
 300
 301 /* This function is used to renumber the dynamic symbols, if some of
 302    them are removed because they are marked as local.  This is called
 303    via elf_link_hash_traverse.  */
 304
 305 static boolean elf_link_renumber_hash_table_dynsyms
 306   PARAMS ((struct elf_link_hash_entry *, PTR));
 307
 308 static boolean
 309 elf_link_renumber_hash_table_dynsyms (h, data)
 310      struct elf_link_hash_entry *h;
 311      PTR data;
 312 {
 313   size_t *count = (size_t *) data;
 314
 315   if (h->dynindx != -1)
 316     h->dynindx = ++(*count);
 317
 318   return true;
 319 }
 320
 321 /* Assign dynsym indicies.  In a shared library we generate a section
 322    symbol for each output section, which come first.  Next come all of
 323    the back-end allocated local dynamic syms, followed by the rest of
 324    the global symbols.  */
 325
 326 unsigned long
 327 _bfd_elf_link_renumber_dynsyms (output_bfd, info)
 328      bfd *output_bfd;
 329      struct bfd_link_info *info;
 330 {
 331   unsigned long dynsymcount = 0;
 332
 333   if (info->shared)
 334     {
 335       asection *p;
 336       for (p = output_bfd->sections; p ; p = p->next)
 337         elf_section_data (p)->dynindx = ++dynsymcount;
 338     }
 339
 340   if (elf_hash_table (info)->dynlocal)
 341     {
 342       struct elf_link_local_dynamic_entry *p;
 343       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
 344         p->dynindx = ++dynsymcount;
 345     }
 346
 347   elf_link_hash_traverse (elf_hash_table (info),
 348                           elf_link_renumber_hash_table_dynsyms,
 349                           &dynsymcount);
 350
 351   /* There is an unused NULL entry at the head of the table which
 352      we must account for in our count.  Unless there weren't any
 353      symbols, which means we'll have no table at all.  */
 354   if (dynsymcount != 0)
 355     ++dynsymcount;
 356
 357   return elf_hash_table (info)->dynsymcount = dynsymcount;
 358 }
 359 \f
 360 /* Create a special linker section, or return a pointer to a linker
 361    section already created */
 362
 363 elf_linker_section_t *
 364 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 365      bfd *abfd;
 366      struct bfd_link_info *info;
 367      enum elf_linker_section_enum which;
 368      elf_linker_section_t *defaults;
 369 {
 370   bfd *dynobj = elf_hash_table (info)->dynobj;
 371   elf_linker_section_t *lsect;
 372
 373   /* Record the first bfd section that needs the special section */
 374   if (!dynobj)
 375     dynobj = elf_hash_table (info)->dynobj = abfd;
 376
 377   /* If this is the first time, create the section */
 378   lsect = elf_linker_section (dynobj, which);
 379   if (!lsect)
 380     {
 381       asection *s;
 382
 383       lsect = (elf_linker_section_t *)
 384         bfd_alloc (dynobj, sizeof (elf_linker_section_t));
 385
 386       *lsect = *defaults;
 387       elf_linker_section (dynobj, which) = lsect;
 388       lsect->which = which;
 389       lsect->hole_written_p = false;
 390
 391       /* See if the sections already exist */
 392       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 393       if (!s || (s->flags & defaults->flags) != defaults->flags)
 394         {
 395           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 396
 397           if (s == NULL)
 398             return (elf_linker_section_t *)0;
 399
 400           bfd_set_section_flags (dynobj, s, defaults->flags);
 401           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 402         }
 403       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 404         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 405
 406       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 407
 408       /* Is there a hole we have to provide?  If so check whether the segment is
 409          too big already */
 410       if (lsect->hole_size)
 411         {
 412           lsect->hole_offset = s->_raw_size;
 413           s->_raw_size += lsect->hole_size;
 414           if (lsect->hole_offset > lsect->max_hole_offset)
 415             {
 416               (*_bfd_error_handler) (_("%s: Section %s is already to large to put hole of %ld bytes in"),
 417                                      bfd_get_filename (abfd),
 418                                      lsect->name,
 419                                      (long)lsect->hole_size);
 420
 421               bfd_set_error (bfd_error_bad_value);
 422               return (elf_linker_section_t *)0;
 423             }
 424         }
 425
 426 #ifdef DEBUG
 427       fprintf (stderr, "Creating section %s, current size = %ld\n",
 428                lsect->name, (long)s->_raw_size);
 429 #endif
 430
 431       if (lsect->sym_name)
 432         {
 433           struct elf_link_hash_entry *h = NULL;
 434 #ifdef DEBUG
 435           fprintf (stderr, "Adding %s to section %s\n",
 436                    lsect->sym_name,
 437                    lsect->name);
 438 #endif
 439           h = (struct elf_link_hash_entry *)
 440             bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
 441
 442           if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 443               && !(_bfd_generic_link_add_one_symbol (info,
 444                                                      abfd,
 445                                                      lsect->sym_name,
 446                                                      BSF_GLOBAL,
 447                                                      s,
 448                                                      ((lsect->hole_size)
 449                                                       ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 450                                                       : lsect->sym_offset),
 451                                                      (const char *) NULL,
 452                                                      false,
 453                                                      get_elf_backend_data (abfd)->collect,
 454                                                      (struct bfd_link_hash_entry **) &h)))
 455             return (elf_linker_section_t *)0;
 456
 457           if ((defaults->which != LINKER_SECTION_SDATA)
 458               && (defaults->which != LINKER_SECTION_SDATA2))
 459             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 460
 461           h->type = STT_OBJECT;
 462           lsect->sym_hash = h;
 463
 464           if (info->shared
 465               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 466             return (elf_linker_section_t *)0;
 467         }
 468     }
 469
 470 #if 0
 471   /* This does not make sense.  The sections which may exist in the
 472      object file have nothing to do with the sections we want to
 473      create.  */
 474
 475   /* Find the related sections if they have been created */
 476   if (lsect->bss_name && !lsect->bss_section)
 477     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 478
 479   if (lsect->rel_name && !lsect->rel_section)
 480     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 481 #endif
 482
 483   return lsect;
 484 }
 485
 486 \f
 487 /* Find a linker generated pointer with a given addend and type.  */
 488
 489 elf_linker_section_pointers_t *
 490 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 491      elf_linker_section_pointers_t *linker_pointers;
 492      bfd_signed_vma addend;
 493      elf_linker_section_enum_t which;
 494 {
 495   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 496     {
 497       if (which == linker_pointers->which && addend == linker_pointers->addend)
 498         return linker_pointers;
 499     }
 500
 501   return (elf_linker_section_pointers_t *)0;
 502 }
 503
 504 \f
 505 /* Make the .rela section corresponding to the generated linker section.  */
 506
 507 boolean
 508 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 509      bfd *dynobj;
 510      elf_linker_section_t *lsect;
 511      int alignment;
 512 {
 513   if (lsect->rel_section)
 514     return true;
 515
 516   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 517   if (lsect->rel_section == NULL)
 518     {
 519       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 520       if (lsect->rel_section == NULL
 521           || ! bfd_set_section_flags (dynobj,
 522                                       lsect->rel_section,
 523                                       (SEC_ALLOC
 524                                        | SEC_LOAD
 525                                        | SEC_HAS_CONTENTS
 526                                        | SEC_IN_MEMORY
 527                                        | SEC_LINKER_CREATED
 528                                        | SEC_READONLY))
 529           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 530         return false;
 531     }
 532
 533   return true;
 534 }