bfd/elflink.c

   1 /* ELF linking support for BFD.
   2    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   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 #define ARCH_SIZE 0
  26 #include "elf-bfd.h"
  27
  28 boolean
  29 _bfd_elf_create_got_section (abfd, info)
  30      bfd *abfd;
  31      struct bfd_link_info *info;
  32 {
  33   flagword flags;
  34   register asection *s;
  35   struct elf_link_hash_entry *h;
  36   struct bfd_link_hash_entry *bh;
  37   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  38   int ptralign;
  39
  40   /* This function may be called more than once.  */
  41   if (bfd_get_section_by_name (abfd, ".got") != NULL)
  42     return true;
  43
  44   switch (bed->s->arch_size)
  45     {
  46     case 32:
  47       ptralign = 2;
  48       break;
  49
  50     case 64:
  51       ptralign = 3;
  52       break;
  53
  54     default:
  55       bfd_set_error (bfd_error_bad_value);
  56       return false;
  57     }
  58
  59   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
  60            | SEC_LINKER_CREATED);
  61
  62   s = bfd_make_section (abfd, ".got");
  63   if (s == NULL
  64       || !bfd_set_section_flags (abfd, s, flags)
  65       || !bfd_set_section_alignment (abfd, s, ptralign))
  66     return false;
  67
  68   if (bed->want_got_plt)
  69     {
  70       s = bfd_make_section (abfd, ".got.plt");
  71       if (s == NULL
  72           || !bfd_set_section_flags (abfd, s, flags)
  73           || !bfd_set_section_alignment (abfd, s, ptralign))
  74         return false;
  75     }
  76
  77   if (bed->want_got_sym)
  78     {
  79       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
  80          (or .got.plt) section.  We don't do this in the linker script
  81          because we don't want to define the symbol if we are not creating
  82          a global offset table.  */
  83       bh = NULL;
  84       if (!(_bfd_generic_link_add_one_symbol
  85             (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
  86              bed->got_symbol_offset, (const char *) NULL, false,
  87              bed->collect, &bh)))
  88         return false;
  89       h = (struct elf_link_hash_entry *) bh;
  90       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
  91       h->type = STT_OBJECT;
  92
  93       if (info->shared
  94           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
  95         return false;
  96
  97       elf_hash_table (info)->hgot = h;
  98     }
  99
 100   /* The first bit of the global offset table is the header.  */
 101   s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
 102
 103   return true;
 104 }
 105 \f
 106 /* Create dynamic sections when linking against a dynamic object.  */
 107
 108 boolean
 109 _bfd_elf_create_dynamic_sections (abfd, info)
 110      bfd *abfd;
 111      struct bfd_link_info *info;
 112 {
 113   flagword flags, pltflags;
 114   register asection *s;
 115   struct elf_backend_data *bed = get_elf_backend_data (abfd);
 116   int ptralign;
 117
 118   switch (bed->s->arch_size)
 119     {
 120     case 32:
 121       ptralign = 2;
 122       break;
 123
 124     case 64:
 125       ptralign = 3;
 126       break;
 127
 128     default:
 129       bfd_set_error (bfd_error_bad_value);
 130       return false;
 131     }
 132
 133   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
 134      .rel[a].bss sections.  */
 135
 136   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 137            | SEC_LINKER_CREATED);
 138
 139   pltflags = flags;
 140   pltflags |= SEC_CODE;
 141   if (bed->plt_not_loaded)
 142     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
 143   if (bed->plt_readonly)
 144     pltflags |= SEC_READONLY;
 145
 146   s = bfd_make_section (abfd, ".plt");
 147   if (s == NULL
 148       || ! bfd_set_section_flags (abfd, s, pltflags)
 149       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
 150     return false;
 151
 152   if (bed->want_plt_sym)
 153     {
 154       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
 155          .plt section.  */
 156       struct elf_link_hash_entry *h;
 157       struct bfd_link_hash_entry *bh = NULL;
 158
 159       if (! (_bfd_generic_link_add_one_symbol
 160              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
 161               (bfd_vma) 0, (const char *) NULL, false,
 162               get_elf_backend_data (abfd)->collect, &bh)))
 163         return false;
 164       h = (struct elf_link_hash_entry *) bh;
 165       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 166       h->type = STT_OBJECT;
 167
 168       if (info->shared
 169           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 170         return false;
 171     }
 172
 173   s = bfd_make_section (abfd,
 174                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
 175   if (s == NULL
 176       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 177       || ! bfd_set_section_alignment (abfd, s, ptralign))
 178     return false;
 179
 180   if (! _bfd_elf_create_got_section (abfd, info))
 181     return false;
 182
 183   if (bed->want_dynbss)
 184     {
 185       /* The .dynbss section is a place to put symbols which are defined
 186          by dynamic objects, are referenced by regular objects, and are
 187          not functions.  We must allocate space for them in the process
 188          image and use a R_*_COPY reloc to tell the dynamic linker to
 189          initialize them at run time.  The linker script puts the .dynbss
 190          section into the .bss section of the final image.  */
 191       s = bfd_make_section (abfd, ".dynbss");
 192       if (s == NULL
 193           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
 194         return false;
 195
 196       /* The .rel[a].bss section holds copy relocs.  This section is not
 197      normally needed.  We need to create it here, though, so that the
 198      linker will map it to an output section.  We can't just create it
 199      only if we need it, because we will not know whether we need it
 200      until we have seen all the input files, and the first time the
 201      main linker code calls BFD after examining all the input files
 202      (size_dynamic_sections) the input sections have already been
 203      mapped to the output sections.  If the section turns out not to
 204      be needed, we can discard it later.  We will never need this
 205      section when generating a shared object, since they do not use
 206      copy relocs.  */
 207       if (! info->shared)
 208         {
 209           s = bfd_make_section (abfd,
 210                                 (bed->default_use_rela_p
 211                                  ? ".rela.bss" : ".rel.bss"));
 212           if (s == NULL
 213               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 214               || ! bfd_set_section_alignment (abfd, s, ptralign))
 215             return false;
 216         }
 217     }
 218
 219   return true;
 220 }
 221 \f
 222 /* Record a new dynamic symbol.  We record the dynamic symbols as we
 223    read the input files, since we need to have a list of all of them
 224    before we can determine the final sizes of the output sections.
 225    Note that we may actually call this function even though we are not
 226    going to output any dynamic symbols; in some cases we know that a
 227    symbol should be in the dynamic symbol table, but only if there is
 228    one.  */
 229
 230 boolean
 231 _bfd_elf_link_record_dynamic_symbol (info, h)
 232      struct bfd_link_info *info;
 233      struct elf_link_hash_entry *h;
 234 {
 235   if (h->dynindx == -1)
 236     {
 237       struct elf_strtab_hash *dynstr;
 238       char *p, *alc;
 239       const char *name;
 240       boolean copy;
 241       bfd_size_type indx;
 242
 243       /* XXX: The ABI draft says the linker must turn hidden and
 244          internal symbols into STB_LOCAL symbols when producing the
 245          DSO. However, if ld.so honors st_other in the dynamic table,
 246          this would not be necessary.  */
 247       switch (ELF_ST_VISIBILITY (h->other))
 248         {
 249         case STV_INTERNAL:
 250         case STV_HIDDEN:
 251           if (h->root.type != bfd_link_hash_undefined
 252               && h->root.type != bfd_link_hash_undefweak)
 253             {
 254               h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
 255               return true;
 256             }
 257
 258         default:
 259           break;
 260         }
 261
 262       h->dynindx = elf_hash_table (info)->dynsymcount;
 263       ++elf_hash_table (info)->dynsymcount;
 264
 265       dynstr = elf_hash_table (info)->dynstr;
 266       if (dynstr == NULL)
 267         {
 268           /* Create a strtab to hold the dynamic symbol names.  */
 269           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
 270           if (dynstr == NULL)
 271             return false;
 272         }
 273
 274       /* We don't put any version information in the dynamic string
 275          table.  */
 276       name = h->root.root.string;
 277       p = strchr (name, ELF_VER_CHR);
 278       if (p == NULL)
 279         {
 280           alc = NULL;
 281           copy = false;
 282         }
 283       else
 284         {
 285           size_t len = p - name + 1;
 286
 287           alc = bfd_malloc ((bfd_size_type) len);
 288           if (alc == NULL)
 289             return false;
 290           memcpy (alc, name, len - 1);
 291           alc[len - 1] = '\0';
 292           name = alc;
 293           copy = true;
 294         }
 295
 296       indx = _bfd_elf_strtab_add (dynstr, name, copy);
 297
 298       if (alc != NULL)
 299         free (alc);
 300
 301       if (indx == (bfd_size_type) -1)
 302         return false;
 303       h->dynstr_index = indx;
 304     }
 305
 306   return true;
 307 }
 308
 309 /* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
 310    success, and 2 on a failure caused by attempting to record a symbol
 311    in a discarded section, eg. a discarded link-once section symbol.  */
 312
 313 int
 314 elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
 315      struct bfd_link_info *info;
 316      bfd *input_bfd;
 317      long input_indx;
 318 {
 319   bfd_size_type amt;
 320   struct elf_link_local_dynamic_entry *entry;
 321   struct elf_link_hash_table *eht;
 322   struct elf_strtab_hash *dynstr;
 323   unsigned long dynstr_index;
 324   char *name;
 325   Elf_External_Sym_Shndx eshndx;
 326   char esym[sizeof (Elf64_External_Sym)];
 327
 328   if (! is_elf_hash_table (info))
 329     return 0;
 330
 331   /* See if the entry exists already.  */
 332   for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
 333     if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
 334       return 1;
 335
 336   amt = sizeof (*entry);
 337   entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
 338   if (entry == NULL)
 339     return 0;
 340
 341   /* Go find the symbol, so that we can find it's name.  */
 342   if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
 343                              (size_t) 1, (size_t) input_indx,
 344                              &entry->isym, esym, &eshndx))
 345     {
 346       bfd_release (input_bfd, entry);
 347       return 0;
 348     }
 349
 350   if (entry->isym.st_shndx != SHN_UNDEF
 351       && (entry->isym.st_shndx < SHN_LORESERVE
 352           || entry->isym.st_shndx > SHN_HIRESERVE))
 353     {
 354       asection *s;
 355
 356       s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
 357       if (s == NULL || bfd_is_abs_section (s->output_section))
 358         {
 359           /* We can still bfd_release here as nothing has done another
 360              bfd_alloc.  We can't do this later in this function.  */
 361           bfd_release (input_bfd, entry);
 362           return 2;
 363         }
 364     }
 365
 366   name = (bfd_elf_string_from_elf_section
 367           (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
 368            entry->isym.st_name));
 369
 370   dynstr = elf_hash_table (info)->dynstr;
 371   if (dynstr == NULL)
 372     {
 373       /* Create a strtab to hold the dynamic symbol names.  */
 374       elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
 375       if (dynstr == NULL)
 376         return 0;
 377     }
 378
 379   dynstr_index = _bfd_elf_strtab_add (dynstr, name, false);
 380   if (dynstr_index == (unsigned long) -1)
 381     return 0;
 382   entry->isym.st_name = dynstr_index;
 383
 384   eht = elf_hash_table (info);
 385
 386   entry->next = eht->dynlocal;
 387   eht->dynlocal = entry;
 388   entry->input_bfd = input_bfd;
 389   entry->input_indx = input_indx;
 390   eht->dynsymcount++;
 391
 392   /* Whatever binding the symbol had before, it's now local.  */
 393   entry->isym.st_info
 394     = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
 395
 396   /* The dynindx will be set at the end of size_dynamic_sections.  */
 397
 398   return 1;
 399 }
 400
 401 /* Return the dynindex of a local dynamic symbol.  */
 402
 403 long
 404 _bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
 405      struct bfd_link_info *info;
 406      bfd *input_bfd;
 407      long input_indx;
 408 {
 409   struct elf_link_local_dynamic_entry *e;
 410
 411   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
 412     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
 413       return e->dynindx;
 414   return -1;
 415 }
 416
 417 /* This function is used to renumber the dynamic symbols, if some of
 418    them are removed because they are marked as local.  This is called
 419    via elf_link_hash_traverse.  */
 420
 421 static boolean elf_link_renumber_hash_table_dynsyms
 422   PARAMS ((struct elf_link_hash_entry *, PTR));
 423
 424 static boolean
 425 elf_link_renumber_hash_table_dynsyms (h, data)
 426      struct elf_link_hash_entry *h;
 427      PTR data;
 428 {
 429   size_t *count = (size_t *) data;
 430
 431   if (h->root.type == bfd_link_hash_warning)
 432     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 433
 434   if (h->dynindx != -1)
 435     h->dynindx = ++(*count);
 436
 437   return true;
 438 }
 439
 440 /* Assign dynsym indices.  In a shared library we generate a section
 441    symbol for each output section, which come first.  Next come all of
 442    the back-end allocated local dynamic syms, followed by the rest of
 443    the global symbols.  */
 444
 445 unsigned long
 446 _bfd_elf_link_renumber_dynsyms (output_bfd, info)
 447      bfd *output_bfd;
 448      struct bfd_link_info *info;
 449 {
 450   unsigned long dynsymcount = 0;
 451
 452   if (info->shared)
 453     {
 454       asection *p;
 455       for (p = output_bfd->sections; p ; p = p->next)
 456         if ((p->flags & SEC_EXCLUDE) == 0)
 457           elf_section_data (p)->dynindx = ++dynsymcount;
 458     }
 459
 460   if (elf_hash_table (info)->dynlocal)
 461     {
 462       struct elf_link_local_dynamic_entry *p;
 463       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
 464         p->dynindx = ++dynsymcount;
 465     }
 466
 467   elf_link_hash_traverse (elf_hash_table (info),
 468                           elf_link_renumber_hash_table_dynsyms,
 469                           &dynsymcount);
 470
 471   /* There is an unused NULL entry at the head of the table which
 472      we must account for in our count.  Unless there weren't any
 473      symbols, which means we'll have no table at all.  */
 474   if (dynsymcount != 0)
 475     ++dynsymcount;
 476
 477   return elf_hash_table (info)->dynsymcount = dynsymcount;
 478 }
 479 \f
 480 /* Create a special linker section, or return a pointer to a linker
 481    section already created */
 482
 483 elf_linker_section_t *
 484 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 485      bfd *abfd;
 486      struct bfd_link_info *info;
 487      enum elf_linker_section_enum which;
 488      elf_linker_section_t *defaults;
 489 {
 490   bfd *dynobj = elf_hash_table (info)->dynobj;
 491   elf_linker_section_t *lsect;
 492
 493   /* Record the first bfd section that needs the special section */
 494   if (!dynobj)
 495     dynobj = elf_hash_table (info)->dynobj = abfd;
 496
 497   /* If this is the first time, create the section */
 498   lsect = elf_linker_section (dynobj, which);
 499   if (!lsect)
 500     {
 501       asection *s;
 502       bfd_size_type amt = sizeof (elf_linker_section_t);
 503
 504       lsect = (elf_linker_section_t *) bfd_alloc (dynobj, amt);
 505
 506       *lsect = *defaults;
 507       elf_linker_section (dynobj, which) = lsect;
 508       lsect->which = which;
 509       lsect->hole_written_p = false;
 510
 511       /* See if the sections already exist */
 512       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 513       if (!s || (s->flags & defaults->flags) != defaults->flags)
 514         {
 515           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 516
 517           if (s == NULL)
 518             return (elf_linker_section_t *)0;
 519
 520           bfd_set_section_flags (dynobj, s, defaults->flags);
 521           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 522         }
 523       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 524         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 525
 526       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 527
 528       /* Is there a hole we have to provide?  If so check whether the segment is
 529          too big already */
 530       if (lsect->hole_size)
 531         {
 532           lsect->hole_offset = s->_raw_size;
 533           s->_raw_size += lsect->hole_size;
 534           if (lsect->hole_offset > lsect->max_hole_offset)
 535             {
 536               (*_bfd_error_handler) (_("%s: Section %s is too large to add hole of %ld bytes"),
 537                                      bfd_get_filename (abfd),
 538                                      lsect->name,
 539                                      (long) lsect->hole_size);
 540
 541               bfd_set_error (bfd_error_bad_value);
 542               return (elf_linker_section_t *)0;
 543             }
 544         }
 545
 546 #ifdef DEBUG
 547       fprintf (stderr, "Creating section %s, current size = %ld\n",
 548                lsect->name, (long)s->_raw_size);
 549 #endif
 550
 551       if (lsect->sym_name)
 552         {
 553           struct elf_link_hash_entry *h;
 554           struct bfd_link_hash_entry *bh;
 555
 556 #ifdef DEBUG
 557           fprintf (stderr, "Adding %s to section %s\n",
 558                    lsect->sym_name,
 559                    lsect->name);
 560 #endif
 561           bh = bfd_link_hash_lookup (info->hash, lsect->sym_name,
 562                                      false, false, false);
 563
 564           if ((bh == NULL || bh->type == bfd_link_hash_undefined)
 565               && !(_bfd_generic_link_add_one_symbol
 566                    (info, abfd, lsect->sym_name, BSF_GLOBAL, s,
 567                     (lsect->hole_size
 568                      ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 569                      : lsect->sym_offset),
 570                     (const char *) NULL, false,
 571                     get_elf_backend_data (abfd)->collect, &bh)))
 572             return (elf_linker_section_t *) 0;
 573           h = (struct elf_link_hash_entry *) bh;
 574
 575           if ((defaults->which != LINKER_SECTION_SDATA)
 576               && (defaults->which != LINKER_SECTION_SDATA2))
 577             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 578
 579           h->type = STT_OBJECT;
 580           lsect->sym_hash = h;
 581
 582           if (info->shared
 583               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 584             return (elf_linker_section_t *) 0;
 585         }
 586     }
 587
 588 #if 0
 589   /* This does not make sense.  The sections which may exist in the
 590      object file have nothing to do with the sections we want to
 591      create.  */
 592
 593   /* Find the related sections if they have been created */
 594   if (lsect->bss_name && !lsect->bss_section)
 595     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 596
 597   if (lsect->rel_name && !lsect->rel_section)
 598     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 599 #endif
 600
 601   return lsect;
 602 }
 603 \f
 604 /* Find a linker generated pointer with a given addend and type.  */
 605
 606 elf_linker_section_pointers_t *
 607 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 608      elf_linker_section_pointers_t *linker_pointers;
 609      bfd_vma addend;
 610      elf_linker_section_enum_t which;
 611 {
 612   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 613     {
 614       if (which == linker_pointers->which && addend == linker_pointers->addend)
 615         return linker_pointers;
 616     }
 617
 618   return (elf_linker_section_pointers_t *)0;
 619 }
 620 \f
 621 /* Make the .rela section corresponding to the generated linker section.  */
 622
 623 boolean
 624 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 625      bfd *dynobj;
 626      elf_linker_section_t *lsect;
 627      int alignment;
 628 {
 629   if (lsect->rel_section)
 630     return true;
 631
 632   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 633   if (lsect->rel_section == NULL)
 634     {
 635       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 636       if (lsect->rel_section == NULL
 637           || ! bfd_set_section_flags (dynobj,
 638                                       lsect->rel_section,
 639                                       (SEC_ALLOC
 640                                        | SEC_LOAD
 641                                        | SEC_HAS_CONTENTS
 642                                        | SEC_IN_MEMORY
 643                                        | SEC_LINKER_CREATED
 644                                        | SEC_READONLY))
 645           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 646         return false;
 647     }
 648
 649   return true;
 650 }