bfd/elflink.c

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