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 /* Return the dynindex of a local dynamic symbol.  */
 306
 307 long
 308 _bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
 309      struct bfd_link_info *info;
 310      bfd *input_bfd;
 311      long input_indx;
 312 {
 313   struct elf_link_local_dynamic_entry *e;
 314
 315   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
 316     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
 317       return e->dynindx;
 318   return -1;
 319 }
 320
 321 /* This function is used to renumber the dynamic symbols, if some of
 322    them are removed because they are marked as local.  This is called
 323    via elf_link_hash_traverse.  */
 324
 325 static boolean elf_link_renumber_hash_table_dynsyms
 326   PARAMS ((struct elf_link_hash_entry *, PTR));
 327
 328 static boolean
 329 elf_link_renumber_hash_table_dynsyms (h, data)
 330      struct elf_link_hash_entry *h;
 331      PTR data;
 332 {
 333   size_t *count = (size_t *) data;
 334
 335   if (h->root.type == bfd_link_hash_warning)
 336     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 337
 338   if (h->dynindx != -1)
 339     h->dynindx = ++(*count);
 340
 341   return true;
 342 }
 343
 344 /* Assign dynsym indices.  In a shared library we generate a section
 345    symbol for each output section, which come first.  Next come all of
 346    the back-end allocated local dynamic syms, followed by the rest of
 347    the global symbols.  */
 348
 349 unsigned long
 350 _bfd_elf_link_renumber_dynsyms (output_bfd, info)
 351      bfd *output_bfd;
 352      struct bfd_link_info *info;
 353 {
 354   unsigned long dynsymcount = 0;
 355
 356   if (info->shared)
 357     {
 358       asection *p;
 359       for (p = output_bfd->sections; p ; p = p->next)
 360         elf_section_data (p)->dynindx = ++dynsymcount;
 361     }
 362
 363   if (elf_hash_table (info)->dynlocal)
 364     {
 365       struct elf_link_local_dynamic_entry *p;
 366       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
 367         p->dynindx = ++dynsymcount;
 368     }
 369
 370   elf_link_hash_traverse (elf_hash_table (info),
 371                           elf_link_renumber_hash_table_dynsyms,
 372                           &dynsymcount);
 373
 374   /* There is an unused NULL entry at the head of the table which
 375      we must account for in our count.  Unless there weren't any
 376      symbols, which means we'll have no table at all.  */
 377   if (dynsymcount != 0)
 378     ++dynsymcount;
 379
 380   return elf_hash_table (info)->dynsymcount = dynsymcount;
 381 }
 382 \f
 383 /* Create a special linker section, or return a pointer to a linker
 384    section already created */
 385
 386 elf_linker_section_t *
 387 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 388      bfd *abfd;
 389      struct bfd_link_info *info;
 390      enum elf_linker_section_enum which;
 391      elf_linker_section_t *defaults;
 392 {
 393   bfd *dynobj = elf_hash_table (info)->dynobj;
 394   elf_linker_section_t *lsect;
 395
 396   /* Record the first bfd section that needs the special section */
 397   if (!dynobj)
 398     dynobj = elf_hash_table (info)->dynobj = abfd;
 399
 400   /* If this is the first time, create the section */
 401   lsect = elf_linker_section (dynobj, which);
 402   if (!lsect)
 403     {
 404       asection *s;
 405       bfd_size_type amt = sizeof (elf_linker_section_t);
 406
 407       lsect = (elf_linker_section_t *) bfd_alloc (dynobj, amt);
 408
 409       *lsect = *defaults;
 410       elf_linker_section (dynobj, which) = lsect;
 411       lsect->which = which;
 412       lsect->hole_written_p = false;
 413
 414       /* See if the sections already exist */
 415       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 416       if (!s || (s->flags & defaults->flags) != defaults->flags)
 417         {
 418           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 419
 420           if (s == NULL)
 421             return (elf_linker_section_t *)0;
 422
 423           bfd_set_section_flags (dynobj, s, defaults->flags);
 424           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 425         }
 426       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 427         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 428
 429       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 430
 431       /* Is there a hole we have to provide?  If so check whether the segment is
 432          too big already */
 433       if (lsect->hole_size)
 434         {
 435           lsect->hole_offset = s->_raw_size;
 436           s->_raw_size += lsect->hole_size;
 437           if (lsect->hole_offset > lsect->max_hole_offset)
 438             {
 439               (*_bfd_error_handler) (_("%s: Section %s is too large to add hole of %ld bytes"),
 440                                      bfd_get_filename (abfd),
 441                                      lsect->name,
 442                                      (long) lsect->hole_size);
 443
 444               bfd_set_error (bfd_error_bad_value);
 445               return (elf_linker_section_t *)0;
 446             }
 447         }
 448
 449 #ifdef DEBUG
 450       fprintf (stderr, "Creating section %s, current size = %ld\n",
 451                lsect->name, (long)s->_raw_size);
 452 #endif
 453
 454       if (lsect->sym_name)
 455         {
 456           struct elf_link_hash_entry *h = NULL;
 457 #ifdef DEBUG
 458           fprintf (stderr, "Adding %s to section %s\n",
 459                    lsect->sym_name,
 460                    lsect->name);
 461 #endif
 462           h = (struct elf_link_hash_entry *)
 463             bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
 464
 465           if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 466               && !(_bfd_generic_link_add_one_symbol (info,
 467                                                      abfd,
 468                                                      lsect->sym_name,
 469                                                      BSF_GLOBAL,
 470                                                      s,
 471                                                      ((lsect->hole_size)
 472                                                       ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 473                                                       : lsect->sym_offset),
 474                                                      (const char *) NULL,
 475                                                      false,
 476                                                      get_elf_backend_data (abfd)->collect,
 477                                                      (struct bfd_link_hash_entry **) &h)))
 478             return (elf_linker_section_t *)0;
 479
 480           if ((defaults->which != LINKER_SECTION_SDATA)
 481               && (defaults->which != LINKER_SECTION_SDATA2))
 482             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 483
 484           h->type = STT_OBJECT;
 485           lsect->sym_hash = h;
 486
 487           if (info->shared
 488               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 489             return (elf_linker_section_t *)0;
 490         }
 491     }
 492
 493 #if 0
 494   /* This does not make sense.  The sections which may exist in the
 495      object file have nothing to do with the sections we want to
 496      create.  */
 497
 498   /* Find the related sections if they have been created */
 499   if (lsect->bss_name && !lsect->bss_section)
 500     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 501
 502   if (lsect->rel_name && !lsect->rel_section)
 503     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 504 #endif
 505
 506   return lsect;
 507 }
 508 \f
 509 /* Find a linker generated pointer with a given addend and type.  */
 510
 511 elf_linker_section_pointers_t *
 512 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 513      elf_linker_section_pointers_t *linker_pointers;
 514      bfd_vma addend;
 515      elf_linker_section_enum_t which;
 516 {
 517   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 518     {
 519       if (which == linker_pointers->which && addend == linker_pointers->addend)
 520         return linker_pointers;
 521     }
 522
 523   return (elf_linker_section_pointers_t *)0;
 524 }
 525 \f
 526 /* Make the .rela section corresponding to the generated linker section.  */
 527
 528 boolean
 529 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 530      bfd *dynobj;
 531      elf_linker_section_t *lsect;
 532      int alignment;
 533 {
 534   if (lsect->rel_section)
 535     return true;
 536
 537   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 538   if (lsect->rel_section == NULL)
 539     {
 540       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 541       if (lsect->rel_section == NULL
 542           || ! bfd_set_section_flags (dynobj,
 543                                       lsect->rel_section,
 544                                       (SEC_ALLOC
 545                                        | SEC_LOAD
 546                                        | SEC_HAS_CONTENTS
 547                                        | SEC_IN_MEMORY
 548                                        | SEC_LINKER_CREATED
 549                                        | SEC_READONLY))
 550           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 551         return false;
 552     }
 553
 554   return true;
 555 }