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           /* This symbol must be defined in the shared object or
 230              executable.  */
 231           if (h->root.type == bfd_link_hash_undefined)
 232             {
 233               bfd * abfd = h->root.u.undef.abfd;
 234               const char * name = h->root.root.string;
 235
 236               (*info->callbacks->undefined_symbol)
 237                 (info, name, abfd, bfd_und_section_ptr, 0, true);
 238
 239               /* We have flaged a fatal error. We now treat this as
 240                  a normal symbol to avoid further error messages. */
 241               h->other ^= ELF_ST_VISIBILITY (h->other);
 242             }
 243           else if (h->root.type != bfd_link_hash_undefweak)
 244             {
 245               h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
 246               return true;
 247             }
 248
 249         default:
 250           break;
 251         }
 252
 253       h->dynindx = elf_hash_table (info)->dynsymcount;
 254       ++elf_hash_table (info)->dynsymcount;
 255
 256       dynstr = elf_hash_table (info)->dynstr;
 257       if (dynstr == NULL)
 258         {
 259           /* Create a strtab to hold the dynamic symbol names.  */
 260           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_stringtab_init ();
 261           if (dynstr == NULL)
 262             return false;
 263         }
 264
 265       /* We don't put any version information in the dynamic string
 266          table.  */
 267       name = h->root.root.string;
 268       p = strchr (name, ELF_VER_CHR);
 269       if (p == NULL)
 270         {
 271           alc = NULL;
 272           copy = false;
 273         }
 274       else
 275         {
 276           alc = bfd_malloc (p - name + 1);
 277           if (alc == NULL)
 278             return false;
 279           strncpy (alc, name, p - name);
 280           alc[p - name] = '\0';
 281           name = alc;
 282           copy = true;
 283         }
 284
 285       indx = _bfd_stringtab_add (dynstr, name, true, copy);
 286
 287       if (alc != NULL)
 288         free (alc);
 289
 290       if (indx == (bfd_size_type) -1)
 291         return false;
 292       h->dynstr_index = indx;
 293     }
 294
 295   return true;
 296 }
 297
 298 /* Return the dynindex of a local dynamic symbol.  */
 299
 300 long
 301 _bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
 302      struct bfd_link_info *info;
 303      bfd *input_bfd;
 304      long input_indx;
 305 {
 306   struct elf_link_local_dynamic_entry *e;
 307
 308   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
 309     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
 310       return e->dynindx;
 311   return -1;
 312 }
 313
 314 /* This function is used to renumber the dynamic symbols, if some of
 315    them are removed because they are marked as local.  This is called
 316    via elf_link_hash_traverse.  */
 317
 318 static boolean elf_link_renumber_hash_table_dynsyms
 319   PARAMS ((struct elf_link_hash_entry *, PTR));
 320
 321 static boolean
 322 elf_link_renumber_hash_table_dynsyms (h, data)
 323      struct elf_link_hash_entry *h;
 324      PTR data;
 325 {
 326   size_t *count = (size_t *) data;
 327
 328   if (h->dynindx != -1)
 329     h->dynindx = ++(*count);
 330
 331   return true;
 332 }
 333
 334 /* Assign dynsym indicies.  In a shared library we generate a section
 335    symbol for each output section, which come first.  Next come all of
 336    the back-end allocated local dynamic syms, followed by the rest of
 337    the global symbols.  */
 338
 339 unsigned long
 340 _bfd_elf_link_renumber_dynsyms (output_bfd, info)
 341      bfd *output_bfd;
 342      struct bfd_link_info *info;
 343 {
 344   unsigned long dynsymcount = 0;
 345
 346   if (info->shared)
 347     {
 348       asection *p;
 349       for (p = output_bfd->sections; p ; p = p->next)
 350         elf_section_data (p)->dynindx = ++dynsymcount;
 351     }
 352
 353   if (elf_hash_table (info)->dynlocal)
 354     {
 355       struct elf_link_local_dynamic_entry *p;
 356       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
 357         p->dynindx = ++dynsymcount;
 358     }
 359
 360   elf_link_hash_traverse (elf_hash_table (info),
 361                           elf_link_renumber_hash_table_dynsyms,
 362                           &dynsymcount);
 363
 364   /* There is an unused NULL entry at the head of the table which
 365      we must account for in our count.  Unless there weren't any
 366      symbols, which means we'll have no table at all.  */
 367   if (dynsymcount != 0)
 368     ++dynsymcount;
 369
 370   return elf_hash_table (info)->dynsymcount = dynsymcount;
 371 }
 372 \f
 373 /* Create a special linker section, or return a pointer to a linker
 374    section already created */
 375
 376 elf_linker_section_t *
 377 _bfd_elf_create_linker_section (abfd, info, which, defaults)
 378      bfd *abfd;
 379      struct bfd_link_info *info;
 380      enum elf_linker_section_enum which;
 381      elf_linker_section_t *defaults;
 382 {
 383   bfd *dynobj = elf_hash_table (info)->dynobj;
 384   elf_linker_section_t *lsect;
 385
 386   /* Record the first bfd section that needs the special section */
 387   if (!dynobj)
 388     dynobj = elf_hash_table (info)->dynobj = abfd;
 389
 390   /* If this is the first time, create the section */
 391   lsect = elf_linker_section (dynobj, which);
 392   if (!lsect)
 393     {
 394       asection *s;
 395
 396       lsect = (elf_linker_section_t *)
 397         bfd_alloc (dynobj, sizeof (elf_linker_section_t));
 398
 399       *lsect = *defaults;
 400       elf_linker_section (dynobj, which) = lsect;
 401       lsect->which = which;
 402       lsect->hole_written_p = false;
 403
 404       /* See if the sections already exist */
 405       lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
 406       if (!s || (s->flags & defaults->flags) != defaults->flags)
 407         {
 408           lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
 409
 410           if (s == NULL)
 411             return (elf_linker_section_t *)0;
 412
 413           bfd_set_section_flags (dynobj, s, defaults->flags);
 414           bfd_set_section_alignment (dynobj, s, lsect->alignment);
 415         }
 416       else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
 417         bfd_set_section_alignment (dynobj, s, lsect->alignment);
 418
 419       s->_raw_size = align_power (s->_raw_size, lsect->alignment);
 420
 421       /* Is there a hole we have to provide?  If so check whether the segment is
 422          too big already */
 423       if (lsect->hole_size)
 424         {
 425           lsect->hole_offset = s->_raw_size;
 426           s->_raw_size += lsect->hole_size;
 427           if (lsect->hole_offset > lsect->max_hole_offset)
 428             {
 429               (*_bfd_error_handler) (_("%s: Section %s is already to large to put hole of %ld bytes in"),
 430                                      bfd_get_filename (abfd),
 431                                      lsect->name,
 432                                      (long)lsect->hole_size);
 433
 434               bfd_set_error (bfd_error_bad_value);
 435               return (elf_linker_section_t *)0;
 436             }
 437         }
 438
 439 #ifdef DEBUG
 440       fprintf (stderr, "Creating section %s, current size = %ld\n",
 441                lsect->name, (long)s->_raw_size);
 442 #endif
 443
 444       if (lsect->sym_name)
 445         {
 446           struct elf_link_hash_entry *h = NULL;
 447 #ifdef DEBUG
 448           fprintf (stderr, "Adding %s to section %s\n",
 449                    lsect->sym_name,
 450                    lsect->name);
 451 #endif
 452           h = (struct elf_link_hash_entry *)
 453             bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
 454
 455           if ((h == NULL || h->root.type == bfd_link_hash_undefined)
 456               && !(_bfd_generic_link_add_one_symbol (info,
 457                                                      abfd,
 458                                                      lsect->sym_name,
 459                                                      BSF_GLOBAL,
 460                                                      s,
 461                                                      ((lsect->hole_size)
 462                                                       ? s->_raw_size - lsect->hole_size + lsect->sym_offset
 463                                                       : lsect->sym_offset),
 464                                                      (const char *) NULL,
 465                                                      false,
 466                                                      get_elf_backend_data (abfd)->collect,
 467                                                      (struct bfd_link_hash_entry **) &h)))
 468             return (elf_linker_section_t *)0;
 469
 470           if ((defaults->which != LINKER_SECTION_SDATA)
 471               && (defaults->which != LINKER_SECTION_SDATA2))
 472             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
 473
 474           h->type = STT_OBJECT;
 475           lsect->sym_hash = h;
 476
 477           if (info->shared
 478               && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 479             return (elf_linker_section_t *)0;
 480         }
 481     }
 482
 483 #if 0
 484   /* This does not make sense.  The sections which may exist in the
 485      object file have nothing to do with the sections we want to
 486      create.  */
 487
 488   /* Find the related sections if they have been created */
 489   if (lsect->bss_name && !lsect->bss_section)
 490     lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
 491
 492   if (lsect->rel_name && !lsect->rel_section)
 493     lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 494 #endif
 495
 496   return lsect;
 497 }
 498
 499 \f
 500 /* Find a linker generated pointer with a given addend and type.  */
 501
 502 elf_linker_section_pointers_t *
 503 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
 504      elf_linker_section_pointers_t *linker_pointers;
 505      bfd_signed_vma addend;
 506      elf_linker_section_enum_t which;
 507 {
 508   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
 509     {
 510       if (which == linker_pointers->which && addend == linker_pointers->addend)
 511         return linker_pointers;
 512     }
 513
 514   return (elf_linker_section_pointers_t *)0;
 515 }
 516
 517 \f
 518 /* Make the .rela section corresponding to the generated linker section.  */
 519
 520 boolean
 521 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
 522      bfd *dynobj;
 523      elf_linker_section_t *lsect;
 524      int alignment;
 525 {
 526   if (lsect->rel_section)
 527     return true;
 528
 529   lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
 530   if (lsect->rel_section == NULL)
 531     {
 532       lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
 533       if (lsect->rel_section == NULL
 534           || ! bfd_set_section_flags (dynobj,
 535                                       lsect->rel_section,
 536                                       (SEC_ALLOC
 537                                        | SEC_LOAD
 538                                        | SEC_HAS_CONTENTS
 539                                        | SEC_IN_MEMORY
 540                                        | SEC_LINKER_CREATED
 541                                        | SEC_READONLY))
 542           || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
 543         return false;
 544     }
 545
 546   return true;
 547 }