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         if ((p->flags & SEC_EXCLUDE) == 0)
 361           elf_section_data (p)->dynindx = ++dynsymcount;
 362     }
 363
 364   if (elf_hash_table (info)->dynlocal)
 365     {
 366       struct elf_link_local_dynamic_entry *p;
 367       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
 368         p->dynindx = ++dynsymcount;
 369     }
 370
 371   elf_link_hash_traverse (elf_hash_table (info),
 372                           elf_link_renumber_hash_table_dynsyms,
 373                           &dynsymcount);
 374
 375   /* There is an unused NULL entry at the head of the table which
 376      we must account for in our count.  Unless there weren't any
 377      symbols, which means we'll have no table at all.  */
 378   if (dynsymcount != 0)
 379     ++dynsymcount;
 380
 381   return elf_hash_table (info)->dynsymcount = dynsymcount;
 382 }
 383 \f
 384 /* Create a special linker section, or return a pointer to a linker
 385    section already created */
 386
 387 elf_linker_section_t *
 388 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 389      bfd *abfd;
 390      struct bfd_link_info *info;
 391      enum elf_linker_section_enum which;
 392      elf_linker_section_t *defaults;
 393 {
 394   bfd *dynobj = elf_hash_table (info)->dynobj;
 395   elf_linker_section_t *lsect;
 396
 397   /* Record the first bfd section that needs the special section */
 398   if (!dynobj)
 399     dynobj = elf_hash_table (info)->dynobj = abfd;
 400
 401   /* If this is the first time, create the section */
 402   lsect = elf_linker_section (dynobj, which);
 403   if (!lsect)
 404     {
 405       asection *s;
 406       bfd_size_type amt = sizeof (elf_linker_section_t);
 407
 408       lsect = (elf_linker_section_t *) bfd_alloc (dynobj, amt);
 409
 410       *lsect = *defaults;
 411       elf_linker_section (dynobj, which) = lsect;
 412       lsect->which = which;
 413       lsect->hole_written_p = false;
 414
 415       /* See if the sections already exist */
 416       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 417       if (!s || (s->flags & defaults->flags) != defaults->flags)
 418         {
 419           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 420
 421           if (s == NULL)
 422             return (elf_linker_section_t *)0;
 423
 424           bfd_set_section_flags (dynobj, s, defaults->flags);
 425           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 426         }
 427       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 428         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 429
 430       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 431
 432       /* Is there a hole we have to provide?  If so check whether the segment is
 433          too big already */
 434       if (lsect->hole_size)
 435         {
 436           lsect->hole_offset = s->_raw_size;
 437           s->_raw_size += lsect->hole_size;
 438           if (lsect->hole_offset > lsect->max_hole_offset)
 439             {
 440               (*_bfd_error_handler) (_("%s: Section %s is too large to add hole of %ld bytes"),
 441                                      bfd_get_filename (abfd),
 442                                      lsect->name,
 443                                      (long) lsect->hole_size);
 444
 445               bfd_set_error (bfd_error_bad_value);
 446               return (elf_linker_section_t *)0;
 447             }
 448         }
 449
 450 #ifdef DEBUG
 451       fprintf (stderr, "Creating section %s, current size = %ld\n",
 452                lsect->name, (long)s->_raw_size);
 453 #endif
 454
 455       if (lsect->sym_name)
 456         {
 457           struct elf_link_hash_entry *h = NULL;
 458 #ifdef DEBUG
 459           fprintf (stderr, "Adding %s to section %s\n",
 460                    lsect->sym_name,
 461                    lsect->name);
 462 #endif
 463           h = (struct elf_link_hash_entry *)
 464             bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
 465
 466           if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 467               && !(_bfd_generic_link_add_one_symbol (info,
 468                                                      abfd,
 469                                                      lsect->sym_name,
 470                                                      BSF_GLOBAL,
 471                                                      s,
 472                                                      ((lsect->hole_size)
 473                                                       ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 474                                                       : lsect->sym_offset),
 475                                                      (const char *) NULL,
 476                                                      false,
 477                                                      get_elf_backend_data (abfd)->collect,
 478                                                      (struct bfd_link_hash_entry **) &h)))
 479             return (elf_linker_section_t *)0;
 480
 481           if ((defaults->which != LINKER_SECTION_SDATA)
 482               && (defaults->which != LINKER_SECTION_SDATA2))
 483             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 484
 485           h->type = STT_OBJECT;
 486           lsect->sym_hash = h;
 487
 488           if (info->shared
 489               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 490             return (elf_linker_section_t *)0;
 491         }
 492     }
 493
 494 #if 0
 495   /* This does not make sense.  The sections which may exist in the
 496      object file have nothing to do with the sections we want to
 497      create.  */
 498
 499   /* Find the related sections if they have been created */
 500   if (lsect->bss_name && !lsect->bss_section)
 501     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 502
 503   if (lsect->rel_name && !lsect->rel_section)
 504     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 505 #endif
 506
 507   return lsect;
 508 }
 509 \f
 510 /* Find a linker generated pointer with a given addend and type.  */
 511
 512 elf_linker_section_pointers_t *
 513 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 514      elf_linker_section_pointers_t *linker_pointers;
 515      bfd_vma addend;
 516      elf_linker_section_enum_t which;
 517 {
 518   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 519     {
 520       if (which == linker_pointers->which && addend == linker_pointers->addend)
 521         return linker_pointers;
 522     }
 523
 524   return (elf_linker_section_pointers_t *)0;
 525 }
 526 \f
 527 /* Make the .rela section corresponding to the generated linker section.  */
 528
 529 boolean
 530 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 531      bfd *dynobj;
 532      elf_linker_section_t *lsect;
 533      int alignment;
 534 {
 535   if (lsect->rel_section)
 536     return true;
 537
 538   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 539   if (lsect->rel_section == NULL)
 540     {
 541       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 542       if (lsect->rel_section == NULL
 543           || ! bfd_set_section_flags (dynobj,
 544                                       lsect->rel_section,
 545                                       (SEC_ALLOC
 546                                        | SEC_LOAD
 547                                        | SEC_HAS_CONTENTS
 548                                        | SEC_IN_MEMORY
 549                                        | SEC_LINKER_CREATED
 550                                        | SEC_READONLY))
 551           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 552         return false;
 553     }
 554
 555   return true;
 556 }