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