bfd/linker.c

   1 /* linker.c -- BFD linker routines
   2    Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support
   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 "libbfd.h"
  24 #include "bfdlink.h"
  25 #include "genlink.h"
  26
  27 /*
  28 SECTION
  29         Linker Functions
  30
  31 @cindex Linker
  32         The linker uses three special entry points in the BFD target
  33         vector.  It is not necessary to write special routines for
  34         these entry points when creating a new BFD back end, since
  35         generic versions are provided.  However, writing them can
  36         speed up linking and make it use significantly less runtime
  37         memory.
  38
  39         The first routine creates a hash table used by the other
  40         routines.  The second routine adds the symbols from an object
  41         file to the hash table.  The third routine takes all the
  42         object files and links them together to create the output
  43         file.  These routines are designed so that the linker proper
  44         does not need to know anything about the symbols in the object
  45         files that it is linking.  The linker merely arranges the
  46         sections as directed by the linker script and lets BFD handle
  47         the details of symbols and relocs.
  48
  49         The second routine and third routines are passed a pointer to
  50         a <<struct bfd_link_info>> structure (defined in
  51         <<bfdlink.h>>) which holds information relevant to the link,
  52         including the linker hash table (which was created by the
  53         first routine) and a set of callback functions to the linker
  54         proper.
  55
  56         The generic linker routines are in <<linker.c>>, and use the
  57         header file <<genlink.h>>.  As of this writing, the only back
  58         ends which have implemented versions of these routines are
  59         a.out (in <<aoutx.h>>) and ECOFF (in <<ecoff.c>>).  The a.out
  60         routines are used as examples throughout this section.
  61
  62 @menu
  63 @* Creating a Linker Hash Table::
  64 @* Adding Symbols to the Hash Table::
  65 @* Performing the Final Link::
  66 @end menu
  67
  68 INODE
  69 Creating a Linker Hash Table, Adding Symbols to the Hash Table, Linker Functions, Linker Functions
  70 SUBSECTION
  71         Creating a linker hash table
  72
  73 @cindex _bfd_link_hash_table_create in target vector
  74 @cindex target vector (_bfd_link_hash_table_create)
  75         The linker routines must create a hash table, which must be
  76         derived from <<struct bfd_link_hash_table>> described in
  77         <<bfdlink.c>>.  @xref{Hash Tables} for information on how to
  78         create a derived hash table.  This entry point is called using
  79         the target vector of the linker output file.
  80
  81         The <<_bfd_link_hash_table_create>> entry point must allocate
  82         and initialize an instance of the desired hash table.  If the
  83         back end does not require any additional information to be
  84         stored with the entries in the hash table, the entry point may
  85         simply create a <<struct bfd_link_hash_table>>.  Most likely,
  86         however, some additional information will be needed.
  87
  88         For example, with each entry in the hash table the a.out
  89         linker keeps the index the symbol has in the final output file
  90         (this index number is used so that when doing a relocateable
  91         link the symbol index used in the output file can be quickly
  92         filled in when copying over a reloc).  The a.out linker code
  93         defines the required structures and functions for a hash table
  94         derived from <<struct bfd_link_hash_table>>.  The a.out linker
  95         hash table is created by the function
  96         <<NAME(aout,link_hash_table_create)>>; it simply allocates
  97         space for the hash table, initializes it, and returns a
  98         pointer to it.
  99
 100         When writing the linker routines for a new back end, you will
 101         generally not know exactly which fields will be required until
 102         you have finished.  You should simply create a new hash table
 103         which defines no additional fields, and then simply add fields
 104         as they become necessary.
 105
 106 INODE
 107 Adding Symbols to the Hash Table, Performing the Final Link, Creating a Linker Hash Table, Linker Functions
 108 SUBSECTION
 109         Adding symbols to the hash table
 110
 111 @cindex _bfd_link_add_symbols in target vector
 112 @cindex target vector (_bfd_link_add_symbols)
 113         The linker proper will call the <<_bfd_link_add_symbols>>
 114         entry point for each object file or archive which is to be
 115         linked (typically these are the files named on the command
 116         line, but some may also come from the linker script).  The
 117         entry point is responsible for examining the file.  For an
 118         object file, BFD must add any relevant symbol information to
 119         the hash table.  For an archive, BFD must determine which
 120         elements of the archive should be used and adding them to the
 121         link.
 122
 123         The a.out version of this entry point is
 124         <<NAME(aout,link_add_symbols)>>.
 125
 126 @menu
 127 @* Differing file formats::
 128 @* Adding symbols from an object file::
 129 @* Adding symbols from an archive::
 130 @end menu
 131
 132 INODE
 133 Differing file formats, Adding symbols from an object file, Adding Symbols to the Hash Table, Adding Symbols to the Hash Table
 134 SUBSUBSECTION
 135         Differing file formats
 136
 137         Normally all the files involved in a link will be of the same
 138         format, but it is also possible to link together different
 139         format object files, and the back end must support that.  The
 140         <<_bfd_link_add_symbols>> entry point is called via the target
 141         vector of the file to be added.  This has an important
 142         consequence: the function may not assume that the hash table
 143         is the type created by the corresponding
 144         <<_bfd_link_hash_table_create>> vector.  All the
 145         <<_bfd_link_add_symbols>> function can assume about the hash
 146         table is that it is derived from <<struct
 147         bfd_link_hash_table>>.
 148
 149         Sometimes the <<_bfd_link_add_symbols>> function must store
 150         some information in the hash table entry to be used by the
 151         <<_bfd_final_link>> function.  In such a case the <<creator>>
 152         field of the hash table must be checked to make sure that the
 153         hash table was created by an object file of the same format.
 154
 155         The <<_bfd_final_link>> routine must be prepared to handle a
 156         hash entry without any extra information added by the
 157         <<_bfd_link_add_symbols>> function.  A hash entry without
 158         extra information will also occur when the linker script
 159         directs the linker to create a symbol.  Note that, regardless
 160         of how a hash table entry is added, all the fields will be
 161         initialized to some sort of null value by the hash table entry
 162         initialization function.
 163
 164         See <<ecoff_link_add_externals>> for an example of how to
 165         check the <<creator>> field before saving information (in this
 166         case, the ECOFF external symbol debugging information) in a
 167         hash table entry.
 168
 169 INODE
 170 Adding symbols from an object file, Adding symbols from an archive, Differing file formats, Adding Symbols to the Hash Table
 171 SUBSUBSECTION
 172         Adding symbols from an object file
 173
 174         When the <<_bfd_link_add_symbols>> routine is passed an object
 175         file, it must add all externally visible symbols in that
 176         object file to the hash table.  The actual work of adding the
 177         symbol to the hash table is normally handled by the function
 178         <<_bfd_generic_link_add_one_symbol>>.  The
 179         <<_bfd_link_add_symbols>> routine is responsible for reading
 180         all the symbols from the object file and passing the correct
 181         information to <<_bfd_generic_link_add_one_symbol>>.
 182
 183         The <<_bfd_link_add_symbols>> routine should not use
 184         <<bfd_canonicalize_symtab>> to read the symbols.  The point of
 185         providing this routine is to avoid the overhead of converting
 186         the symbols into generic <<asymbol>> structures.
 187
 188 @findex _bfd_generic_link_add_one_symbol
 189         <<_bfd_generic_link_add_one_symbol>> handles the details of
 190         combining common symbols, warning about multiple definitions,
 191         and so forth.  It takes arguments which describe the symbol to
 192         add, notably symbol flags, a section, and an offset.  The
 193         symbol flags include such things as <<BSF_WEAK>> or
 194         <<BSF_INDIRECT>>.  The section is a section in the object
 195         file, or something like <<bfd_und_section_ptr>> for an undefined
 196         symbol or <<bfd_com_section_ptr>> for a common symbol.
 197
 198         If the <<_bfd_final_link>> routine is also going to need to
 199         read the symbol information, the <<_bfd_link_add_symbols>>
 200         routine should save it somewhere attached to the object file
 201         BFD.  However, the information should only be saved if the
 202         <<keep_memory>> field of the <<info>> argument is true, so
 203         that the <<-no-keep-memory>> linker switch is effective.
 204
 205         The a.out function which adds symbols from an object file is
 206         <<aout_link_add_object_symbols>>, and most of the interesting
 207         work is in <<aout_link_add_symbols>>.  The latter saves
 208         pointers to the hash tables entries created by
 209         <<_bfd_generic_link_add_one_symbol>> indexed by symbol number,
 210         so that the <<_bfd_final_link>> routine does not have to call
 211         the hash table lookup routine to locate the entry.
 212
 213 INODE
 214 Adding symbols from an archive, , Adding symbols from an object file, Adding Symbols to the Hash Table
 215 SUBSUBSECTION
 216         Adding symbols from an archive
 217
 218         When the <<_bfd_link_add_symbols>> routine is passed an
 219         archive, it must look through the symbols defined by the
 220         archive and decide which elements of the archive should be
 221         included in the link.  For each such element it must call the
 222         <<add_archive_element>> linker callback, and it must add the
 223         symbols from the object file to the linker hash table.
 224
 225 @findex _bfd_generic_link_add_archive_symbols
 226         In most cases the work of looking through the symbols in the
 227         archive should be done by the
 228         <<_bfd_generic_link_add_archive_symbols>> function.  This
 229         function builds a hash table from the archive symbol table and
 230         looks through the list of undefined symbols to see which
 231         elements should be included.
 232         <<_bfd_generic_link_add_archive_symbols>> is passed a function
 233         to call to make the final decision about adding an archive
 234         element to the link and to do the actual work of adding the
 235         symbols to the linker hash table.
 236
 237         The function passed to
 238         <<_bfd_generic_link_add_archive_symbols>> must read the
 239         symbols of the archive element and decide whether the archive
 240         element should be included in the link.  If the element is to
 241         be included, the <<add_archive_element>> linker callback
 242         routine must be called with the element as an argument, and
 243         the elements symbols must be added to the linker hash table
 244         just as though the element had itself been passed to the
 245         <<_bfd_link_add_symbols>> function.
 246
 247         When the a.out <<_bfd_link_add_symbols>> function receives an
 248         archive, it calls <<_bfd_generic_link_add_archive_symbols>>
 249         passing <<aout_link_check_archive_element>> as the function
 250         argument. <<aout_link_check_archive_element>> calls
 251         <<aout_link_check_ar_symbols>>.  If the latter decides to add
 252         the element (an element is only added if it provides a real,
 253         non-common, definition for a previously undefined or common
 254         symbol) it calls the <<add_archive_element>> callback and then
 255         <<aout_link_check_archive_element>> calls
 256         <<aout_link_add_symbols>> to actually add the symbols to the
 257         linker hash table.
 258
 259         The ECOFF back end is unusual in that it does not normally
 260         call <<_bfd_generic_link_add_archive_symbols>>, because ECOFF
 261         archives already contain a hash table of symbols.  The ECOFF
 262         back end searches the archive itself to avoid the overhead of
 263         creating a new hash table.
 264
 265 INODE
 266 Performing the Final Link, , Adding Symbols to the Hash Table, Linker Functions
 267 SUBSECTION
 268         Performing the final link
 269
 270 @cindex _bfd_link_final_link in target vector
 271 @cindex target vector (_bfd_final_link)
 272         When all the input files have been processed, the linker calls
 273         the <<_bfd_final_link>> entry point of the output BFD.  This
 274         routine is responsible for producing the final output file,
 275         which has several aspects.  It must relocate the contents of
 276         the input sections and copy the data into the output sections.
 277         It must build an output symbol table including any local
 278         symbols from the input files and the global symbols from the
 279         hash table.  When producing relocateable output, it must
 280         modify the input relocs and write them into the output file.
 281         There may also be object format dependent work to be done.
 282
 283         The linker will also call the <<write_object_contents>> entry
 284         point when the BFD is closed.  The two entry points must work
 285         together in order to produce the correct output file.
 286
 287         The details of how this works are inevitably dependent upon
 288         the specific object file format.  The a.out
 289         <<_bfd_final_link>> routine is <<NAME(aout,final_link)>>.
 290
 291 @menu
 292 @* Information provided by the linker::
 293 @* Relocating the section contents::
 294 @* Writing the symbol table::
 295 @end menu
 296
 297 INODE
 298 Information provided by the linker, Relocating the section contents, Performing the Final Link, Performing the Final Link
 299 SUBSUBSECTION
 300         Information provided by the linker
 301
 302         Before the linker calls the <<_bfd_final_link>> entry point,
 303         it sets up some data structures for the function to use.
 304
 305         The <<input_bfds>> field of the <<bfd_link_info>> structure
 306         will point to a list of all the input files included in the
 307         link.  These files are linked through the <<link_next>> field
 308         of the <<bfd>> structure.
 309
 310         Each section in the output file will have a list of
 311         <<link_order>> structures attached to the <<link_order_head>>
 312         field (the <<link_order>> structure is defined in
 313         <<bfdlink.h>>).  These structures describe how to create the
 314         contents of the output section in terms of the contents of
 315         various input sections, fill constants, and, eventually, other
 316         types of information.  They also describe relocs that must be
 317         created by the BFD backend, but do not correspond to any input
 318         file; this is used to support -Ur, which builds constructors
 319         while generating a relocateable object file.
 320
 321 INODE
 322 Relocating the section contents, Writing the symbol table, Information provided by the linker, Performing the Final Link
 323 SUBSUBSECTION
 324         Relocating the section contents
 325
 326         The <<_bfd_final_link>> function should look through the
 327         <<link_order>> structures attached to each section of the
 328         output file.  Each <<link_order>> structure should either be
 329         handled specially, or it should be passed to the function
 330         <<_bfd_default_link_order>> which will do the right thing
 331         (<<_bfd_default_link_order>> is defined in <<linker.c>>).
 332
 333         For efficiency, a <<link_order>> of type
 334         <<bfd_indirect_link_order>> whose associated section belongs
 335         to a BFD of the same format as the output BFD must be handled
 336         specially.  This type of <<link_order>> describes part of an
 337         output section in terms of a section belonging to one of the
 338         input files.  The <<_bfd_final_link>> function should read the
 339         contents of the section and any associated relocs, apply the
 340         relocs to the section contents, and write out the modified
 341         section contents.  If performing a relocateable link, the
 342         relocs themselves must also be modified and written out.
 343
 344 @findex _bfd_relocate_contents
 345 @findex _bfd_final_link_relocate
 346         The functions <<_bfd_relocate_contents>> and
 347         <<_bfd_final_link_relocate>> provide some general support for
 348         performing the actual relocations, notably overflow checking.
 349         Their arguments include information about the symbol the
 350         relocation is against and a <<reloc_howto_type>> argument
 351         which describes the relocation to perform.  These functions
 352         are defined in <<reloc.c>>.
 353
 354         The a.out function which handles reading, relocating, and
 355         writing section contents is <<aout_link_input_section>>.  The
 356         actual relocation is done in <<aout_link_input_section_std>>
 357         and <<aout_link_input_section_ext>>.
 358
 359 INODE
 360 Writing the symbol table, , Relocating the section contents, Performing the Final Link
 361 SUBSUBSECTION
 362         Writing the symbol table
 363
 364         The <<_bfd_final_link>> function must gather all the symbols
 365         in the input files and write them out.  It must also write out
 366         all the symbols in the global hash table.  This must be
 367         controlled by the <<strip>> and <<discard>> fields of the
 368         <<bfd_link_info>> structure.
 369
 370         The local symbols of the input files will not have been
 371         entered into the linker hash table.  The <<_bfd_final_link>>
 372         routine must consider each input file and include the symbols
 373         in the output file.  It may be convenient to do this when
 374         looking through the <<link_order>> structures, or it may be
 375         done by stepping through the <<input_bfds>> list.
 376
 377         The <<_bfd_final_link>> routine must also traverse the global
 378         hash table to gather all the externally visible symbols.  It
 379         is possible that most of the externally visible symbols may be
 380         written out when considering the symbols of each input file,
 381         but it is still necessary to traverse the hash table since the
 382         linker script may have defined some symbols that are not in
 383         any of the input files.
 384
 385         The <<strip>> field of the <<bfd_link_info>> structure
 386         controls which symbols are written out.  The possible values
 387         are listed in <<bfdlink.h>>.  If the value is <<strip_some>>,
 388         then the <<keep_hash>> field of the <<bfd_link_info>>
 389         structure is a hash table of symbols to keep; each symbol
 390         should be looked up in this hash table, and only symbols which
 391         are present should be included in the output file.
 392
 393         If the <<strip>> field of the <<bfd_link_info>> structure
 394         permits local symbols to be written out, the <<discard>> field
 395         is used to further controls which local symbols are included
 396         in the output file.  If the value is <<discard_l>>, then all
 397         local symbols which begin with a certain prefix are discarded;
 398         this prefix is described by the <<lprefix>> and
 399         <<lprefix_len>> fields of the <<bfd_link_info>> structure.
 400
 401         The a.out backend handles symbols by calling
 402         <<aout_link_write_symbols>> on each input BFD and then
 403         traversing the global hash table with the function
 404         <<aout_link_write_other_symbol>>.  It builds a string table
 405         while writing out the symbols, which is written to the output
 406         file at the end of <<NAME(aout,final_link)>>.
 407 */
 408
 409 static struct bfd_hash_entry *generic_link_hash_newfunc
 410   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
 411            const char *));
 412 static boolean generic_link_read_symbols
 413   PARAMS ((bfd *));
 414 static boolean generic_link_add_symbols
 415   PARAMS ((bfd *, struct bfd_link_info *, boolean collect));
 416 static boolean generic_link_add_object_symbols
 417   PARAMS ((bfd *, struct bfd_link_info *, boolean collect));
 418 static boolean generic_link_check_archive_element_no_collect
 419   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
 420 static boolean generic_link_check_archive_element_collect
 421   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
 422 static boolean generic_link_check_archive_element
 423   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded, boolean collect));
 424 static boolean generic_link_add_symbol_list
 425   PARAMS ((bfd *, struct bfd_link_info *, bfd_size_type count, asymbol **,
 426            boolean collect));
 427 static void set_symbol_from_hash
 428   PARAMS ((asymbol *, struct bfd_link_hash_entry *));
 429 static boolean generic_add_output_symbol
 430   PARAMS ((bfd *, size_t *psymalloc, asymbol *));
 431 static boolean default_fill_link_order
 432   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 433            struct bfd_link_order *));
 434 static boolean default_indirect_link_order
 435   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 436            struct bfd_link_order *, boolean));
 437
 438 /* The link hash table structure is defined in bfdlink.h.  It provides
 439    a base hash table which the backend specific hash tables are built
 440    upon.  */
 441
 442 /* Routine to create an entry in the link hash table.  */
 443
 444 struct bfd_hash_entry *
 445 _bfd_link_hash_newfunc (entry, table, string)
 446      struct bfd_hash_entry *entry;
 447      struct bfd_hash_table *table;
 448      const char *string;
 449 {
 450   struct bfd_link_hash_entry *ret = (struct bfd_link_hash_entry *) entry;
 451
 452   /* Allocate the structure if it has not already been allocated by a
 453      subclass.  */
 454   if (ret == (struct bfd_link_hash_entry *) NULL)
 455     ret = ((struct bfd_link_hash_entry *)
 456            bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry)));
 457   if (ret == (struct bfd_link_hash_entry *) NULL)
 458     {
 459       bfd_set_error (bfd_error_no_memory);
 460       return NULL;
 461     }
 462
 463   /* Call the allocation method of the superclass.  */
 464   ret = ((struct bfd_link_hash_entry *)
 465          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 466
 467   if (ret)
 468     {
 469       /* Initialize the local fields.  */
 470       ret->type = bfd_link_hash_new;
 471       ret->next = NULL;
 472     }
 473
 474   return (struct bfd_hash_entry *) ret;
 475 }
 476
 477 /* Initialize a link hash table.  The BFD argument is the one
 478    responsible for creating this table.  */
 479
 480 boolean
 481 _bfd_link_hash_table_init (table, abfd, newfunc)
 482      struct bfd_link_hash_table *table;
 483      bfd *abfd;
 484      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 485                                                 struct bfd_hash_table *,
 486                                                 const char *));
 487 {
 488   table->creator = abfd->xvec;
 489   table->undefs = NULL;
 490   table->undefs_tail = NULL;
 491   return bfd_hash_table_init (&table->table, newfunc);
 492 }
 493
 494 /* Look up a symbol in a link hash table.  If follow is true, we
 495    follow bfd_link_hash_indirect and bfd_link_hash_warning links to
 496    the real symbol.  */
 497
 498 struct bfd_link_hash_entry *
 499 bfd_link_hash_lookup (table, string, create, copy, follow)
 500      struct bfd_link_hash_table *table;
 501      const char *string;
 502      boolean create;
 503      boolean copy;
 504      boolean follow;
 505 {
 506   struct bfd_link_hash_entry *ret;
 507
 508   ret = ((struct bfd_link_hash_entry *)
 509          bfd_hash_lookup (&table->table, string, create, copy));
 510
 511   if (follow && ret != (struct bfd_link_hash_entry *) NULL)
 512     {
 513       while (ret->type == bfd_link_hash_indirect
 514              || ret->type == bfd_link_hash_warning)
 515         ret = ret->u.i.link;
 516     }
 517
 518   return ret;
 519 }
 520
 521 /* Traverse a generic link hash table.  The only reason this is not a
 522    macro is to do better type checking.  This code presumes that an
 523    argument passed as a struct bfd_hash_entry * may be caught as a
 524    struct bfd_link_hash_entry * with no explicit cast required on the
 525    call.  */
 526
 527 void
 528 bfd_link_hash_traverse (table, func, info)
 529      struct bfd_link_hash_table *table;
 530      boolean (*func) PARAMS ((struct bfd_link_hash_entry *, PTR));
 531      PTR info;
 532 {
 533   bfd_hash_traverse (&table->table,
 534                      ((boolean (*) PARAMS ((struct bfd_hash_entry *, PTR)))
 535                       func),
 536                      info);
 537 }
 538
 539 /* Add a symbol to the linker hash table undefs list.  */
 540
 541 INLINE void
 542 bfd_link_add_undef (table, h)
 543      struct bfd_link_hash_table *table;
 544      struct bfd_link_hash_entry *h;
 545 {
 546   BFD_ASSERT (h->next == NULL);
 547   if (table->undefs_tail != (struct bfd_link_hash_entry *) NULL)
 548     table->undefs_tail->next = h;
 549   if (table->undefs == (struct bfd_link_hash_entry *) NULL)
 550     table->undefs = h;
 551   table->undefs_tail = h;
 552 }
 553 \f
 554 /* Routine to create an entry in an generic link hash table.  */
 555
 556 static struct bfd_hash_entry *
 557 generic_link_hash_newfunc (entry, table, string)
 558      struct bfd_hash_entry *entry;
 559      struct bfd_hash_table *table;
 560      const char *string;
 561 {
 562   struct generic_link_hash_entry *ret =
 563     (struct generic_link_hash_entry *) entry;
 564
 565   /* Allocate the structure if it has not already been allocated by a
 566      subclass.  */
 567   if (ret == (struct generic_link_hash_entry *) NULL)
 568     ret = ((struct generic_link_hash_entry *)
 569            bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry)));
 570   if (ret == (struct generic_link_hash_entry *) NULL)
 571     {
 572       bfd_set_error (bfd_error_no_memory);
 573       return NULL;
 574     }
 575
 576   /* Call the allocation method of the superclass.  */
 577   ret = ((struct generic_link_hash_entry *)
 578          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 579                                  table, string));
 580
 581   if (ret)
 582     {
 583       /* Set local fields.  */
 584       ret->written = false;
 585       ret->sym = NULL;
 586     }
 587
 588   return (struct bfd_hash_entry *) ret;
 589 }
 590
 591 /* Create an generic link hash table.  */
 592
 593 struct bfd_link_hash_table *
 594 _bfd_generic_link_hash_table_create (abfd)
 595      bfd *abfd;
 596 {
 597   struct generic_link_hash_table *ret;
 598
 599   ret = ((struct generic_link_hash_table *)
 600          bfd_alloc (abfd, sizeof (struct generic_link_hash_table)));
 601   if (ret == NULL)
 602     {
 603       bfd_set_error (bfd_error_no_memory);
 604       return (struct bfd_link_hash_table *) NULL;
 605     }
 606   if (! _bfd_link_hash_table_init (&ret->root, abfd,
 607                                    generic_link_hash_newfunc))
 608     {
 609       free (ret);
 610       return (struct bfd_link_hash_table *) NULL;
 611     }
 612   return &ret->root;
 613 }
 614
 615 /* Grab the symbols for an object file when doing a generic link.  We
 616    store the symbols in the outsymbols field.  We need to keep them
 617    around for the entire link to ensure that we only read them once.
 618    If we read them multiple times, we might wind up with relocs and
 619    the hash table pointing to different instances of the symbol
 620    structure.  */
 621
 622 static boolean
 623 generic_link_read_symbols (abfd)
 624      bfd *abfd;
 625 {
 626   if (abfd->outsymbols == (asymbol **) NULL)
 627     {
 628       long symsize;
 629       long symcount;
 630
 631       symsize = bfd_get_symtab_upper_bound (abfd);
 632       if (symsize < 0)
 633         return false;
 634       abfd->outsymbols = (asymbol **) bfd_alloc (abfd, symsize);
 635       if (abfd->outsymbols == NULL && symsize != 0)
 636         {
 637           bfd_set_error (bfd_error_no_memory);
 638           return false;
 639         }
 640       symcount = bfd_canonicalize_symtab (abfd, abfd->outsymbols);
 641       if (symcount < 0)
 642         return false;
 643       abfd->symcount = symcount;
 644     }
 645
 646   return true;
 647 }
 648 \f
 649 /* Generic function to add symbols to from an object file to the
 650    global hash table.  This version does not automatically collect
 651    constructors by name.  */
 652
 653 boolean
 654 _bfd_generic_link_add_symbols (abfd, info)
 655      bfd *abfd;
 656      struct bfd_link_info *info;
 657 {
 658   return generic_link_add_symbols (abfd, info, false);
 659 }
 660
 661 /* Generic function to add symbols from an object file to the global
 662    hash table.  This version automatically collects constructors by
 663    name, as the collect2 program does.  It should be used for any
 664    target which does not provide some other mechanism for setting up
 665    constructors and destructors; these are approximately those targets
 666    for which gcc uses collect2 and do not support stabs.  */
 667
 668 boolean
 669 _bfd_generic_link_add_symbols_collect (abfd, info)
 670      bfd *abfd;
 671      struct bfd_link_info *info;
 672 {
 673   return generic_link_add_symbols (abfd, info, true);
 674 }
 675
 676 /* Add symbols from an object file to the global hash table.  */
 677
 678 static boolean
 679 generic_link_add_symbols (abfd, info, collect)
 680      bfd *abfd;
 681      struct bfd_link_info *info;
 682      boolean collect;
 683 {
 684   boolean ret;
 685
 686   switch (bfd_get_format (abfd))
 687     {
 688     case bfd_object:
 689       ret = generic_link_add_object_symbols (abfd, info, collect);
 690       break;
 691     case bfd_archive:
 692       ret = (_bfd_generic_link_add_archive_symbols
 693              (abfd, info,
 694               (collect
 695                ? generic_link_check_archive_element_collect
 696                : generic_link_check_archive_element_no_collect)));
 697       break;
 698     default:
 699       bfd_set_error (bfd_error_wrong_format);
 700       ret = false;
 701     }
 702
 703   return ret;
 704 }
 705
 706 /* Add symbols from an object file to the global hash table.  */
 707
 708 static boolean
 709 generic_link_add_object_symbols (abfd, info, collect)
 710      bfd *abfd;
 711      struct bfd_link_info *info;
 712      boolean collect;
 713 {
 714   if (! generic_link_read_symbols (abfd))
 715     return false;
 716   return generic_link_add_symbol_list (abfd, info,
 717                                        _bfd_generic_link_get_symcount (abfd),
 718                                        _bfd_generic_link_get_symbols (abfd),
 719                                        collect);
 720 }
 721 \f
 722 /* We build a hash table of all symbols defined in an archive.  */
 723
 724 /* An archive symbol may be defined by multiple archive elements.
 725    This linked list is used to hold the elements.  */
 726
 727 struct archive_list
 728 {
 729   struct archive_list *next;
 730   int indx;
 731 };
 732
 733 /* An entry in an archive hash table.  */
 734
 735 struct archive_hash_entry
 736 {
 737   struct bfd_hash_entry root;
 738   /* Where the symbol is defined.  */
 739   struct archive_list *defs;
 740 };
 741
 742 /* An archive hash table itself.  */
 743
 744 struct archive_hash_table
 745 {
 746   struct bfd_hash_table table;
 747 };
 748
 749 static struct bfd_hash_entry *archive_hash_newfunc
 750   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 751 static boolean archive_hash_table_init
 752   PARAMS ((struct archive_hash_table *,
 753            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 754                                        struct bfd_hash_table *,
 755                                        const char *)));
 756
 757 /* Create a new entry for an archive hash table.  */
 758
 759 static struct bfd_hash_entry *
 760 archive_hash_newfunc (entry, table, string)
 761      struct bfd_hash_entry *entry;
 762      struct bfd_hash_table *table;
 763      const char *string;
 764 {
 765   struct archive_hash_entry *ret = (struct archive_hash_entry *) entry;
 766
 767   /* Allocate the structure if it has not already been allocated by a
 768      subclass.  */
 769   if (ret == (struct archive_hash_entry *) NULL)
 770     ret = ((struct archive_hash_entry *)
 771            bfd_hash_allocate (table, sizeof (struct archive_hash_entry)));
 772   if (ret == (struct archive_hash_entry *) NULL)
 773     {
 774       bfd_set_error (bfd_error_no_memory);
 775       return NULL;
 776     }
 777
 778   /* Call the allocation method of the superclass.  */
 779   ret = ((struct archive_hash_entry *)
 780          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 781
 782   if (ret)
 783     {
 784       /* Initialize the local fields.  */
 785       ret->defs = (struct archive_list *) NULL;
 786     }
 787
 788   return (struct bfd_hash_entry *) ret;
 789 }
 790
 791 /* Initialize an archive hash table.  */
 792
 793 static boolean
 794 archive_hash_table_init (table, newfunc)
 795      struct archive_hash_table *table;
 796      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 797                                                 struct bfd_hash_table *,
 798                                                 const char *));
 799 {
 800   return bfd_hash_table_init (&table->table, newfunc);
 801 }
 802
 803 /* Look up an entry in an archive hash table.  */
 804
 805 #define archive_hash_lookup(t, string, create, copy) \
 806   ((struct archive_hash_entry *) \
 807    bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
 808
 809 /* Allocate space in an archive hash table.  */
 810
 811 #define archive_hash_allocate(t, size) bfd_hash_allocate (&(t)->table, (size))
 812
 813 /* Free an archive hash table.  */
 814
 815 #define archive_hash_table_free(t) bfd_hash_table_free (&(t)->table)
 816
 817 /* Generic function to add symbols from an archive file to the global
 818    hash file.  This function presumes that the archive symbol table
 819    has already been read in (this is normally done by the
 820    bfd_check_format entry point).  It looks through the undefined and
 821    common symbols and searches the archive symbol table for them.  If
 822    it finds an entry, it includes the associated object file in the
 823    link.
 824
 825    The old linker looked through the archive symbol table for
 826    undefined symbols.  We do it the other way around, looking through
 827    undefined symbols for symbols defined in the archive.  The
 828    advantage of the newer scheme is that we only have to look through
 829    the list of undefined symbols once, whereas the old method had to
 830    re-search the symbol table each time a new object file was added.
 831
 832    The CHECKFN argument is used to see if an object file should be
 833    included.  CHECKFN should set *PNEEDED to true if the object file
 834    should be included, and must also call the bfd_link_info
 835    add_archive_element callback function and handle adding the symbols
 836    to the global hash table.  CHECKFN should only return false if some
 837    sort of error occurs.
 838
 839    For some formats, such as a.out, it is possible to look through an
 840    object file but not actually include it in the link.  The
 841    archive_pass field in a BFD is used to avoid checking the symbols
 842    of an object files too many times.  When an object is included in
 843    the link, archive_pass is set to -1.  If an object is scanned but
 844    not included, archive_pass is set to the pass number.  The pass
 845    number is incremented each time a new object file is included.  The
 846    pass number is used because when a new object file is included it
 847    may create new undefined symbols which cause a previously examined
 848    object file to be included.  */
 849
 850 boolean
 851 _bfd_generic_link_add_archive_symbols (abfd, info, checkfn)
 852      bfd *abfd;
 853      struct bfd_link_info *info;
 854      boolean (*checkfn) PARAMS ((bfd *, struct bfd_link_info *,
 855                                  boolean *pneeded));
 856 {
 857   carsym *arsyms;
 858   carsym *arsym_end;
 859   register carsym *arsym;
 860   int pass;
 861   struct archive_hash_table arsym_hash;
 862   int indx;
 863   struct bfd_link_hash_entry **pundef;
 864
 865   if (! bfd_has_map (abfd))
 866     {
 867       /* An empty archive is a special case.  */
 868       if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
 869         return true;
 870       bfd_set_error (bfd_error_no_armap);
 871       return false;
 872     }
 873
 874   arsyms = bfd_ardata (abfd)->symdefs;
 875   arsym_end = arsyms + bfd_ardata (abfd)->symdef_count;
 876
 877   /* In order to quickly determine whether an symbol is defined in
 878      this archive, we build a hash table of the symbols.  */
 879   if (! archive_hash_table_init (&arsym_hash, archive_hash_newfunc))
 880     return false;
 881   for (arsym = arsyms, indx = 0; arsym < arsym_end; arsym++, indx++)
 882     {
 883       struct archive_hash_entry *arh;
 884       struct archive_list *l, **pp;
 885
 886       arh = archive_hash_lookup (&arsym_hash, arsym->name, true, false);
 887       if (arh == (struct archive_hash_entry *) NULL)
 888         goto error_return;
 889       l = ((struct archive_list *)
 890            archive_hash_allocate (&arsym_hash, sizeof (struct archive_list)));
 891       if (l == NULL)
 892         goto error_return;
 893       l->indx = indx;
 894       for (pp = &arh->defs;
 895            *pp != (struct archive_list *) NULL;
 896            pp = &(*pp)->next)
 897         ;
 898       *pp = l;
 899       l->next = NULL;
 900     }
 901
 902   /* The archive_pass field in the archive itself is used to
 903      initialize PASS, sine we may search the same archive multiple
 904      times.  */
 905   pass = abfd->archive_pass + 1;
 906
 907   /* New undefined symbols are added to the end of the list, so we
 908      only need to look through it once.  */
 909   pundef = &info->hash->undefs;
 910   while (*pundef != (struct bfd_link_hash_entry *) NULL)
 911     {
 912       struct bfd_link_hash_entry *h;
 913       struct archive_hash_entry *arh;
 914       struct archive_list *l;
 915
 916       h = *pundef;
 917
 918       /* When a symbol is defined, it is not necessarily removed from
 919          the list.  */
 920       if (h->type != bfd_link_hash_undefined
 921           && h->type != bfd_link_hash_common)
 922         {
 923           /* Remove this entry from the list, for general cleanliness
 924              and because we are going to look through the list again
 925              if we search any more libraries.  We can't remove the
 926              entry if it is the tail, because that would lose any
 927              entries we add to the list later on (it would also cause
 928              us to lose track of whether the symbol has been
 929              referenced).  */
 930           if (*pundef != info->hash->undefs_tail)
 931             *pundef = (*pundef)->next;
 932           else
 933             pundef = &(*pundef)->next;
 934           continue;
 935         }
 936
 937       /* Look for this symbol in the archive symbol map.  */
 938       arh = archive_hash_lookup (&arsym_hash, h->root.string, false, false);
 939       if (arh == (struct archive_hash_entry *) NULL)
 940         {
 941           pundef = &(*pundef)->next;
 942           continue;
 943         }
 944
 945       /* Look at all the objects which define this symbol.  */
 946       for (l = arh->defs; l != (struct archive_list *) NULL; l = l->next)
 947         {
 948           bfd *element;
 949           boolean needed;
 950
 951           /* If the symbol has gotten defined along the way, quit.  */
 952           if (h->type != bfd_link_hash_undefined
 953               && h->type != bfd_link_hash_common)
 954             break;
 955
 956           element = bfd_get_elt_at_index (abfd, l->indx);
 957           if (element == (bfd *) NULL)
 958             goto error_return;
 959
 960           /* If we've already included this element, or if we've
 961              already checked it on this pass, continue.  */
 962           if (element->archive_pass == -1
 963               || element->archive_pass == pass)
 964             continue;
 965
 966           /* If we can't figure this element out, just ignore it.  */
 967           if (! bfd_check_format (element, bfd_object))
 968             {
 969               element->archive_pass = -1;
 970               continue;
 971             }
 972
 973           /* CHECKFN will see if this element should be included, and
 974              go ahead and include it if appropriate.  */
 975           if (! (*checkfn) (element, info, &needed))
 976             goto error_return;
 977
 978           if (! needed)
 979             element->archive_pass = pass;
 980           else
 981             {
 982               element->archive_pass = -1;
 983
 984               /* Increment the pass count to show that we may need to
 985                  recheck object files which were already checked.  */
 986               ++pass;
 987             }
 988         }
 989
 990       pundef = &(*pundef)->next;
 991     }
 992
 993   archive_hash_table_free (&arsym_hash);
 994
 995   /* Save PASS in case we are called again.  */
 996   abfd->archive_pass = pass;
 997
 998   return true;
 999
1000  error_return:
1001   archive_hash_table_free (&arsym_hash);
1002   return false;
1003 }
1004 \f
1005 /* See if we should include an archive element.  This version is used
1006    when we do not want to automatically collect constructors based on
1007    the symbol name, presumably because we have some other mechanism
1008    for finding them.  */
1009
1010 static boolean
1011 generic_link_check_archive_element_no_collect (abfd, info, pneeded)
1012      bfd *abfd;
1013      struct bfd_link_info *info;
1014      boolean *pneeded;
1015 {
1016   return generic_link_check_archive_element (abfd, info, pneeded, false);
1017 }
1018
1019 /* See if we should include an archive element.  This version is used
1020    when we want to automatically collect constructors based on the
1021    symbol name, as collect2 does.  */
1022
1023 static boolean
1024 generic_link_check_archive_element_collect (abfd, info, pneeded)
1025      bfd *abfd;
1026      struct bfd_link_info *info;
1027      boolean *pneeded;
1028 {
1029   return generic_link_check_archive_element (abfd, info, pneeded, true);
1030 }
1031
1032 /* See if we should include an archive element.  Optionally collect
1033    constructors.  */
1034
1035 static boolean
1036 generic_link_check_archive_element (abfd, info, pneeded, collect)
1037      bfd *abfd;
1038      struct bfd_link_info *info;
1039      boolean *pneeded;
1040      boolean collect;
1041 {
1042   asymbol **pp, **ppend;
1043
1044   *pneeded = false;
1045
1046   if (! generic_link_read_symbols (abfd))
1047     return false;
1048
1049   pp = _bfd_generic_link_get_symbols (abfd);
1050   ppend = pp + _bfd_generic_link_get_symcount (abfd);
1051   for (; pp < ppend; pp++)
1052     {
1053       asymbol *p;
1054       struct bfd_link_hash_entry *h;
1055
1056       p = *pp;
1057
1058       /* We are only interested in globally visible symbols.  */
1059       if (! bfd_is_com_section (p->section)
1060           && (p->flags & (BSF_GLOBAL | BSF_INDIRECT | BSF_WEAK)) == 0)
1061         continue;
1062
1063       /* We are only interested if we know something about this
1064          symbol, and it is undefined or common.  An undefined weak
1065          symbol (type bfd_link_hash_undefweak) is not considered to be
1066          a reference when pulling files out of an archive.  See the
1067          SVR4 ABI, p. 4-27.  */
1068       h = bfd_link_hash_lookup (info->hash, bfd_asymbol_name (p), false,
1069                                 false, true);
1070       if (h == (struct bfd_link_hash_entry *) NULL
1071           || (h->type != bfd_link_hash_undefined
1072               && h->type != bfd_link_hash_common))
1073         continue;
1074
1075       /* P is a symbol we are looking for.  */
1076
1077       if (! bfd_is_com_section (p->section))
1078         {
1079           bfd_size_type symcount;
1080           asymbol **symbols;
1081
1082           /* This object file defines this symbol, so pull it in.  */
1083           if (! (*info->callbacks->add_archive_element) (info, abfd,
1084                                                          bfd_asymbol_name (p)))
1085             return false;
1086           symcount = _bfd_generic_link_get_symcount (abfd);
1087           symbols = _bfd_generic_link_get_symbols (abfd);
1088           if (! generic_link_add_symbol_list (abfd, info, symcount,
1089                                               symbols, collect))
1090             return false;
1091           *pneeded = true;
1092           return true;
1093         }
1094
1095       /* P is a common symbol.  */
1096
1097       if (h->type == bfd_link_hash_undefined)
1098         {
1099           bfd *symbfd;
1100           bfd_vma size;
1101           unsigned int power;
1102
1103           symbfd = h->u.undef.abfd;
1104           if (symbfd == (bfd *) NULL)
1105             {
1106               /* This symbol was created as undefined from outside
1107                  BFD.  We assume that we should link in the object
1108                  file.  This is for the -u option in the linker.  */
1109               if (! (*info->callbacks->add_archive_element)
1110                   (info, abfd, bfd_asymbol_name (p)))
1111                 return false;
1112               *pneeded = true;
1113               return true;
1114             }
1115
1116           /* Turn the symbol into a common symbol but do not link in
1117              the object file.  This is how a.out works.  Object
1118              formats that require different semantics must implement
1119              this function differently.  This symbol is already on the
1120              undefs list.  We add the section to a common section
1121              attached to symbfd to ensure that it is in a BFD which
1122              will be linked in.  */
1123           h->type = bfd_link_hash_common;
1124           h->u.c.p =
1125             ((struct bfd_link_hash_common_entry *)
1126              bfd_hash_allocate (&info->hash->table,
1127                                 sizeof (struct bfd_link_hash_common_entry)));
1128           if (h->u.c.p == NULL)
1129             return false;
1130
1131           size = bfd_asymbol_value (p);
1132           h->u.c.size = size;
1133
1134           power = bfd_log2 (size);
1135           if (power > 4)
1136             power = 4;
1137           h->u.c.p->alignment_power = power;
1138
1139           if (p->section == bfd_com_section_ptr)
1140             h->u.c.p->section = bfd_make_section_old_way (symbfd, "COMMON");
1141           else
1142             h->u.c.p->section = bfd_make_section_old_way (symbfd,
1143                                                           p->section->name);
1144           h->u.c.p->section->flags = SEC_ALLOC;
1145         }
1146       else
1147         {
1148           /* Adjust the size of the common symbol if necessary.  This
1149              is how a.out works.  Object formats that require
1150              different semantics must implement this function
1151              differently.  */
1152           if (bfd_asymbol_value (p) > h->u.c.size)
1153             h->u.c.size = bfd_asymbol_value (p);
1154         }
1155     }
1156
1157   /* This archive element is not needed.  */
1158   return true;
1159 }
1160
1161 /* Add the symbols from an object file to the global hash table.  ABFD
1162    is the object file.  INFO is the linker information.  SYMBOL_COUNT
1163    is the number of symbols.  SYMBOLS is the list of symbols.  COLLECT
1164    is true if constructors should be automatically collected by name
1165    as is done by collect2.  */
1166
1167 static boolean
1168 generic_link_add_symbol_list (abfd, info, symbol_count, symbols, collect)
1169      bfd *abfd;
1170      struct bfd_link_info *info;
1171      bfd_size_type symbol_count;
1172      asymbol **symbols;
1173      boolean collect;
1174 {
1175   asymbol **pp, **ppend;
1176
1177   pp = symbols;
1178   ppend = symbols + symbol_count;
1179   for (; pp < ppend; pp++)
1180     {
1181       asymbol *p;
1182
1183       p = *pp;
1184
1185       if ((p->flags & (BSF_INDIRECT
1186                        | BSF_WARNING
1187                        | BSF_GLOBAL
1188                        | BSF_CONSTRUCTOR
1189                        | BSF_WEAK)) != 0
1190           || bfd_is_und_section (bfd_get_section (p))
1191           || bfd_is_com_section (bfd_get_section (p))
1192           || bfd_is_ind_section (bfd_get_section (p)))
1193         {
1194           const char *name;
1195           const char *string;
1196           struct generic_link_hash_entry *h;
1197
1198           name = bfd_asymbol_name (p);
1199           if ((p->flags & BSF_INDIRECT) != 0
1200               || bfd_is_ind_section (p->section))
1201             string = bfd_asymbol_name ((asymbol *) p->value);
1202           else if ((p->flags & BSF_WARNING) != 0)
1203             {
1204               /* The name of P is actually the warning string, and the
1205                  value is actually a pointer to the symbol to warn
1206                  about.  */
1207               string = name;
1208               name = bfd_asymbol_name ((asymbol *) p->value);
1209             }
1210           else
1211             string = NULL;
1212
1213           h = NULL;
1214           if (! (_bfd_generic_link_add_one_symbol
1215                  (info, abfd, name, p->flags, bfd_get_section (p),
1216                   p->value, string, false, collect,
1217                   (struct bfd_link_hash_entry **) &h)))
1218             return false;
1219
1220           /* If this is a constructor symbol, and the linker didn't do
1221              anything with it, then we want to just pass the symbol
1222              through to the output file.  This will happen when
1223              linking with -r.  */
1224           if ((p->flags & BSF_CONSTRUCTOR) != 0
1225               && (h == NULL || h->root.type == bfd_link_hash_new))
1226             {
1227               p->udata.p = NULL;
1228               continue;
1229             }
1230
1231           /* Save the BFD symbol so that we don't lose any backend
1232              specific information that may be attached to it.  We only
1233              want this one if it gives more information than the
1234              existing one; we don't want to replace a defined symbol
1235              with an undefined one.  This routine may be called with a
1236              hash table other than the generic hash table, so we only
1237              do this if we are certain that the hash table is a
1238              generic one.  */
1239           if (info->hash->creator == abfd->xvec)
1240             {
1241               if (h->sym == (asymbol *) NULL
1242                   || (! bfd_is_und_section (bfd_get_section (p))
1243                       && (! bfd_is_com_section (bfd_get_section (p))
1244                           || bfd_is_und_section (bfd_get_section (h->sym)))))
1245                 {
1246                   h->sym = p;
1247                   /* BSF_OLD_COMMON is a hack to support COFF reloc
1248                      reading, and it should go away when the COFF
1249                      linker is switched to the new version.  */
1250                   if (bfd_is_com_section (bfd_get_section (p)))
1251                     p->flags |= BSF_OLD_COMMON;
1252                 }
1253
1254               /* Store a back pointer from the symbol to the hash
1255                  table entry for the benefit of relaxation code until
1256                  it gets rewritten to not use asymbol structures.
1257                  Setting this is also used to check whether these
1258                  symbols were set up by the generic linker.  */
1259               p->udata.p = (PTR) h;
1260             }
1261         }
1262     }
1263
1264   return true;
1265 }
1266 \f
1267 /* We use a state table to deal with adding symbols from an object
1268    file.  The first index into the state table describes the symbol
1269    from the object file.  The second index into the state table is the
1270    type of the symbol in the hash table.  */
1271
1272 /* The symbol from the object file is turned into one of these row
1273    values.  */
1274
1275 enum link_row
1276 {
1277   UNDEF_ROW,            /* Undefined.  */
1278   UNDEFW_ROW,           /* Weak undefined.  */
1279   DEF_ROW,              /* Defined.  */
1280   DEFW_ROW,             /* Weak defined.  */
1281   COMMON_ROW,           /* Common.  */
1282   INDR_ROW,             /* Indirect.  */
1283   WARN_ROW,             /* Warning.  */
1284   SET_ROW               /* Member of set.  */
1285 };
1286
1287 /* apparently needed for Hitachi 3050R(HI-UX/WE2)? */
1288 #undef FAIL
1289
1290 /* The actions to take in the state table.  */
1291
1292 enum link_action
1293 {
1294   FAIL,         /* Abort. */
1295   UND,          /* Mark symbol undefined.  */
1296   WEAK,         /* Mark symbol weak undefined.  */
1297   DEF,          /* Mark symbol defined.  */
1298   DEFW,         /* Mark symbol weak defined.  */
1299   COM,          /* Mark symbol common.  */
1300   REF,          /* Mark defined symbol referenced.  */
1301   CREF,         /* Possibly warn about common reference to defined symbol.  */
1302   CDEF,         /* Define existing common symbol.  */
1303   NOACT,        /* No action.  */
1304   BIG,          /* Mark symbol common using largest size.  */
1305   MDEF,         /* Multiple definition error.  */
1306   MIND,         /* Multiple indirect symbols.  */
1307   IND,          /* Make indirect symbol.  */
1308   CIND,         /* Make indirect symbol from existing common symbol.  */
1309   SET,          /* Add value to set.  */
1310   MWARN,        /* Make warning symbol.  */
1311   WARN,         /* Issue warning.  */
1312   CWARN,        /* Warn if referenced, else MWARN.  */
1313   CYCLE,        /* Repeat with symbol pointed to.  */
1314   REFC,         /* Mark indirect symbol referenced and then CYCLE.  */
1315   WARNC         /* Issue warning and then CYCLE.  */
1316 };
1317
1318 /* The state table itself.  The first index is a link_row and the
1319    second index is a bfd_link_hash_type.  */
1320
1321 static const enum link_action link_action[8][8] =
1322 {
1323   /* current\prev    new    undef  undefw def    defw   com    indr   warn  */
1324   /* UNDEF_ROW  */  {UND,   NOACT, NOACT, REF,   REF,   NOACT, REFC,  WARNC },
1325   /* UNDEFW_ROW */  {WEAK,  NOACT, NOACT, REF,   REF,   NOACT, REFC,  WARNC },
1326   /* DEF_ROW    */  {DEF,   DEF,   DEF,   MDEF,  DEF,   CDEF,  MDEF,  CYCLE },
1327   /* DEFW_ROW   */  {DEFW,  DEFW,  DEFW,  NOACT, NOACT, NOACT, NOACT, CYCLE },
1328   /* COMMON_ROW */  {COM,   COM,   COM,   CREF,  CREF,  BIG,   CREF,  WARNC },
1329   /* INDR_ROW   */  {IND,   IND,   IND,   MDEF,  IND,   CIND,  MIND,  CYCLE },
1330   /* WARN_ROW   */  {MWARN, WARN,  WARN,  CWARN, CWARN, WARN,  CWARN, CYCLE },
1331   /* SET_ROW    */  {SET,   SET,   SET,   SET,   SET,   SET,   CYCLE, CYCLE }
1332 };
1333
1334 /* Most of the entries in the LINK_ACTION table are straightforward,
1335    but a few are somewhat subtle.
1336
1337    A reference to an indirect symbol (UNDEF_ROW/indr or
1338    UNDEFW_ROW/indr) is counted as a reference both to the indirect
1339    symbol and to the symbol the indirect symbol points to.
1340
1341    A reference to a warning symbol (UNDEF_ROW/warn or UNDEFW_ROW/warn)
1342    causes the warning to be issued.
1343
1344    A common definition of an indirect symbol (COMMON_ROW/indr) is
1345    treated as a multiple definition error.  Likewise for an indirect
1346    definition of a common symbol (INDR_ROW/com).
1347
1348    An indirect definition of a warning (INDR_ROW/warn) does not cause
1349    the warning to be issued.
1350
1351    If a warning is created for an indirect symbol (WARN_ROW/indr) no
1352    warning is created for the symbol the indirect symbol points to.
1353
1354    Adding an entry to a set does not count as a reference to a set,
1355    and no warning is issued (SET_ROW/warn).  */
1356
1357 /* Add a symbol to the global hash table.
1358    ABFD is the BFD the symbol comes from.
1359    NAME is the name of the symbol.
1360    FLAGS is the BSF_* bits associated with the symbol.
1361    SECTION is the section in which the symbol is defined; this may be
1362      bfd_und_section_ptr or bfd_com_section_ptr.
1363    VALUE is the value of the symbol, relative to the section.
1364    STRING is used for either an indirect symbol, in which case it is
1365      the name of the symbol to indirect to, or a warning symbol, in
1366      which case it is the warning string.
1367    COPY is true if NAME or STRING must be copied into locally
1368      allocated memory if they need to be saved.
1369    COLLECT is true if we should automatically collect gcc constructor
1370      or destructor names as collect2 does.
1371    HASHP, if not NULL, is a place to store the created hash table
1372      entry; if *HASHP is not NULL, the caller has already looked up
1373      the hash table entry, and stored it in *HASHP. */
1374
1375 boolean
1376 _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, value,
1377                                   string, copy, collect, hashp)
1378      struct bfd_link_info *info;
1379      bfd *abfd;
1380      const char *name;
1381      flagword flags;
1382      asection *section;
1383      bfd_vma value;
1384      const char *string;
1385      boolean copy;
1386      boolean collect;
1387      struct bfd_link_hash_entry **hashp;
1388 {
1389   enum link_row row;
1390   struct bfd_link_hash_entry *h;
1391   boolean cycle;
1392
1393   if (bfd_is_ind_section (section)
1394       || (flags & BSF_INDIRECT) != 0)
1395     row = INDR_ROW;
1396   else if ((flags & BSF_WARNING) != 0)
1397     row = WARN_ROW;
1398   else if ((flags & BSF_CONSTRUCTOR) != 0)
1399     row = SET_ROW;
1400   else if (bfd_is_und_section (section))
1401     {
1402       if ((flags & BSF_WEAK) != 0)
1403         row = UNDEFW_ROW;
1404       else
1405         row = UNDEF_ROW;
1406     }
1407   else if ((flags & BSF_WEAK) != 0)
1408     row = DEFW_ROW;
1409   else if (bfd_is_com_section (section))
1410     row = COMMON_ROW;
1411   else
1412     row = DEF_ROW;
1413
1414   if (hashp != NULL && *hashp != NULL)
1415     {
1416       h = *hashp;
1417       BFD_ASSERT (strcmp (h->root.string, name) == 0);
1418     }
1419   else
1420     {
1421       h = bfd_link_hash_lookup (info->hash, name, true, copy, false);
1422       if (h == NULL)
1423         {
1424           if (hashp != NULL)
1425             *hashp = NULL;
1426           return false;
1427         }
1428     }
1429
1430   if (info->notice_hash != (struct bfd_hash_table *) NULL
1431       && (bfd_hash_lookup (info->notice_hash, name, false, false)
1432           != (struct bfd_hash_entry *) NULL))
1433     {
1434       if (! (*info->callbacks->notice) (info, name, abfd, section, value))
1435         return false;
1436     }
1437
1438   if (hashp != (struct bfd_link_hash_entry **) NULL)
1439     *hashp = h;
1440
1441   do
1442     {
1443       enum link_action action;
1444
1445       cycle = false;
1446       action = link_action[(int) row][(int) h->type];
1447       switch (action)
1448         {
1449         case FAIL:
1450           abort ();
1451
1452         case NOACT:
1453           /* Do nothing.  */
1454           break;
1455
1456         case UND:
1457           /* Make a new undefined symbol.  */
1458           h->type = bfd_link_hash_undefined;
1459           h->u.undef.abfd = abfd;
1460           bfd_link_add_undef (info->hash, h);
1461           break;
1462
1463         case WEAK:
1464           /* Make a new weak undefined symbol.  */
1465           h->type = bfd_link_hash_undefweak;
1466           h->u.undef.abfd = abfd;
1467           break;
1468
1469         case CDEF:
1470           /* We have found a definition for a symbol which was
1471              previously common.  */
1472           BFD_ASSERT (h->type == bfd_link_hash_common);
1473           if (! ((*info->callbacks->multiple_common)
1474                  (info, name,
1475                   h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
1476                   abfd, bfd_link_hash_defined, (bfd_vma) 0)))
1477             return false;
1478           /* Fall through.  */
1479         case DEF:
1480         case DEFW:
1481           {
1482             enum bfd_link_order_type oldtype;
1483
1484             /* Define a symbol.  */
1485             oldtype = h->type;
1486             if (action == DEFW)
1487               h->type = bfd_link_hash_defweak;
1488             else
1489               h->type = bfd_link_hash_defined;
1490             h->u.def.section = section;
1491             h->u.def.value = value;
1492
1493             /* If we have been asked to, we act like collect2 and
1494                identify all functions that might be global
1495                constructors and destructors and pass them up in a
1496                callback.  We only do this for certain object file
1497                types, since many object file types can handle this
1498                automatically.  */
1499             if (collect && name[0] == '_')
1500               {
1501                 const char *s;
1502
1503                 /* A constructor or destructor name starts like this:
1504                    _+GLOBAL_[_.$][ID][_.$] where the first [_.$] and
1505                    the second are the same character (we accept any
1506                    character there, in case a new object file format
1507                    comes along with even worse naming restrictions).  */
1508
1509 #define CONS_PREFIX "GLOBAL_"
1510 #define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
1511
1512                 s = name + 1;
1513                 while (*s == '_')
1514                   ++s;
1515                 if (s[0] == 'G'
1516                     && strncmp (s, CONS_PREFIX, CONS_PREFIX_LEN - 1) == 0)
1517                   {
1518                     char c;
1519
1520                     c = s[CONS_PREFIX_LEN + 1];
1521                     if ((c == 'I' || c == 'D')
1522                         && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
1523                       {
1524                         /* If this is a definition of a symbol which
1525                            was previously weakly defined, we are in
1526                            trouble.  We have already added a
1527                            constructor entry for the weak defined
1528                            symbol, and now we are trying to add one
1529                            for the new symbol.  Fortunately, this case
1530                            should never arise in practice.  */
1531                         if (oldtype == bfd_link_hash_defweak)
1532                           abort ();
1533
1534                         if (! ((*info->callbacks->constructor)
1535                                (info,
1536                                 c == 'I' ? true : false,
1537                                 name, abfd, section, value)))
1538                           return false;
1539                       }
1540                   }
1541               }
1542           }
1543
1544           break;
1545
1546         case COM:
1547           /* We have found a common definition for a symbol.  */
1548           if (h->type == bfd_link_hash_new)
1549             bfd_link_add_undef (info->hash, h);
1550           h->type = bfd_link_hash_common;
1551           h->u.c.p =
1552             ((struct bfd_link_hash_common_entry *)
1553              bfd_hash_allocate (&info->hash->table,
1554                                 sizeof (struct bfd_link_hash_common_entry)));
1555           if (h->u.c.p == NULL)
1556             return false;
1557
1558           h->u.c.size = value;
1559
1560           /* Select a default alignment based on the size.  This may
1561              be overridden by the caller.  */
1562           {
1563             unsigned int power;
1564
1565             power = bfd_log2 (value);
1566             if (power > 4)
1567               power = 4;
1568             h->u.c.p->alignment_power = power;
1569           }
1570
1571           /* The section of a common symbol is only used if the common
1572              symbol is actually allocated.  It basically provides a
1573              hook for the linker script to decide which output section
1574              the common symbols should be put in.  In most cases, the
1575              section of a common symbol will be bfd_com_section_ptr,
1576              the code here will choose a common symbol section named
1577              "COMMON", and the linker script will contain *(COMMON) in
1578              the appropriate place.  A few targets use separate common
1579              sections for small symbols, and they require special
1580              handling.  */
1581           if (section == bfd_com_section_ptr)
1582             {
1583               h->u.c.p->section = bfd_make_section_old_way (abfd, "COMMON");
1584               h->u.c.p->section->flags = SEC_ALLOC;
1585             }
1586           else if (section->owner != abfd)
1587             {
1588               h->u.c.p->section = bfd_make_section_old_way (abfd,
1589                                                             section->name);
1590               h->u.c.p->section->flags = SEC_ALLOC;
1591             }
1592           else
1593             h->u.c.p->section = section;
1594           break;
1595
1596         case REF:
1597           /* A reference to a defined symbol.  */
1598           if (h->next == NULL && info->hash->undefs_tail != h)
1599             h->next = h;
1600           break;
1601
1602         case BIG:
1603           /* We have found a common definition for a symbol which
1604              already had a common definition.  Use the maximum of the
1605              two sizes.  */
1606           BFD_ASSERT (h->type == bfd_link_hash_common);
1607           if (! ((*info->callbacks->multiple_common)
1608                  (info, name,
1609                   h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
1610                   abfd, bfd_link_hash_common, value)))
1611             return false;
1612           if (value > h->u.c.size)
1613             {
1614               unsigned int power;
1615
1616               h->u.c.size = value;
1617
1618               /* Select a default alignment based on the size.  This may
1619                  be overridden by the caller.  */
1620               power = bfd_log2 (value);
1621               if (power > 4)
1622                 power = 4;
1623               h->u.c.p->alignment_power = power;
1624             }
1625           break;
1626
1627         case CREF:
1628           {
1629             bfd *obfd;
1630
1631             /* We have found a common definition for a symbol which
1632                was already defined.  FIXME: It would nice if we could
1633                report the BFD which defined an indirect symbol, but we
1634                don't have anywhere to store the information.  */
1635             if (h->type == bfd_link_hash_defined
1636                 || h->type == bfd_link_hash_defweak)
1637               obfd = h->u.def.section->owner;
1638             else
1639               obfd = NULL;
1640             if (! ((*info->callbacks->multiple_common)
1641                    (info, name, obfd, h->type, (bfd_vma) 0,
1642                     abfd, bfd_link_hash_common, value)))
1643               return false;
1644           }
1645           break;
1646
1647         case MIND:
1648           /* Multiple indirect symbols.  This is OK if they both point
1649              to the same symbol.  */
1650           if (strcmp (h->u.i.link->root.string, string) == 0)
1651             break;
1652           /* Fall through.  */
1653         case MDEF:
1654           /* Handle a multiple definition.  */
1655           {
1656             asection *msec;
1657             bfd_vma mval;
1658
1659             switch (h->type)
1660               {
1661               case bfd_link_hash_defined:
1662                 msec = h->u.def.section;
1663                 mval = h->u.def.value;
1664                 break;
1665               case bfd_link_hash_indirect:
1666                 msec = bfd_ind_section_ptr;
1667                 mval = 0;
1668                 break;
1669               default:
1670                 abort ();
1671               }
1672
1673             /* Ignore a redefinition of an absolute symbol to the same
1674                value; it's harmless.  */
1675             if (h->type == bfd_link_hash_defined
1676                 && bfd_is_abs_section (msec)
1677                 && bfd_is_abs_section (section)
1678                 && value == mval)
1679               break;
1680
1681             if (! ((*info->callbacks->multiple_definition)
1682                    (info, name, msec->owner, msec, mval, abfd, section,
1683                     value)))
1684               return false;
1685           }
1686           break;
1687
1688         case CIND:
1689           /* Create an indirect symbol from an existing common symbol.  */
1690           BFD_ASSERT (h->type == bfd_link_hash_common);
1691           if (! ((*info->callbacks->multiple_common)
1692                  (info, name,
1693                   h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
1694                   abfd, bfd_link_hash_indirect, (bfd_vma) 0)))
1695             return false;
1696           /* Fall through.  */
1697         case IND:
1698           /* Create an indirect symbol.  */
1699           {
1700             struct bfd_link_hash_entry *inh;
1701
1702             /* STRING is the name of the symbol we want to indirect
1703                to.  */
1704             inh = bfd_link_hash_lookup (info->hash, string, true, copy,
1705                                         false);
1706             if (inh == (struct bfd_link_hash_entry *) NULL)
1707               return false;
1708             if (inh->type == bfd_link_hash_new)
1709               {
1710                 inh->type = bfd_link_hash_undefined;
1711                 inh->u.undef.abfd = abfd;
1712                 bfd_link_add_undef (info->hash, inh);
1713               }
1714
1715             /* If the indirect symbol has been referenced, we need to
1716                push the reference down to the symbol we are
1717                referencing.  */
1718             if (h->type != bfd_link_hash_new)
1719               {
1720                 row = UNDEF_ROW;
1721                 cycle = true;
1722               }
1723
1724             h->type = bfd_link_hash_indirect;
1725             h->u.i.link = inh;
1726           }
1727           break;
1728
1729         case SET:
1730           /* Add an entry to a set.  */
1731           if (! (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR,
1732                                                 abfd, section, value))
1733             return false;
1734           break;
1735
1736         case WARNC:
1737           /* Issue a warning and cycle.  */
1738           if (h->u.i.warning != NULL)
1739             {
1740               if (! (*info->callbacks->warning) (info, h->u.i.warning))
1741                 return false;
1742               /* Only issue a warning once.  */
1743               h->u.i.warning = NULL;
1744             }
1745           /* Fall through.  */
1746         case CYCLE:
1747           /* Try again with the referenced symbol.  */
1748           h = h->u.i.link;
1749           cycle = true;
1750           break;
1751
1752         case REFC:
1753           /* A reference to an indirect symbol.  */
1754           if (h->next == NULL && info->hash->undefs_tail != h)
1755             h->next = h;
1756           h = h->u.i.link;
1757           cycle = true;
1758           break;
1759
1760         case WARN:
1761           /* Issue a warning.  */
1762           if (! (*info->callbacks->warning) (info, string))
1763             return false;
1764           break;
1765
1766         case CWARN:
1767           /* Warn if this symbol has been referenced already,
1768              otherwise add a warning.  A symbol has been referenced if
1769              the next field is not NULL, or it is the tail of the
1770              undefined symbol list.  The REF case above helps to
1771              ensure this.  */
1772           if (h->next != NULL || info->hash->undefs_tail == h)
1773             {
1774               if (! (*info->callbacks->warning) (info, string))
1775                 return false;
1776               break;
1777             }
1778           /* Fall through.  */
1779         case MWARN:
1780           /* Make a warning symbol.  */
1781           {
1782             struct bfd_link_hash_entry *sub;
1783
1784             /* STRING is the warning to give.  */
1785             sub = ((struct bfd_link_hash_entry *)
1786                    bfd_hash_allocate (&info->hash->table,
1787                                       sizeof (struct bfd_link_hash_entry)));
1788             if (!sub)
1789               {
1790                 bfd_set_error (bfd_error_no_memory);
1791                 return false;
1792               }
1793             *sub = *h;
1794             h->type = bfd_link_hash_warning;
1795             h->u.i.link = sub;
1796             if (! copy)
1797               h->u.i.warning = string;
1798             else
1799               {
1800                 char *w;
1801
1802                 w = bfd_hash_allocate (&info->hash->table,
1803                                        strlen (string) + 1);
1804                 strcpy (w, string);
1805                 h->u.i.warning = w;
1806               }
1807           }
1808           break;
1809         }
1810     }
1811   while (cycle);
1812
1813   return true;
1814 }
1815 \f
1816 /* Generic final link routine.  */
1817
1818 boolean
1819 _bfd_generic_final_link (abfd, info)
1820      bfd *abfd;
1821      struct bfd_link_info *info;
1822 {
1823   bfd *sub;
1824   asection *o;
1825   struct bfd_link_order *p;
1826   size_t outsymalloc;
1827   struct generic_write_global_symbol_info wginfo;
1828
1829   abfd->outsymbols = (asymbol **) NULL;
1830   abfd->symcount = 0;
1831   outsymalloc = 0;
1832
1833   /* Build the output symbol table.  */
1834   for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
1835     if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
1836       return false;
1837
1838   /* Accumulate the global symbols.  */
1839   wginfo.info = info;
1840   wginfo.output_bfd = abfd;
1841   wginfo.psymalloc = &outsymalloc;
1842   _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info),
1843                                    _bfd_generic_link_write_global_symbol,
1844                                    (PTR) &wginfo);
1845
1846   if (info->relocateable)
1847     {
1848       /* Allocate space for the output relocs for each section.  */
1849       for (o = abfd->sections;
1850            o != (asection *) NULL;
1851            o = o->next)
1852         {
1853           o->reloc_count = 0;
1854           for (p = o->link_order_head;
1855                p != (struct bfd_link_order *) NULL;
1856                p = p->next)
1857             {
1858               if (p->type == bfd_section_reloc_link_order
1859                   || p->type == bfd_symbol_reloc_link_order)
1860                 ++o->reloc_count;
1861               else if (p->type == bfd_indirect_link_order)
1862                 {
1863                   asection *input_section;
1864                   bfd *input_bfd;
1865                   long relsize;
1866                   arelent **relocs;
1867                   asymbol **symbols;
1868                   long reloc_count;
1869
1870                   input_section = p->u.indirect.section;
1871                   input_bfd = input_section->owner;
1872                   relsize = bfd_get_reloc_upper_bound (input_bfd,
1873                                                        input_section);
1874                   if (relsize < 0)
1875                     return false;
1876                   relocs = (arelent **) malloc ((size_t) relsize);
1877                   if (!relocs && relsize != 0)
1878                     {
1879                       bfd_set_error (bfd_error_no_memory);
1880                       return false;
1881                     }
1882                   symbols = _bfd_generic_link_get_symbols (input_bfd);
1883                   reloc_count = bfd_canonicalize_reloc (input_bfd,
1884                                                         input_section,
1885                                                         relocs,
1886                                                         symbols);
1887                   if (reloc_count < 0)
1888                     return false;
1889                   BFD_ASSERT (reloc_count == input_section->reloc_count);
1890                   o->reloc_count += reloc_count;
1891                   free (relocs);
1892                 }
1893             }
1894           if (o->reloc_count > 0)
1895             {
1896               o->orelocation = ((arelent **)
1897                                 bfd_alloc (abfd,
1898                                            (o->reloc_count
1899                                             * sizeof (arelent *))));
1900               if (!o->orelocation)
1901                 {
1902                   bfd_set_error (bfd_error_no_memory);
1903                   return false;
1904                 }
1905               o->flags |= SEC_RELOC;
1906               /* Reset the count so that it can be used as an index
1907                  when putting in the output relocs.  */
1908               o->reloc_count = 0;
1909             }
1910         }
1911     }
1912
1913   /* Handle all the link order information for the sections.  */
1914   for (o = abfd->sections;
1915        o != (asection *) NULL;
1916        o = o->next)
1917     {
1918       for (p = o->link_order_head;
1919            p != (struct bfd_link_order *) NULL;
1920            p = p->next)
1921         {
1922           switch (p->type)
1923             {
1924             case bfd_section_reloc_link_order:
1925             case bfd_symbol_reloc_link_order:
1926               if (! _bfd_generic_reloc_link_order (abfd, info, o, p))
1927                 return false;
1928               break;
1929             case bfd_indirect_link_order:
1930               if (! default_indirect_link_order (abfd, info, o, p, true))
1931                 return false;
1932               break;
1933             default:
1934               if (! _bfd_default_link_order (abfd, info, o, p))
1935                 return false;
1936               break;
1937             }
1938         }
1939     }
1940
1941   return true;
1942 }
1943
1944 /* Add an output symbol to the output BFD.  */
1945
1946 static boolean
1947 generic_add_output_symbol (output_bfd, psymalloc, sym)
1948      bfd *output_bfd;
1949      size_t *psymalloc;
1950      asymbol *sym;
1951 {
1952   if (output_bfd->symcount >= *psymalloc)
1953     {
1954       asymbol **newsyms;
1955
1956       if (*psymalloc == 0)
1957         *psymalloc = 124;
1958       else
1959         *psymalloc *= 2;
1960       if (output_bfd->outsymbols == (asymbol **) NULL)
1961         newsyms = (asymbol **) malloc (*psymalloc * sizeof (asymbol *));
1962       else
1963         newsyms = (asymbol **) realloc (output_bfd->outsymbols,
1964                                         *psymalloc * sizeof (asymbol *));
1965       if (newsyms == (asymbol **) NULL)
1966         {
1967           bfd_set_error (bfd_error_no_memory);
1968           return false;
1969         }
1970       output_bfd->outsymbols = newsyms;
1971     }
1972
1973   output_bfd->outsymbols[output_bfd->symcount] = sym;
1974   ++output_bfd->symcount;
1975
1976   return true;
1977 }
1978
1979 /* Handle the symbols for an input BFD.  */
1980
1981 boolean
1982 _bfd_generic_link_output_symbols (output_bfd, input_bfd, info, psymalloc)
1983      bfd *output_bfd;
1984      bfd *input_bfd;
1985      struct bfd_link_info *info;
1986      size_t *psymalloc;
1987 {
1988   asymbol **sym_ptr;
1989   asymbol **sym_end;
1990
1991   if (! generic_link_read_symbols (input_bfd))
1992     return false;
1993
1994   /* Create a filename symbol if we are supposed to.  */
1995   if (info->create_object_symbols_section != (asection *) NULL)
1996     {
1997       asection *sec;
1998
1999       for (sec = input_bfd->sections;
2000            sec != (asection *) NULL;
2001            sec = sec->next)
2002         {
2003           if (sec->output_section == info->create_object_symbols_section)
2004             {
2005               asymbol *newsym;
2006
2007               newsym = bfd_make_empty_symbol (input_bfd);
2008               if (!newsym)
2009                 return false;
2010               newsym->name = input_bfd->filename;
2011               newsym->value = 0;
2012               newsym->flags = BSF_LOCAL | BSF_FILE;
2013               newsym->section = sec;
2014
2015               if (! generic_add_output_symbol (output_bfd, psymalloc,
2016                                                newsym))
2017                 return false;
2018
2019               break;
2020             }
2021         }
2022     }
2023
2024   /* Adjust the values of the globally visible symbols, and write out
2025      local symbols.  */
2026   sym_ptr = _bfd_generic_link_get_symbols (input_bfd);
2027   sym_end = sym_ptr + _bfd_generic_link_get_symcount (input_bfd);
2028   for (; sym_ptr < sym_end; sym_ptr++)
2029     {
2030       asymbol *sym;
2031       struct generic_link_hash_entry *h;
2032       boolean output;
2033
2034       h = (struct generic_link_hash_entry *) NULL;
2035       sym = *sym_ptr;
2036       if ((sym->flags & (BSF_INDIRECT
2037                          | BSF_WARNING
2038                          | BSF_GLOBAL
2039                          | BSF_CONSTRUCTOR
2040                          | BSF_WEAK)) != 0
2041           || bfd_is_und_section (bfd_get_section (sym))
2042           || bfd_is_com_section (bfd_get_section (sym))
2043           || bfd_is_ind_section (bfd_get_section (sym)))
2044         {
2045           if (sym->udata.p != NULL)
2046             h = (struct generic_link_hash_entry *) sym->udata.p;
2047           else if ((sym->flags & BSF_CONSTRUCTOR) != 0)
2048             {
2049               /* This case normally means that the main linker code
2050                  deliberately ignored this constructor symbol.  We
2051                  should just pass it through.  This will screw up if
2052                  the constructor symbol is from a different,
2053                  non-generic, object file format, but the case will
2054                  only arise when linking with -r, which will probably
2055                  fail anyhow, since there will be no way to represent
2056                  the relocs in the output format being used.  */
2057               h = NULL;
2058             }
2059           else
2060             h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
2061                                                bfd_asymbol_name (sym),
2062                                                false, false, true);
2063
2064           if (h != (struct generic_link_hash_entry *) NULL)
2065             {
2066               /* Force all references to this symbol to point to
2067                  the same area in memory.  It is possible that
2068                  this routine will be called with a hash table
2069                  other than a generic hash table, so we double
2070                  check that.  */
2071               if (info->hash->creator == input_bfd->xvec)
2072                 {
2073                   if (h->sym != (asymbol *) NULL)
2074                     *sym_ptr = sym = h->sym;
2075                 }
2076
2077               switch (h->root.type)
2078                 {
2079                 default:
2080                 case bfd_link_hash_new:
2081                   abort ();
2082                 case bfd_link_hash_undefined:
2083                   break;
2084                 case bfd_link_hash_undefweak:
2085                   sym->flags |= BSF_WEAK;
2086                   break;
2087                 case bfd_link_hash_indirect:
2088                   h = (struct generic_link_hash_entry *) h->root.u.i.link;
2089                   /* fall through */
2090                 case bfd_link_hash_defined:
2091                   sym->flags |= BSF_GLOBAL;
2092                   sym->flags &=~ BSF_CONSTRUCTOR;
2093                   sym->value = h->root.u.def.value;
2094                   sym->section = h->root.u.def.section;
2095                   break;
2096                 case bfd_link_hash_defweak:
2097                   sym->flags |= BSF_WEAK;
2098                   sym->flags &=~ BSF_CONSTRUCTOR;
2099                   sym->value = h->root.u.def.value;
2100                   sym->section = h->root.u.def.section;
2101                   break;
2102                 case bfd_link_hash_common:
2103                   sym->value = h->root.u.c.size;
2104                   sym->flags |= BSF_GLOBAL;
2105                   if (! bfd_is_com_section (sym->section))
2106                     {
2107                       BFD_ASSERT (bfd_is_und_section (sym->section));
2108                       sym->section = bfd_com_section_ptr;
2109                     }
2110                   /* We do not set the section of the symbol to
2111                      h->root.u.c.p->section.  That value was saved so
2112                      that we would know where to allocate the symbol
2113                      if it was defined.  In this case the type is
2114                      still bfd_link_hash_common, so we did not define
2115                      it, so we do not want to use that section.  */
2116                   break;
2117                 }
2118             }
2119         }
2120
2121       /* This switch is straight from the old code in
2122          write_file_locals in ldsym.c.  */
2123       if (info->strip == strip_some
2124           && (bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym),
2125                                false, false)
2126               == (struct bfd_hash_entry *) NULL))
2127         output = false;
2128       else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
2129         {
2130           /* If this symbol is marked as occurring now, rather
2131              than at the end, output it now.  This is used for
2132              COFF C_EXT FCN symbols.  FIXME: There must be a
2133              better way.  */
2134           if (bfd_asymbol_bfd (sym) == input_bfd
2135               && (sym->flags & BSF_NOT_AT_END) != 0)
2136             output = true;
2137           else
2138             output = false;
2139         }
2140       else if (bfd_is_ind_section (sym->section))
2141         output = false;
2142       else if ((sym->flags & BSF_DEBUGGING) != 0)
2143         {
2144           if (info->strip == strip_none)
2145             output = true;
2146           else
2147             output = false;
2148         }
2149       else if (bfd_is_und_section (sym->section)
2150                || bfd_is_com_section (sym->section))
2151         output = false;
2152       else if ((sym->flags & BSF_LOCAL) != 0)
2153         {
2154           if ((sym->flags & BSF_WARNING) != 0)
2155             output = false;
2156           else
2157             {
2158               switch (info->discard)
2159                 {
2160                 default:
2161                 case discard_all:
2162                   output = false;
2163                   break;
2164                 case discard_l:
2165                   if (bfd_asymbol_name (sym)[0] == info->lprefix[0]
2166                       && (info->lprefix_len == 1
2167                           || strncmp (bfd_asymbol_name (sym), info->lprefix,
2168                                       info->lprefix_len) == 0))
2169                     output = false;
2170                   else
2171                     output = true;
2172                   break;
2173                 case discard_none:
2174                   output = true;
2175                   break;
2176                 }
2177             }
2178         }
2179       else if ((sym->flags & BSF_CONSTRUCTOR))
2180         {
2181           if (info->strip != strip_all)
2182             output = true;
2183           else
2184             output = false;
2185         }
2186       else
2187         abort ();
2188
2189       if (output)
2190         {
2191           if (! generic_add_output_symbol (output_bfd, psymalloc, sym))
2192             return false;
2193           if (h != (struct generic_link_hash_entry *) NULL)
2194             h->written = true;
2195         }
2196     }
2197
2198   return true;
2199 }
2200
2201 /* Set the section and value of a generic BFD symbol based on a linker
2202    hash table entry.  */
2203
2204 static void
2205 set_symbol_from_hash (sym, h)
2206      asymbol *sym;
2207      struct bfd_link_hash_entry *h;
2208 {
2209   switch (h->type)
2210     {
2211     default:
2212     case bfd_link_hash_new:
2213       abort ();
2214     case bfd_link_hash_undefined:
2215       sym->section = bfd_und_section_ptr;
2216       sym->value = 0;
2217       break;
2218     case bfd_link_hash_undefweak:
2219       sym->section = bfd_und_section_ptr;
2220       sym->value = 0;
2221       sym->flags |= BSF_WEAK;
2222       break;
2223     case bfd_link_hash_defined:
2224       sym->section = h->u.def.section;
2225       sym->value = h->u.def.value;
2226       break;
2227     case bfd_link_hash_defweak:
2228       sym->flags |= BSF_WEAK;
2229       sym->section = h->u.def.section;
2230       sym->value = h->u.def.value;
2231       break;
2232     case bfd_link_hash_common:
2233       sym->value = h->u.c.size;
2234       if (sym->section == NULL)
2235         sym->section = bfd_com_section_ptr;
2236       else if (! bfd_is_com_section (sym->section))
2237         {
2238           BFD_ASSERT (bfd_is_und_section (sym->section));
2239           sym->section = bfd_com_section_ptr;
2240         }
2241       /* Do not set the section; see _bfd_generic_link_output_symbols.  */
2242       break;
2243     case bfd_link_hash_indirect:
2244     case bfd_link_hash_warning:
2245       /* FIXME: What should we do here?  */
2246       break;
2247     }
2248 }
2249
2250 /* Write out a global symbol, if it hasn't already been written out.
2251    This is called for each symbol in the hash table.  */
2252
2253 boolean
2254 _bfd_generic_link_write_global_symbol (h, data)
2255      struct generic_link_hash_entry *h;
2256      PTR data;
2257 {
2258   struct generic_write_global_symbol_info *wginfo =
2259     (struct generic_write_global_symbol_info *) data;
2260   asymbol *sym;
2261
2262   if (h->written)
2263     return true;
2264
2265   h->written = true;
2266
2267   if (wginfo->info->strip == strip_all
2268       || (wginfo->info->strip == strip_some
2269           && bfd_hash_lookup (wginfo->info->keep_hash, h->root.root.string,
2270                               false, false) == NULL))
2271     return true;
2272
2273   if (h->sym != (asymbol *) NULL)
2274     {
2275       sym = h->sym;
2276       BFD_ASSERT (strcmp (bfd_asymbol_name (sym), h->root.root.string) == 0);
2277     }
2278   else
2279     {
2280       sym = bfd_make_empty_symbol (wginfo->output_bfd);
2281       if (!sym)
2282         return false;
2283       sym->name = h->root.root.string;
2284       sym->flags = 0;
2285     }
2286
2287   set_symbol_from_hash (sym, &h->root);
2288
2289   sym->flags |= BSF_GLOBAL;
2290
2291   if (! generic_add_output_symbol (wginfo->output_bfd, wginfo->psymalloc,
2292                                    sym))
2293     {
2294       /* FIXME: No way to return failure.  */
2295       abort ();
2296     }
2297
2298   return true;
2299 }
2300
2301 /* Create a relocation.  */
2302
2303 boolean
2304 _bfd_generic_reloc_link_order (abfd, info, sec, link_order)
2305      bfd *abfd;
2306      struct bfd_link_info *info;
2307      asection *sec;
2308      struct bfd_link_order *link_order;
2309 {
2310   arelent *r;
2311
2312   if (! info->relocateable)
2313     abort ();
2314   if (sec->orelocation == (arelent **) NULL)
2315     abort ();
2316
2317   r = (arelent *) bfd_alloc (abfd, sizeof (arelent));
2318   if (r == (arelent *) NULL)
2319     {
2320       bfd_set_error (bfd_error_no_memory);
2321       return false;
2322     }
2323
2324   r->address = link_order->offset;
2325   r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc);
2326   if (r->howto == 0)
2327     {
2328       bfd_set_error (bfd_error_bad_value);
2329       return false;
2330     }
2331
2332   /* Get the symbol to use for the relocation.  */
2333   if (link_order->type == bfd_section_reloc_link_order)
2334     r->sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
2335   else
2336     {
2337       struct generic_link_hash_entry *h;
2338
2339       h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
2340                                          link_order->u.reloc.p->u.name,
2341                                          false, false, true);
2342       if (h == (struct generic_link_hash_entry *) NULL
2343           || ! h->written)
2344         {
2345           if (! ((*info->callbacks->unattached_reloc)
2346                  (info, link_order->u.reloc.p->u.name,
2347                   (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2348             return false;
2349           bfd_set_error (bfd_error_bad_value);
2350           return false;
2351         }
2352       r->sym_ptr_ptr = &h->sym;
2353     }
2354
2355   /* If this is an inplace reloc, write the addend to the object file.
2356      Otherwise, store it in the reloc addend.  */
2357   if (! r->howto->partial_inplace)
2358     r->addend = link_order->u.reloc.p->addend;
2359   else
2360     {
2361       bfd_size_type size;
2362       bfd_reloc_status_type rstat;
2363       bfd_byte *buf;
2364       boolean ok;
2365
2366       size = bfd_get_reloc_size (r->howto);
2367       buf = (bfd_byte *) bfd_zmalloc (size);
2368       if (buf == (bfd_byte *) NULL)
2369         {
2370           bfd_set_error (bfd_error_no_memory);
2371           return false;
2372         }
2373       rstat = _bfd_relocate_contents (r->howto, abfd,
2374                                       link_order->u.reloc.p->addend, buf);
2375       switch (rstat)
2376         {
2377         case bfd_reloc_ok:
2378           break;
2379         default:
2380         case bfd_reloc_outofrange:
2381           abort ();
2382         case bfd_reloc_overflow:
2383           if (! ((*info->callbacks->reloc_overflow)
2384                  (info,
2385                   (link_order->type == bfd_section_reloc_link_order
2386                    ? bfd_section_name (abfd, link_order->u.reloc.p->u.section)
2387                    : link_order->u.reloc.p->u.name),
2388                   r->howto->name, link_order->u.reloc.p->addend,
2389                   (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2390             {
2391               free (buf);
2392               return false;
2393             }
2394           break;
2395         }
2396       ok = bfd_set_section_contents (abfd, sec, (PTR) buf,
2397                                      (file_ptr) link_order->offset, size);
2398       free (buf);
2399       if (! ok)
2400         return false;
2401
2402       r->addend = 0;
2403     }
2404
2405   sec->orelocation[sec->reloc_count] = r;
2406   ++sec->reloc_count;
2407
2408   return true;
2409 }
2410 \f
2411 /* Allocate a new link_order for a section.  */
2412
2413 struct bfd_link_order *
2414 bfd_new_link_order (abfd, section)
2415      bfd *abfd;
2416      asection *section;
2417 {
2418   struct bfd_link_order *new;
2419
2420   new = ((struct bfd_link_order *)
2421          bfd_alloc_by_size_t (abfd, sizeof (struct bfd_link_order)));
2422   if (!new)
2423     {
2424       bfd_set_error (bfd_error_no_memory);
2425       return NULL;
2426     }
2427
2428   new->type = bfd_undefined_link_order;
2429   new->offset = 0;
2430   new->size = 0;
2431   new->next = (struct bfd_link_order *) NULL;
2432
2433   if (section->link_order_tail != (struct bfd_link_order *) NULL)
2434     section->link_order_tail->next = new;
2435   else
2436     section->link_order_head = new;
2437   section->link_order_tail = new;
2438
2439   return new;
2440 }
2441
2442 /* Default link order processing routine.  Note that we can not handle
2443    the reloc_link_order types here, since they depend upon the details
2444    of how the particular backends generates relocs.  */
2445
2446 boolean
2447 _bfd_default_link_order (abfd, info, sec, link_order)
2448      bfd *abfd;
2449      struct bfd_link_info *info;
2450      asection *sec;
2451      struct bfd_link_order *link_order;
2452 {
2453   switch (link_order->type)
2454     {
2455     case bfd_undefined_link_order:
2456     case bfd_section_reloc_link_order:
2457     case bfd_symbol_reloc_link_order:
2458     default:
2459       abort ();
2460     case bfd_indirect_link_order:
2461       return default_indirect_link_order (abfd, info, sec, link_order,
2462                                           false);
2463     case bfd_fill_link_order:
2464       return default_fill_link_order (abfd, info, sec, link_order);
2465     case bfd_data_link_order:
2466       return bfd_set_section_contents (abfd, sec,
2467                                        (PTR) link_order->u.data.contents,
2468                                        (file_ptr) link_order->offset,
2469                                        link_order->size);
2470     }
2471 }
2472
2473 /* Default routine to handle a bfd_fill_link_order.  */
2474
2475 /*ARGSUSED*/
2476 static boolean
2477 default_fill_link_order (abfd, info, sec, link_order)
2478      bfd *abfd;
2479      struct bfd_link_info *info;
2480      asection *sec;
2481      struct bfd_link_order *link_order;
2482 {
2483   size_t size;
2484   char *space;
2485   size_t i;
2486   int fill;
2487   boolean result;
2488
2489   BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0);
2490
2491   size = (size_t) link_order->size;
2492   space = (char *) malloc (size);
2493   if (space == NULL && size != 0)
2494     {
2495       bfd_set_error (bfd_error_no_memory);
2496       return false;
2497     }
2498
2499   fill = link_order->u.fill.value;
2500   for (i = 0; i < size; i += 2)
2501     space[i] = fill >> 8;
2502   for (i = 1; i < size; i += 2)
2503     space[i] = fill;
2504   result = bfd_set_section_contents (abfd, sec, space,
2505                                      (file_ptr) link_order->offset,
2506                                      link_order->size);
2507   free (space);
2508   return result;
2509 }
2510
2511 /* Default routine to handle a bfd_indirect_link_order.  */
2512
2513 static boolean
2514 default_indirect_link_order (output_bfd, info, output_section, link_order,
2515                              generic_linker)
2516      bfd *output_bfd;
2517      struct bfd_link_info *info;
2518      asection *output_section;
2519      struct bfd_link_order *link_order;
2520      boolean generic_linker;
2521 {
2522   asection *input_section;
2523   bfd *input_bfd;
2524   bfd_byte *contents = NULL;
2525   bfd_byte *new_contents;
2526
2527   BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
2528
2529   if (link_order->size == 0)
2530     return true;
2531
2532   input_section = link_order->u.indirect.section;
2533   input_bfd = input_section->owner;
2534
2535   BFD_ASSERT (input_section->output_section == output_section);
2536   BFD_ASSERT (input_section->output_offset == link_order->offset);
2537   BFD_ASSERT (input_section->_cooked_size == link_order->size);
2538
2539   if (info->relocateable
2540       && input_section->reloc_count > 0
2541       && output_section->orelocation == (arelent **) NULL)
2542     {
2543       /* Space has not been allocated for the output relocations.
2544          This can happen when we are called by a specific backend
2545          because somebody is attempting to link together different
2546          types of object files.  Handling this case correctly is
2547          difficult, and sometimes impossible.  */
2548       abort ();
2549     }
2550
2551   if (! generic_linker)
2552     {
2553       asymbol **sympp;
2554       asymbol **symppend;
2555
2556       /* Get the canonical symbols.  The generic linker will always
2557          have retrieved them by this point, but we are being called by
2558          a specific linker, presumably because we are linking
2559          different types of object files together.  */
2560       if (! generic_link_read_symbols (input_bfd))
2561         return false;
2562
2563       /* Since we have been called by a specific linker, rather than
2564          the generic linker, the values of the symbols will not be
2565          right.  They will be the values as seen in the input file,
2566          not the values of the final link.  We need to fix them up
2567          before we can relocate the section.  */
2568       sympp = _bfd_generic_link_get_symbols (input_bfd);
2569       symppend = sympp + _bfd_generic_link_get_symcount (input_bfd);
2570       for (; sympp < symppend; sympp++)
2571         {
2572           asymbol *sym;
2573           struct bfd_link_hash_entry *h;
2574
2575           sym = *sympp;
2576
2577           if ((sym->flags & (BSF_INDIRECT
2578                              | BSF_WARNING
2579                              | BSF_GLOBAL
2580                              | BSF_CONSTRUCTOR
2581                              | BSF_WEAK)) != 0
2582               || bfd_is_und_section (bfd_get_section (sym))
2583               || bfd_is_com_section (bfd_get_section (sym))
2584               || bfd_is_ind_section (bfd_get_section (sym)))
2585             {
2586               /* sym->udata may have been set by
2587                  generic_link_add_symbol_list.  */
2588               if (sym->udata.p != NULL)
2589                 h = (struct bfd_link_hash_entry *) sym->udata.p;
2590               else
2591                 h = bfd_link_hash_lookup (info->hash,
2592                                           bfd_asymbol_name (sym),
2593                                           false, false, true);
2594               if (h != NULL)
2595                 set_symbol_from_hash (sym, h);
2596             }
2597         }
2598     }
2599
2600   /* Get and relocate the section contents.  */
2601   contents = (bfd_byte *) malloc (bfd_section_size (input_bfd, input_section));
2602   if (contents == NULL && bfd_section_size (input_bfd, input_section) != 0)
2603     {
2604       bfd_set_error (bfd_error_no_memory);
2605       goto error_return;
2606     }
2607   new_contents = (bfd_get_relocated_section_contents
2608                   (output_bfd, info, link_order, contents, info->relocateable,
2609                    _bfd_generic_link_get_symbols (input_bfd)));
2610   if (!new_contents)
2611     goto error_return;
2612
2613   /* Output the section contents.  */
2614   if (! bfd_set_section_contents (output_bfd, output_section,
2615                                   (PTR) new_contents,
2616                                   link_order->offset, link_order->size))
2617     goto error_return;
2618
2619   if (contents != NULL)
2620     free (contents);
2621   return true;
2622
2623  error_return:
2624   if (contents != NULL)
2625     free (contents);
2626   return false;
2627 }
2628
2629 /* A little routine to count the number of relocs in a link_order
2630    list.  */
2631
2632 unsigned int
2633 _bfd_count_link_order_relocs (link_order)
2634      struct bfd_link_order *link_order;
2635 {
2636   register unsigned int c;
2637   register struct bfd_link_order *l;
2638
2639   c = 0;
2640   for (l = link_order; l != (struct bfd_link_order *) NULL; l = l->next)
2641     {
2642       if (l->type == bfd_section_reloc_link_order
2643           || l->type == bfd_symbol_reloc_link_order)
2644         ++c;
2645     }
2646
2647   return c;
2648 }
2649
2650 /*
2651 FUNCTION
2652         bfd_link_split_section
2653
2654 SYNOPSIS
2655         boolean bfd_link_split_section(bfd *abfd, asection *sec);
2656
2657 DESCRIPTION
2658         Return nonzero if @var{sec} should be split during a
2659         reloceatable or final link.
2660
2661 .#define bfd_link_split_section(abfd, sec) \
2662 .       BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
2663 .
2664
2665 */
2666
2667
2668
2669 boolean
2670 _bfd_generic_link_split_section (abfd, sec)
2671      bfd *abfd;
2672      asection *sec;
2673 {
2674   return false;
2675 }