bfd/linker.c

   1 /* linker.c -- BFD linker routines
   2    Copyright (C) 1993, 94 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., 675 Mass Ave, Cambridge, MA 02139, 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>> for an undefined
 196         symbol or <<bfd_com_section>> 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.  The <<written>> field in the
 384         <<bfd_link_hash_entry>> structure may be used to determine
 385         which entries in the hash table have not already been written
 386         out.
 387
 388         The <<strip>> field of the <<bfd_link_info>> structure
 389         controls which symbols are written out.  The possible values
 390         are listed in <<bfdlink.h>>.  If the value is <<strip_some>>,
 391         then the <<keep_hash>> field of the <<bfd_link_info>>
 392         structure is a hash table of symbols to keep; each symbol
 393         should be looked up in this hash table, and only symbols which
 394         are present should be included in the output file.
 395
 396         If the <<strip>> field of the <<bfd_link_info>> structure
 397         permits local symbols to be written out, the <<discard>> field
 398         is used to further controls which local symbols are included
 399         in the output file.  If the value is <<discard_l>>, then all
 400         local symbols which begin with a certain prefix are discarded;
 401         this prefix is described by the <<lprefix>> and
 402         <<lprefix_len>> fields of the <<bfd_link_info>> structure.
 403
 404         The a.out backend handles symbols by calling
 405         <<aout_link_write_symbols>> on each input BFD and then
 406         traversing the global hash table with the function
 407         <<aout_link_write_other_symbol>>.  It builds a string table
 408         while writing out the symbols, which is written to the output
 409         file at the end of <<NAME(aout,final_link)>>.
 410 */
 411
 412 static struct bfd_hash_entry *generic_link_hash_newfunc
 413   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
 414            const char *));
 415 static boolean generic_link_add_symbols
 416   PARAMS ((bfd *, struct bfd_link_info *, boolean collect));
 417 static boolean generic_link_add_object_symbols
 418   PARAMS ((bfd *, struct bfd_link_info *, boolean collect));
 419 static boolean generic_link_check_archive_element_no_collect
 420   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
 421 static boolean generic_link_check_archive_element_collect
 422   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
 423 static boolean generic_link_check_archive_element
 424   PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded, boolean collect));
 425 static boolean generic_link_add_symbol_list
 426   PARAMS ((bfd *, struct bfd_link_info *, bfd_size_type count, asymbol **,
 427            boolean collect));
 428 static boolean generic_add_output_symbol
 429   PARAMS ((bfd *, size_t *psymalloc, asymbol *));
 430 static boolean default_fill_link_order
 431   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 432            struct bfd_link_order *));
 433 static boolean default_indirect_link_order
 434   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 435            struct bfd_link_order *));
 436
 437 /* The link hash table structure is defined in bfdlink.h.  It provides
 438    a base hash table which the backend specific hash tables are built
 439    upon.  */
 440
 441 /* Routine to create an entry in the link hash table.  */
 442
 443 struct bfd_hash_entry *
 444 _bfd_link_hash_newfunc (entry, table, string)
 445      struct bfd_hash_entry *entry;
 446      struct bfd_hash_table *table;
 447      const char *string;
 448 {
 449   struct bfd_link_hash_entry *ret = (struct bfd_link_hash_entry *) entry;
 450
 451   /* Allocate the structure if it has not already been allocated by a
 452      subclass.  */
 453   if (ret == (struct bfd_link_hash_entry *) NULL)
 454     ret = ((struct bfd_link_hash_entry *)
 455            bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry)));
 456   if (ret == (struct bfd_link_hash_entry *) NULL)
 457     {
 458       bfd_set_error (bfd_error_no_memory);
 459       return NULL;
 460     }
 461
 462   /* Call the allocation method of the superclass.  */
 463   ret = ((struct bfd_link_hash_entry *)
 464          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 465
 466   if (ret)
 467     {
 468       /* Initialize the local fields.  */
 469       ret->type = bfd_link_hash_new;
 470       ret->written = false;
 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->sym = NULL;
 585     }
 586
 587   return (struct bfd_hash_entry *) ret;
 588 }
 589
 590 /* Create an generic link hash table.  */
 591
 592 struct bfd_link_hash_table *
 593 _bfd_generic_link_hash_table_create (abfd)
 594      bfd *abfd;
 595 {
 596   struct generic_link_hash_table *ret;
 597
 598   ret = ((struct generic_link_hash_table *)
 599          malloc (sizeof (struct generic_link_hash_table)));
 600   if (!ret)
 601       {
 602         bfd_set_error (bfd_error_no_memory);
 603         return (struct bfd_link_hash_table *) NULL;
 604       }
 605   if (! _bfd_link_hash_table_init (&ret->root, abfd,
 606                                    generic_link_hash_newfunc))
 607     {
 608       free (ret);
 609       return (struct bfd_link_hash_table *) NULL;
 610     }
 611   return &ret->root;
 612 }
 613 \f
 614 /* Generic function to add symbols to from an object file to the
 615    global hash table.  This version does not automatically collect
 616    constructors by name.  */
 617
 618 boolean
 619 _bfd_generic_link_add_symbols (abfd, info)
 620      bfd *abfd;
 621      struct bfd_link_info *info;
 622 {
 623   return generic_link_add_symbols (abfd, info, false);
 624 }
 625
 626 /* Generic function to add symbols from an object file to the global
 627    hash table.  This version automatically collects constructors by
 628    name, as the collect2 program does.  It should be used for any
 629    target which does not provide some other mechanism for setting up
 630    constructors and destructors; these are approximately those targets
 631    for which gcc uses collect2 and do not support stabs.  */
 632
 633 boolean
 634 _bfd_generic_link_add_symbols_collect (abfd, info)
 635      bfd *abfd;
 636      struct bfd_link_info *info;
 637 {
 638   return generic_link_add_symbols (abfd, info, true);
 639 }
 640
 641 /* Add symbols from an object file to the global hash table.  */
 642
 643 static boolean
 644 generic_link_add_symbols (abfd, info, collect)
 645      bfd *abfd;
 646      struct bfd_link_info *info;
 647      boolean collect;
 648 {
 649   boolean ret;
 650
 651   switch (bfd_get_format (abfd))
 652     {
 653     case bfd_object:
 654       ret = generic_link_add_object_symbols (abfd, info, collect);
 655       break;
 656     case bfd_archive:
 657       ret = (_bfd_generic_link_add_archive_symbols
 658              (abfd, info,
 659               (collect
 660                ? generic_link_check_archive_element_collect
 661                : generic_link_check_archive_element_no_collect)));
 662       break;
 663     default:
 664       bfd_set_error (bfd_error_wrong_format);
 665       ret = false;
 666     }
 667
 668   return ret;
 669 }
 670
 671 /* Add symbols from an object file to the global hash table.  */
 672
 673 static boolean
 674 generic_link_add_object_symbols (abfd, info, collect)
 675      bfd *abfd;
 676      struct bfd_link_info *info;
 677      boolean collect;
 678 {
 679   size_t symsize;
 680   asymbol **symbols;
 681   bfd_size_type symbol_count;
 682   boolean result;
 683
 684   symsize = get_symtab_upper_bound (abfd);
 685   symbols = (asymbol **) malloc (symsize);
 686   if (symbols == NULL && symsize != 0)
 687     {
 688       bfd_set_error (bfd_error_no_memory);
 689       return false;
 690     }
 691   symbol_count = bfd_canonicalize_symtab (abfd, symbols);
 692
 693   result = generic_link_add_symbol_list (abfd, info, symbol_count, symbols,
 694                                          collect);
 695   free (symbols);
 696   return result;
 697 }
 698 \f
 699 /* We build a hash table of all symbols defined in an archive.  */
 700
 701 /* An archive symbol may be defined by multiple archive elements.
 702    This linked list is used to hold the elements.  */
 703
 704 struct archive_list
 705 {
 706   struct archive_list *next;
 707   int indx;
 708 };
 709
 710 /* An entry in an archive hash table.  */
 711
 712 struct archive_hash_entry
 713 {
 714   struct bfd_hash_entry root;
 715   /* Where the symbol is defined.  */
 716   struct archive_list *defs;
 717 };
 718
 719 /* An archive hash table itself.  */
 720
 721 struct archive_hash_table
 722 {
 723   struct bfd_hash_table table;
 724 };
 725
 726 static struct bfd_hash_entry *archive_hash_newfunc
 727   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 728 static boolean archive_hash_table_init
 729   PARAMS ((struct archive_hash_table *,
 730            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 731                                        struct bfd_hash_table *,
 732                                        const char *)));
 733
 734 /* Create a new entry for an archive hash table.  */
 735
 736 static struct bfd_hash_entry *
 737 archive_hash_newfunc (entry, table, string)
 738      struct bfd_hash_entry *entry;
 739      struct bfd_hash_table *table;
 740      const char *string;
 741 {
 742   struct archive_hash_entry *ret = (struct archive_hash_entry *) entry;
 743
 744   /* Allocate the structure if it has not already been allocated by a
 745      subclass.  */
 746   if (ret == (struct archive_hash_entry *) NULL)
 747     ret = ((struct archive_hash_entry *)
 748            bfd_hash_allocate (table, sizeof (struct archive_hash_entry)));
 749   if (ret == (struct archive_hash_entry *) NULL)
 750     {
 751       bfd_set_error (bfd_error_no_memory);
 752       return NULL;
 753     }
 754
 755   /* Call the allocation method of the superclass.  */
 756   ret = ((struct archive_hash_entry *)
 757          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 758
 759   if (ret)
 760     {
 761       /* Initialize the local fields.  */
 762       ret->defs = (struct archive_list *) NULL;
 763     }
 764
 765   return (struct bfd_hash_entry *) ret;
 766 }
 767
 768 /* Initialize an archive hash table.  */
 769
 770 static boolean
 771 archive_hash_table_init (table, newfunc)
 772      struct archive_hash_table *table;
 773      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 774                                                 struct bfd_hash_table *,
 775                                                 const char *));
 776 {
 777   return bfd_hash_table_init (&table->table, newfunc);
 778 }
 779
 780 /* Look up an entry in an archive hash table.  */
 781
 782 #define archive_hash_lookup(t, string, create, copy) \
 783   ((struct archive_hash_entry *) \
 784    bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
 785
 786 /* Free an archive hash table.  */
 787
 788 #define archive_hash_table_free(t) bfd_hash_table_free (&(t)->table)
 789
 790 /* Generic function to add symbols from an archive file to the global
 791    hash file.  This function presumes that the archive symbol table
 792    has already been read in (this is normally done by the
 793    bfd_check_format entry point).  It looks through the undefined and
 794    common symbols and searches the archive symbol table for them.  If
 795    it finds an entry, it includes the associated object file in the
 796    link.
 797
 798    The old linker looked through the archive symbol table for
 799    undefined symbols.  We do it the other way around, looking through
 800    undefined symbols for symbols defined in the archive.  The
 801    advantage of the newer scheme is that we only have to look through
 802    the list of undefined symbols once, whereas the old method had to
 803    re-search the symbol table each time a new object file was added.
 804
 805    The CHECKFN argument is used to see if an object file should be
 806    included.  CHECKFN should set *PNEEDED to true if the object file
 807    should be included, and must also call the bfd_link_info
 808    add_archive_element callback function and handle adding the symbols
 809    to the global hash table.  CHECKFN should only return false if some
 810    sort of error occurs.
 811
 812    For some formats, such as a.out, it is possible to look through an
 813    object file but not actually include it in the link.  The
 814    archive_pass field in a BFD is used to avoid checking the symbols
 815    of an object files too many times.  When an object is included in
 816    the link, archive_pass is set to -1.  If an object is scanned but
 817    not included, archive_pass is set to the pass number.  The pass
 818    number is incremented each time a new object file is included.  The
 819    pass number is used because when a new object file is included it
 820    may create new undefined symbols which cause a previously examined
 821    object file to be included.  */
 822
 823 boolean
 824 _bfd_generic_link_add_archive_symbols (abfd, info, checkfn)
 825      bfd *abfd;
 826      struct bfd_link_info *info;
 827      boolean (*checkfn) PARAMS ((bfd *, struct bfd_link_info *,
 828                                  boolean *pneeded));
 829 {
 830   carsym *arsyms;
 831   carsym *arsym_end;
 832   register carsym *arsym;
 833   int pass;
 834   struct archive_hash_table arsym_hash;
 835   int indx;
 836   struct bfd_link_hash_entry **pundef;
 837
 838   if (! bfd_has_map (abfd))
 839     {
 840       bfd_set_error (bfd_error_no_symbols);
 841       return false;
 842     }
 843
 844   arsyms = bfd_ardata (abfd)->symdefs;
 845   arsym_end = arsyms + bfd_ardata (abfd)->symdef_count;
 846
 847   /* In order to quickly determine whether an symbol is defined in
 848      this archive, we build a hash table of the symbols.  */
 849   if (! archive_hash_table_init (&arsym_hash, archive_hash_newfunc))
 850     return false;
 851   for (arsym = arsyms, indx = 0; arsym < arsym_end; arsym++, indx++)
 852     {
 853       struct archive_hash_entry *arh;
 854       struct archive_list *l, **pp;
 855
 856       arh = archive_hash_lookup (&arsym_hash, arsym->name, true, false);
 857       if (arh == (struct archive_hash_entry *) NULL)
 858         goto error_return;
 859       l = (struct archive_list *)
 860         obstack_alloc (&(&(&arsym_hash)->table)->memory,
 861                        sizeof (struct archive_list));
 862       if (l == NULL)
 863         {
 864           bfd_set_error (bfd_error_no_memory);
 865           goto error_return;
 866         }
 867       l->indx = indx;
 868       for (pp = &arh->defs;
 869            *pp != (struct archive_list *) NULL;
 870            pp = &(*pp)->next)
 871         ;
 872       *pp = l;
 873       l->next = NULL;
 874     }
 875
 876   pass = 1;
 877
 878   /* New undefined symbols are added to the end of the list, so we
 879      only need to look through it once.  */
 880   pundef = &info->hash->undefs;
 881   while (*pundef != (struct bfd_link_hash_entry *) NULL)
 882     {
 883       struct bfd_link_hash_entry *h;
 884       struct archive_hash_entry *arh;
 885       struct archive_list *l;
 886
 887       h = *pundef;
 888
 889       /* When a symbol is defined, it is not necessarily removed from
 890          the list.  */
 891       if (h->type != bfd_link_hash_undefined
 892           && h->type != bfd_link_hash_common)
 893         {
 894           /* Remove this entry from the list, for general cleanliness
 895              and because we are going to look through the list again
 896              if we search any more libraries.  We can't remove the
 897              entry if it is the tail, because that would lose any
 898              entries we add to the list later on.  */
 899           if (*pundef != info->hash->undefs_tail)
 900             *pundef = (*pundef)->next;
 901           else
 902             pundef = &(*pundef)->next;
 903           continue;
 904         }
 905
 906       /* Look for this symbol in the archive symbol map.  */
 907       arh = archive_hash_lookup (&arsym_hash, h->root.string, false, false);
 908       if (arh == (struct archive_hash_entry *) NULL)
 909         {
 910           pundef = &(*pundef)->next;
 911           continue;
 912         }
 913
 914       /* Look at all the objects which define this symbol.  */
 915       for (l = arh->defs; l != (struct archive_list *) NULL; l = l->next)
 916         {
 917           bfd *element;
 918           boolean needed;
 919
 920           /* If the symbol has gotten defined along the way, quit.  */
 921           if (h->type != bfd_link_hash_undefined
 922               && h->type != bfd_link_hash_common)
 923             break;
 924
 925           element = bfd_get_elt_at_index (abfd, l->indx);
 926           if (element == (bfd *) NULL)
 927             goto error_return;
 928
 929           /* If we've already included this element, or if we've
 930              already checked it on this pass, continue.  */
 931           if (element->archive_pass == -1
 932               || element->archive_pass == pass)
 933             continue;
 934
 935           /* If we can't figure this element out, just ignore it.  */
 936           if (! bfd_check_format (element, bfd_object))
 937             {
 938               element->archive_pass = -1;
 939               continue;
 940             }
 941
 942           /* CHECKFN will see if this element should be included, and
 943              go ahead and include it if appropriate.  */
 944           if (! (*checkfn) (element, info, &needed))
 945             goto error_return;
 946
 947           if (! needed)
 948             element->archive_pass = pass;
 949           else
 950             {
 951               element->archive_pass = -1;
 952
 953               /* Increment the pass count to show that we may need to
 954                  recheck object files which were already checked.  */
 955               ++pass;
 956             }
 957         }
 958
 959       pundef = &(*pundef)->next;
 960     }
 961
 962   archive_hash_table_free (&arsym_hash);
 963
 964   return true;
 965
 966  error_return:
 967   archive_hash_table_free (&arsym_hash);
 968   return false;
 969 }
 970 \f
 971 /* See if we should include an archive element.  This version is used
 972    when we do not want to automatically collect constructors based on
 973    the symbol name, presumably because we have some other mechanism
 974    for finding them.  */
 975
 976 static boolean
 977 generic_link_check_archive_element_no_collect (abfd, info, pneeded)
 978      bfd *abfd;
 979      struct bfd_link_info *info;
 980      boolean *pneeded;
 981 {
 982   return generic_link_check_archive_element (abfd, info, pneeded, false);
 983 }
 984
 985 /* See if we should include an archive element.  This version is used
 986    when we want to automatically collect constructors based on the
 987    symbol name, as collect2 does.  */
 988
 989 static boolean
 990 generic_link_check_archive_element_collect (abfd, info, pneeded)
 991      bfd *abfd;
 992      struct bfd_link_info *info;
 993      boolean *pneeded;
 994 {
 995   return generic_link_check_archive_element (abfd, info, pneeded, true);
 996 }
 997
 998 /* See if we should include an archive element.  Optionally collect
 999    constructors.  */
1000
1001 static boolean
1002 generic_link_check_archive_element (abfd, info, pneeded, collect)
1003      bfd *abfd;
1004      struct bfd_link_info *info;
1005      boolean *pneeded;
1006      boolean collect;
1007 {
1008   size_t symsize;
1009   asymbol **symbols = NULL;
1010   bfd_size_type symbol_count;
1011   asymbol **pp, **ppend;
1012
1013   *pneeded = false;
1014
1015   symsize = get_symtab_upper_bound (abfd);
1016   symbols = (asymbol **) malloc (symsize);
1017   if (symbols == NULL && symsize != 0)
1018     {
1019       bfd_set_error (bfd_error_no_memory);
1020       goto error_return;
1021     }
1022
1023   symbol_count = bfd_canonicalize_symtab (abfd, symbols);
1024
1025   pp = symbols;
1026   ppend = symbols + symbol_count;
1027   for (; pp < ppend; pp++)
1028     {
1029       asymbol *p;
1030       struct bfd_link_hash_entry *h;
1031
1032       p = *pp;
1033
1034       /* We are only interested in globally visible symbols.  */
1035       if (! bfd_is_com_section (p->section)
1036           && (p->flags & (BSF_GLOBAL | BSF_INDIRECT | BSF_WEAK)) == 0)
1037         continue;
1038
1039       /* We are only interested if we know something about this
1040          symbol, and it is undefined or common.  An undefined weak
1041          symbol (type bfd_link_hash_weak) is not considered to be a
1042          reference when pulling files out of an archive.  See the SVR4
1043          ABI, p. 4-27.  */
1044       h = bfd_link_hash_lookup (info->hash, bfd_asymbol_name (p), false,
1045                                 false, true);
1046       if (h == (struct bfd_link_hash_entry *) NULL
1047           || (h->type != bfd_link_hash_undefined
1048               && h->type != bfd_link_hash_common))
1049         continue;
1050
1051       /* P is a symbol we are looking for.  */
1052
1053       if (! bfd_is_com_section (p->section))
1054         {
1055           /* This object file defines this symbol, so pull it in.  */
1056           if (! (*info->callbacks->add_archive_element) (info, abfd,
1057                                                          bfd_asymbol_name (p)))
1058             goto error_return;
1059           if (! generic_link_add_symbol_list (abfd, info, symbol_count,
1060                                               symbols, collect))
1061             goto error_return;
1062           *pneeded = true;
1063           goto successful_return;
1064         }
1065
1066       /* P is a common symbol.  */
1067
1068       if (h->type == bfd_link_hash_undefined)
1069         {
1070           bfd *symbfd;
1071
1072           symbfd = h->u.undef.abfd;
1073           if (symbfd == (bfd *) NULL)
1074             {
1075               /* This symbol was created as undefined from outside
1076                  BFD.  We assume that we should link in the object
1077                  file.  This is for the -u option in the linker.  */
1078               if (! (*info->callbacks->add_archive_element)
1079                   (info, abfd, bfd_asymbol_name (p)))
1080                 goto error_return;
1081               *pneeded = true;
1082               goto successful_return;
1083             }
1084
1085           /* Turn the symbol into a common symbol but do not link in
1086              the object file.  This is how a.out works.  Object
1087              formats that require different semantics must implement
1088              this function differently.  This symbol is already on the
1089              undefs list.  We add the section to a common section
1090              attached to symbfd to ensure that it is in a BFD which
1091              will be linked in.  */
1092           h->type = bfd_link_hash_common;
1093           h->u.c.size = bfd_asymbol_value (p);
1094           if (p->section == &bfd_com_section)
1095             h->u.c.section = bfd_make_section_old_way (symbfd, "COMMON");
1096           else
1097             h->u.c.section = bfd_make_section_old_way (symbfd,
1098                                                        p->section->name);
1099           h->u.c.section->flags = SEC_ALLOC;
1100         }
1101       else
1102         {
1103           /* Adjust the size of the common symbol if necessary.  This
1104              is how a.out works.  Object formats that require
1105              different semantics must implement this function
1106              differently.  */
1107           if (bfd_asymbol_value (p) > h->u.c.size)
1108             h->u.c.size = bfd_asymbol_value (p);
1109         }
1110     }
1111
1112   /* This archive element is not needed.  */
1113
1114  successful_return:
1115   if (symbols != NULL)
1116     free (symbols);
1117   return true;
1118
1119  error_return:
1120   if (symbols != NULL)
1121     free (symbols);
1122   return false;
1123 }
1124
1125 /* Add the symbols from an object file to the global hash table.  ABFD
1126    is the object file.  INFO is the linker information.  SYMBOL_COUNT
1127    is the number of symbols.  SYMBOLS is the list of symbols.  COLLECT
1128    is true if constructors should be automatically collected by name
1129    as is done by collect2.  */
1130
1131 static boolean
1132 generic_link_add_symbol_list (abfd, info, symbol_count, symbols, collect)
1133      bfd *abfd;
1134      struct bfd_link_info *info;
1135      bfd_size_type symbol_count;
1136      asymbol **symbols;
1137      boolean collect;
1138 {
1139   asymbol **pp, **ppend;
1140
1141   pp = symbols;
1142   ppend = symbols + symbol_count;
1143   for (; pp < ppend; pp++)
1144     {
1145       asymbol *p;
1146
1147       p = *pp;
1148
1149       if ((p->flags & (BSF_INDIRECT
1150                        | BSF_WARNING
1151                        | BSF_GLOBAL
1152                        | BSF_CONSTRUCTOR
1153                        | BSF_WEAK)) != 0
1154           || bfd_get_section (p) == &bfd_und_section
1155           || bfd_is_com_section (bfd_get_section (p))
1156           || bfd_get_section (p) == &bfd_ind_section)
1157         {
1158           const char *name;
1159           const char *string;
1160           struct generic_link_hash_entry *h;
1161
1162           name = bfd_asymbol_name (p);
1163           if ((p->flags & BSF_INDIRECT) != 0
1164               || p->section == &bfd_ind_section)
1165             string = bfd_asymbol_name ((asymbol *) p->value);
1166           else if ((p->flags & BSF_WARNING) != 0)
1167             {
1168               /* The name of P is actually the warning string, and the
1169                  value is actually a pointer to the symbol to warn
1170                  about.  */
1171               string = name;
1172               name = bfd_asymbol_name ((asymbol *) p->value);
1173             }
1174           else
1175             string = NULL;
1176
1177           if (! (_bfd_generic_link_add_one_symbol
1178                  (info, abfd, name, p->flags, bfd_get_section (p),
1179                   p->value, string, false, collect,
1180                   (struct bfd_link_hash_entry **) &h)))
1181             return false;
1182
1183           /* Save the BFD symbol so that we don't lose any backend
1184              specific information that may be attached to it.  We only
1185              want this one if it gives more information than the
1186              existing one; we don't want to replace a defined symbol
1187              with an undefined one.  This routine may be called with a
1188              hash table other than the generic hash table, so we only
1189              do this if we are certain that the hash table is a
1190              generic one.  */
1191           if (info->hash->creator == abfd->xvec)
1192             {
1193               if (h->sym == (asymbol *) NULL
1194                   || (bfd_get_section (p) != &bfd_und_section
1195                       && (! bfd_is_com_section (bfd_get_section (p))
1196                           || (bfd_get_section (h->sym) == &bfd_und_section))))
1197                 {
1198                   h->sym = p;
1199                   /* BSF_OLD_COMMON is a hack to support COFF reloc
1200                      reading, and it should go away when the COFF
1201                      linker is switched to the new version.  */
1202                   if (bfd_is_com_section (bfd_get_section (p)))
1203                     p->flags |= BSF_OLD_COMMON;
1204                 }
1205             }
1206         }
1207     }
1208
1209   return true;
1210 }
1211 \f
1212 /* We use a state table to deal with adding symbols from an object
1213    file.  The first index into the state table describes the symbol
1214    from the object file.  The second index into the state table is the
1215    type of the symbol in the hash table.  */
1216
1217 /* The symbol from the object file is turned into one of these row
1218    values.  */
1219
1220 enum link_row
1221 {
1222   UNDEF_ROW,            /* Undefined.  */
1223   UNDEFW_ROW,           /* Weak undefined.  */
1224   DEF_ROW,              /* Defined.  */
1225   DEFW_ROW,             /* Weak defined.  */
1226   COMMON_ROW,           /* Common.  */
1227   INDR_ROW,             /* Indirect.  */
1228   WARN_ROW,             /* Warning.  */
1229   SET_ROW               /* Member of set.  */
1230 };
1231
1232 /* The actions to take in the state table.  */
1233
1234 enum link_action
1235 {
1236   FAIL,         /* Abort. */
1237   UND,          /* Mark symbol undefined.  */
1238   WEAK,         /* Mark symbol weak undefined.  */
1239   DEF,          /* Mark symbol defined.  */
1240   COM,          /* Mark symbol common.  */
1241   CREF,         /* Possibly warn about common reference to defined symbol.  */
1242   CDEF,         /* Define existing common symbol.  */
1243   NOACT,        /* No action.  */
1244   BIG,          /* Mark symbol common using largest size.  */
1245   MDEF,         /* Multiple definition error.  */
1246   IND,          /* Make indirect symbol.  */
1247   SET,          /* Add value to set.  */
1248   MWARN,        /* Make warning symbol.  */
1249   WARN,         /* Issue warning.  */
1250   CYCLE,        /* Repeat with symbol pointed to.  */
1251   WARNC         /* Issue warning and then CYCLE.  */
1252 };
1253
1254 /* The state table itself.  The first index is a link_row and the
1255    second index is a bfd_link_hash_type.  */
1256
1257 static const enum link_action link_action[8][7] =
1258 {
1259   /* current\prev    new    undef  weak   def    com    indr   warn  */
1260   /* UNDEF_ROW  */  {UND,   NOACT, NOACT, NOACT, NOACT, CYCLE, WARNC },
1261   /* UNDEFW_ROW */  {WEAK,  WEAK,  NOACT, NOACT, NOACT, CYCLE, WARNC },
1262   /* DEF_ROW    */  {DEF,   DEF,   DEF,   MDEF,  CDEF,  CYCLE, CYCLE },
1263   /* DEFW_ROW   */  {DEF,   DEF,   DEF,   NOACT, NOACT, CYCLE, CYCLE },
1264   /* COMMON_ROW */  {COM,   COM,   COM,   CREF,  BIG,   CYCLE, WARNC },
1265   /* INDR_ROW   */  {IND,   IND,   IND,   MDEF,  MDEF,  MDEF,  WARNC },
1266   /* WARN_ROW   */  {MWARN, WARN,  WARN,  MWARN, MWARN, MWARN, NOACT },
1267   /* SET_ROW    */  {SET,   SET,   SET,   SET,   SET,   CYCLE, WARNC }
1268 };
1269
1270 /* Add a symbol to the global hash table.
1271    ABFD is the BFD the symbol comes from.
1272    NAME is the name of the symbol.
1273    FLAGS is the BSF_* bits associated with the symbol.
1274    SECTION is the section in which the symbol is defined; this may be
1275      bfd_und_section or bfd_com_section.
1276    VALUE is the value of the symbol, relative to the section.
1277    STRING is used for either an indirect symbol, in which case it is
1278      the name of the symbol to indirect to, or a warning symbol, in
1279      which case it is the warning string.
1280    COPY is true if NAME or STRING must be copied into locally
1281      allocated memory if they need to be saved.
1282    COLLECT is true if we should automatically collect gcc constructor
1283      or destructor names as collect2 does.
1284    HASHP, if not NULL, is a place to store the created hash table
1285      entry.  */
1286
1287 boolean
1288 _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, value,
1289                                   string, copy, collect, hashp)
1290      struct bfd_link_info *info;
1291      bfd *abfd;
1292      const char *name;
1293      flagword flags;
1294      asection *section;
1295      bfd_vma value;
1296      const char *string;
1297      boolean copy;
1298      boolean collect;
1299      struct bfd_link_hash_entry **hashp;
1300 {
1301   enum link_row row;
1302   struct bfd_link_hash_entry *h;
1303   boolean cycle;
1304
1305   if (section == &bfd_ind_section
1306       || (flags & BSF_INDIRECT) != 0)
1307     row = INDR_ROW;
1308   else if ((flags & BSF_WARNING) != 0)
1309     row = WARN_ROW;
1310   else if ((flags & BSF_CONSTRUCTOR) != 0)
1311     row = SET_ROW;
1312   else if (section == &bfd_und_section)
1313     {
1314       if ((flags & BSF_WEAK) != 0)
1315         row = UNDEFW_ROW;
1316       else
1317         row = UNDEF_ROW;
1318     }
1319   else if ((flags & BSF_WEAK) != 0)
1320     row = DEFW_ROW;
1321   else if (bfd_is_com_section (section))
1322     row = COMMON_ROW;
1323   else
1324     row = DEF_ROW;
1325
1326   h = bfd_link_hash_lookup (info->hash, name, true, copy, false);
1327   if (h == (struct bfd_link_hash_entry *) NULL)
1328     {
1329       if (hashp != (struct bfd_link_hash_entry **) NULL)
1330         *hashp = NULL;
1331       return false;
1332     }
1333
1334   if (info->notice_hash != (struct bfd_hash_table *) NULL
1335       && (bfd_hash_lookup (info->notice_hash, name, false, false)
1336           != (struct bfd_hash_entry *) NULL))
1337     {
1338       if (! (*info->callbacks->notice) (info, name, abfd, section, value))
1339         return false;
1340     }
1341
1342   if (hashp != (struct bfd_link_hash_entry **) NULL)
1343     *hashp = h;
1344
1345   do
1346     {
1347       enum link_action action;
1348
1349       cycle = false;
1350       action = link_action[(int) row][(int) h->type];
1351       switch (action)
1352         {
1353         case FAIL:
1354           abort ();
1355         case UND:
1356           h->type = bfd_link_hash_undefined;
1357           h->u.undef.abfd = abfd;
1358           bfd_link_add_undef (info->hash, h);
1359           break;
1360         case WEAK:
1361           h->type = bfd_link_hash_weak;
1362           h->u.undef.abfd = abfd;
1363           break;
1364         case CDEF:
1365           BFD_ASSERT (h->type == bfd_link_hash_common);
1366           if (! ((*info->callbacks->multiple_common)
1367                  (info, name,
1368                   h->u.c.section->owner, bfd_link_hash_common, h->u.c.size,
1369                   abfd, bfd_link_hash_defined, (bfd_vma) 0)))
1370             return false;
1371           /* Fall through.  */
1372         case DEF:
1373           h->type = bfd_link_hash_defined;
1374           h->u.def.section = section;
1375           h->u.def.value = value;
1376
1377           /* If we have been asked to, we act like collect2 and
1378              identify all functions that might be global constructors
1379              and destructors and pass them up in a callback.  We only
1380              do this for certain object file types, since many object
1381              file types can handle this automatically.  */
1382           if (collect && name[0] == '_')
1383             {
1384               const char *s;
1385
1386               /* A constructor or destructor name starts like this:
1387                    _+GLOBAL_[_.$][ID][_.$]
1388                  where the first [_.$] and the second are the same
1389                  character (we accept any character there, in case a
1390                  new object file format comes along with even worse
1391                  naming restrictions).  */
1392
1393 #define CONS_PREFIX "GLOBAL_"
1394 #define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
1395
1396               s = name + 1;
1397               while (*s == '_')
1398                 ++s;
1399               if (s[0] == 'G'
1400                   && strncmp (s, CONS_PREFIX, CONS_PREFIX_LEN - 1) == 0)
1401                 {
1402                   char c;
1403
1404                   c = s[CONS_PREFIX_LEN + 1];
1405                   if ((c == 'I' || c == 'D')
1406                       && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
1407                     {
1408                       if (! ((*info->callbacks->constructor)
1409                              (info,
1410                               c == 'I' ? true : false,
1411                               name, abfd, section, value)))
1412                         return false;
1413                     }
1414                 }
1415             }
1416
1417           break;
1418         case COM:
1419           if (h->type == bfd_link_hash_new)
1420             bfd_link_add_undef (info->hash, h);
1421           h->type = bfd_link_hash_common;
1422           h->u.c.size = value;
1423           if (section == &bfd_com_section)
1424             {
1425               h->u.c.section = bfd_make_section_old_way (abfd, "COMMON");
1426               h->u.c.section->flags = SEC_ALLOC;
1427             }
1428           else if (section->owner != abfd)
1429             {
1430               h->u.c.section = bfd_make_section_old_way (abfd, section->name);
1431               h->u.c.section->flags = SEC_ALLOC;
1432             }
1433           else
1434             h->u.c.section = section;
1435           break;
1436         case NOACT:
1437           break;
1438         case BIG:
1439           BFD_ASSERT (h->type == bfd_link_hash_common);
1440           if (! ((*info->callbacks->multiple_common)
1441                  (info, name,
1442                   h->u.c.section->owner, bfd_link_hash_common, h->u.c.size,
1443                   abfd, bfd_link_hash_common, value)))
1444             return false;
1445           if (value > h->u.c.size)
1446             h->u.c.size = value;
1447           break;
1448         case CREF:
1449           BFD_ASSERT (h->type == bfd_link_hash_defined);
1450           if (! ((*info->callbacks->multiple_common)
1451                  (info, name,
1452                   h->u.def.section->owner, bfd_link_hash_defined, (bfd_vma) 0,
1453                   abfd, bfd_link_hash_common, value)))
1454             return false;
1455           break;
1456         case MDEF:
1457           {
1458             asection *msec;
1459             bfd_vma mval;
1460
1461             switch (h->type)
1462               {
1463               case bfd_link_hash_defined:
1464                 msec = h->u.def.section;
1465                 mval = h->u.def.value;
1466                 break;
1467               case bfd_link_hash_common:
1468                 msec = &bfd_com_section;
1469                 mval = h->u.c.size;
1470                 break;
1471               case bfd_link_hash_indirect:
1472                 msec = &bfd_ind_section;
1473                 mval = 0;
1474                 break;
1475               default:
1476                 abort ();
1477               }
1478
1479             if (! ((*info->callbacks->multiple_definition)
1480                    (info, name, msec->owner, msec, mval, abfd, section,
1481                     value)))
1482               return false;
1483           }
1484           break;
1485         case IND:
1486           {
1487             struct bfd_link_hash_entry *inh;
1488
1489             /* STRING is the name of the symbol we want to indirect
1490                to.  */
1491             inh = bfd_link_hash_lookup (info->hash, string, true, copy,
1492                                         false);
1493             if (inh == (struct bfd_link_hash_entry *) NULL)
1494               return false;
1495             if (inh->type == bfd_link_hash_new)
1496               {
1497                 inh->type = bfd_link_hash_undefined;
1498                 inh->u.undef.abfd = abfd;
1499                 bfd_link_add_undef (info->hash, inh);
1500               }
1501             h->type = bfd_link_hash_indirect;
1502             h->u.i.link = inh;
1503           }
1504           break;
1505         case SET:
1506           if (! (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR,
1507                                                 abfd, section, value))
1508             return false;
1509           break;
1510         case WARN:
1511         case WARNC:
1512           if (h->u.i.warning != NULL)
1513             {
1514               if (! (*info->callbacks->warning) (info, h->u.i.warning))
1515                 return false;
1516               /* Only issue a warning once.  */
1517               h->u.i.warning = NULL;
1518             }
1519           if (action == WARN)
1520             break;
1521           /* Fall through.  */
1522         case CYCLE:
1523           h = h->u.i.link;
1524           cycle = true;
1525           break;
1526         case MWARN:
1527           {
1528             struct bfd_link_hash_entry *sub;
1529
1530             /* STRING is the warning to give.  */
1531             sub = ((struct bfd_link_hash_entry *)
1532                    bfd_hash_allocate (&info->hash->table,
1533                                       sizeof (struct bfd_link_hash_entry)));
1534             if (!sub)
1535               {
1536                 bfd_set_error (bfd_error_no_memory);
1537                 return false;
1538               }
1539             *sub = *h;
1540             h->type = bfd_link_hash_warning;
1541             h->u.i.link = sub;
1542             if (! copy)
1543               h->u.i.warning = string;
1544             else
1545               {
1546                 char *w;
1547
1548                 w = bfd_hash_allocate (&info->hash->table,
1549                                        strlen (string) + 1);
1550                 strcpy (w, string);
1551                 h->u.i.warning = w;
1552               }
1553           }
1554           break;
1555         }
1556     }
1557   while (cycle);
1558
1559   return true;
1560 }
1561 \f
1562 /* Generic final link routine.  */
1563
1564 boolean
1565 _bfd_generic_final_link (abfd, info)
1566      bfd *abfd;
1567      struct bfd_link_info *info;
1568 {
1569   bfd *sub;
1570   asection *o;
1571   struct bfd_link_order *p;
1572   size_t outsymalloc;
1573   struct generic_write_global_symbol_info wginfo;
1574
1575   abfd->outsymbols = (asymbol **) NULL;
1576   abfd->symcount = 0;
1577   outsymalloc = 0;
1578
1579   /* Build the output symbol table.  This also reads in the symbols
1580      for all the input BFDs, keeping them in the outsymbols field.  */
1581   for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
1582     if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
1583       return false;
1584
1585   /* Accumulate the global symbols.  */
1586   wginfo.info = info;
1587   wginfo.output_bfd = abfd;
1588   wginfo.psymalloc = &outsymalloc;
1589   _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info),
1590                                    _bfd_generic_link_write_global_symbol,
1591                                    (PTR) &wginfo);
1592
1593   if (info->relocateable)
1594     {
1595       /* Allocate space for the output relocs for each section.  */
1596       for (o = abfd->sections;
1597            o != (asection *) NULL;
1598            o = o->next)
1599         {
1600           o->reloc_count = 0;
1601           for (p = o->link_order_head;
1602                p != (struct bfd_link_order *) NULL;
1603                p = p->next)
1604             {
1605               if (p->type == bfd_section_reloc_link_order
1606                   || p->type == bfd_symbol_reloc_link_order)
1607                 ++o->reloc_count;
1608               else if (p->type == bfd_indirect_link_order)
1609                 {
1610                   asection *input_section;
1611                   bfd *input_bfd;
1612                   bfd_size_type relsize;
1613                   arelent **relocs;
1614                   bfd_size_type reloc_count;
1615
1616                   input_section = p->u.indirect.section;
1617                   input_bfd = input_section->owner;
1618                   relsize = bfd_get_reloc_upper_bound (input_bfd,
1619                                                        input_section);
1620                   relocs = (arelent **) malloc ((size_t) relsize);
1621                   if (!relocs && relsize != 0)
1622                     {
1623                       bfd_set_error (bfd_error_no_memory);
1624                       return false;
1625                     }
1626                   reloc_count =
1627                     bfd_canonicalize_reloc (input_bfd, input_section,
1628                                             relocs,
1629                                             bfd_get_outsymbols (input_bfd));
1630                   BFD_ASSERT (reloc_count == input_section->reloc_count);
1631                   o->reloc_count += reloc_count;
1632                   free (relocs);
1633                 }
1634             }
1635           if (o->reloc_count > 0)
1636             {
1637               o->orelocation = ((arelent **)
1638                                 bfd_alloc (abfd,
1639                                            (o->reloc_count
1640                                             * sizeof (arelent *))));
1641               if (!o->orelocation)
1642                 {
1643                   bfd_set_error (bfd_error_no_memory);
1644                   return false;
1645                 }
1646               o->flags |= SEC_RELOC;
1647               /* Reset the count so that it can be used as an index
1648                  when putting in the output relocs.  */
1649               o->reloc_count = 0;
1650             }
1651         }
1652     }
1653
1654   /* Handle all the link order information for the sections.  */
1655   for (o = abfd->sections;
1656        o != (asection *) NULL;
1657        o = o->next)
1658     {
1659       for (p = o->link_order_head;
1660            p != (struct bfd_link_order *) NULL;
1661            p = p->next)
1662         {
1663           switch (p->type)
1664             {
1665             case bfd_section_reloc_link_order:
1666             case bfd_symbol_reloc_link_order:
1667               if (! _bfd_generic_reloc_link_order (abfd, info, o, p))
1668                 return false;
1669               break;
1670             default:
1671               if (! _bfd_default_link_order (abfd, info, o, p))
1672                 return false;
1673               break;
1674             }
1675         }
1676     }
1677
1678   return true;
1679 }
1680
1681 /* Add an output symbol to the output BFD.  */
1682
1683 static boolean
1684 generic_add_output_symbol (output_bfd, psymalloc, sym)
1685      bfd *output_bfd;
1686      size_t *psymalloc;
1687      asymbol *sym;
1688 {
1689   if (output_bfd->symcount >= *psymalloc)
1690     {
1691       asymbol **newsyms;
1692
1693       if (*psymalloc == 0)
1694         *psymalloc = 124;
1695       else
1696         *psymalloc *= 2;
1697       if (output_bfd->outsymbols == (asymbol **) NULL)
1698         newsyms = (asymbol **) malloc (*psymalloc * sizeof (asymbol *));
1699       else
1700         newsyms = (asymbol **) realloc (output_bfd->outsymbols,
1701                                         *psymalloc * sizeof (asymbol *));
1702       if (newsyms == (asymbol **) NULL)
1703         {
1704           bfd_set_error (bfd_error_no_memory);
1705           return false;
1706         }
1707       output_bfd->outsymbols = newsyms;
1708     }
1709
1710   output_bfd->outsymbols[output_bfd->symcount] = sym;
1711   ++output_bfd->symcount;
1712
1713   return true;
1714 }
1715
1716 /* Handle the symbols for an input BFD.  */
1717
1718 boolean
1719 _bfd_generic_link_output_symbols (output_bfd, input_bfd, info, psymalloc)
1720      bfd *output_bfd;
1721      bfd *input_bfd;
1722      struct bfd_link_info *info;
1723      size_t *psymalloc;
1724 {
1725   size_t symsize;
1726   asymbol **sym_ptr;
1727   asymbol **sym_end;
1728
1729   /* Do not clobber outsymbols if they have already been created.  */
1730   if (input_bfd->outsymbols == NULL)
1731     {
1732       symsize = get_symtab_upper_bound (input_bfd);
1733       input_bfd->outsymbols = (asymbol **) bfd_alloc (input_bfd, symsize);
1734       if (!input_bfd->outsymbols)
1735         {
1736           bfd_set_error (bfd_error_no_memory);
1737           return false;
1738         }
1739       input_bfd->symcount = bfd_canonicalize_symtab (input_bfd,
1740                                                      input_bfd->outsymbols);
1741     }
1742
1743   /* Create a filename symbol if we are supposed to.  */
1744   if (info->create_object_symbols_section != (asection *) NULL)
1745     {
1746       asection *sec;
1747
1748       for (sec = input_bfd->sections;
1749            sec != (asection *) NULL;
1750            sec = sec->next)
1751         {
1752           if (sec->output_section == info->create_object_symbols_section)
1753             {
1754               asymbol *newsym;
1755
1756               newsym = bfd_make_empty_symbol (input_bfd);
1757               if (!newsym)
1758                 return false;
1759               newsym->name = input_bfd->filename;
1760               newsym->value = 0;
1761               newsym->flags = BSF_LOCAL | BSF_FILE;
1762               newsym->section = sec;
1763
1764               if (! generic_add_output_symbol (output_bfd, psymalloc,
1765                                                newsym))
1766                 return false;
1767
1768               break;
1769             }
1770         }
1771     }
1772
1773   /* Adjust the values of the globally visible symbols, and write out
1774      local symbols.  */
1775   sym_ptr = bfd_get_outsymbols (input_bfd);
1776   sym_end = sym_ptr + bfd_get_symcount (input_bfd);
1777   for (; sym_ptr < sym_end; sym_ptr++)
1778     {
1779       asymbol *sym;
1780       struct generic_link_hash_entry *h;
1781       boolean output;
1782
1783       h = (struct generic_link_hash_entry *) NULL;
1784       sym = *sym_ptr;
1785       if ((sym->flags & (BSF_INDIRECT
1786                          | BSF_WARNING
1787                          | BSF_GLOBAL
1788                          | BSF_CONSTRUCTOR
1789                          | BSF_WEAK)) != 0
1790           || bfd_get_section (sym) == &bfd_und_section
1791           || bfd_is_com_section (bfd_get_section (sym))
1792           || bfd_get_section (sym) == &bfd_ind_section)
1793         {
1794           h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
1795                                              bfd_asymbol_name (sym),
1796                                              false, false, true);
1797           if (h != (struct generic_link_hash_entry *) NULL)
1798             {
1799               /* Force all references to this symbol to point to
1800                  the same area in memory.  It is possible that
1801                  this routine will be called with a hash table
1802                  other than a generic hash table, so we double
1803                  check that.  */
1804               if (info->hash->creator == input_bfd->xvec)
1805                 {
1806                   if (h->sym != (asymbol *) NULL)
1807                     *sym_ptr = sym = h->sym;
1808                 }
1809
1810               switch (h->root.type)
1811                 {
1812                 default:
1813                 case bfd_link_hash_new:
1814                   abort ();
1815                 case bfd_link_hash_undefined:
1816                 case bfd_link_hash_weak:
1817                   break;
1818                 case bfd_link_hash_defined:
1819                   sym->value = h->root.u.def.value;
1820                   sym->section = h->root.u.def.section;
1821                   sym->flags |= BSF_GLOBAL;
1822                   break;
1823                 case bfd_link_hash_common:
1824                   sym->value = h->root.u.c.size;
1825                   sym->flags |= BSF_GLOBAL;
1826                   if (! bfd_is_com_section (sym->section))
1827                     {
1828                       BFD_ASSERT (sym->section == &bfd_und_section);
1829                       sym->section = &bfd_com_section;
1830                     }
1831                   /* We do not set the section of the symbol to
1832                      h->root.u.c.section.  That value was saved so
1833                      that we would know where to allocate the symbol
1834                      if it was defined.  In this case the type is
1835                      still bfd_link_hash_common, so we did not define
1836                      it, so we do not want to use that section.  */
1837                   break;
1838                 }
1839             }
1840         }
1841
1842       /* This switch is straight from the old code in
1843          write_file_locals in ldsym.c.  */
1844       if (info->strip == strip_some
1845           && (bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym),
1846                                false, false)
1847               == (struct bfd_hash_entry *) NULL))
1848         output = false;
1849       else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
1850         {
1851           /* If this symbol is marked as occurring now, rather
1852              than at the end, output it now.  This is used for
1853              COFF C_EXT FCN symbols.  FIXME: There must be a
1854              better way.  */
1855           if (bfd_asymbol_bfd (sym) == input_bfd
1856               && (sym->flags & BSF_NOT_AT_END) != 0)
1857             output = true;
1858           else
1859             output = false;
1860         }
1861       else if (sym->section == &bfd_ind_section)
1862         output = false;
1863       else if ((sym->flags & BSF_DEBUGGING) != 0)
1864         {
1865           if (info->strip == strip_none)
1866             output = true;
1867           else
1868             output = false;
1869         }
1870       else if (sym->section == &bfd_und_section
1871                || bfd_is_com_section (sym->section))
1872         output = false;
1873       else if ((sym->flags & BSF_LOCAL) != 0)
1874         {
1875           if ((sym->flags & BSF_WARNING) != 0)
1876             output = false;
1877           else
1878             {
1879               switch (info->discard)
1880                 {
1881                 default:
1882                 case discard_all:
1883                   output = false;
1884                   break;
1885                 case discard_l:
1886                   if (bfd_asymbol_name (sym)[0] == info->lprefix[0]
1887                       && (info->lprefix_len == 1
1888                           || strncmp (bfd_asymbol_name (sym), info->lprefix,
1889                                       info->lprefix_len) == 0))
1890                     output = false;
1891                   else
1892                     output = true;
1893                   break;
1894                 case discard_none:
1895                   output = true;
1896                   break;
1897                 }
1898             }
1899         }
1900       else if ((sym->flags & BSF_CONSTRUCTOR))
1901         {
1902           if (info->strip != strip_all)
1903             output = true;
1904           else
1905             output = false;
1906         }
1907       else
1908         abort ();
1909
1910       if (output)
1911         {
1912           if (! generic_add_output_symbol (output_bfd, psymalloc, sym))
1913             return false;
1914           if (h != (struct generic_link_hash_entry *) NULL)
1915             h->root.written = true;
1916         }
1917     }
1918
1919   return true;
1920 }
1921
1922 /* Write out a global symbol, if it hasn't already been written out.
1923    This is called for each symbol in the hash table.  */
1924
1925 boolean
1926 _bfd_generic_link_write_global_symbol (h, data)
1927      struct generic_link_hash_entry *h;
1928      PTR data;
1929 {
1930   struct generic_write_global_symbol_info *wginfo =
1931     (struct generic_write_global_symbol_info *) data;
1932   asymbol *sym;
1933
1934   if (h->root.written)
1935     return true;
1936
1937   h->root.written = true;
1938
1939   if (wginfo->info->strip == strip_all
1940       || (wginfo->info->strip == strip_some
1941           && bfd_hash_lookup (wginfo->info->keep_hash, h->root.root.string,
1942                               false, false) == NULL))
1943     return true;
1944
1945   if (h->sym != (asymbol *) NULL)
1946     {
1947       sym = h->sym;
1948       BFD_ASSERT (strcmp (bfd_asymbol_name (sym), h->root.root.string) == 0);
1949     }
1950   else
1951     {
1952       sym = bfd_make_empty_symbol (wginfo->output_bfd);
1953       if (!sym)
1954         return false;
1955       sym->name = h->root.root.string;
1956       sym->flags = 0;
1957     }
1958
1959   switch (h->root.type)
1960     {
1961     default:
1962     case bfd_link_hash_new:
1963       abort ();
1964     case bfd_link_hash_undefined:
1965       sym->section = &bfd_und_section;
1966       sym->value = 0;
1967       break;
1968     case bfd_link_hash_weak:
1969       sym->section = &bfd_und_section;
1970       sym->value = 0;
1971       sym->flags |= BSF_WEAK;
1972       break;
1973     case bfd_link_hash_defined:
1974       sym->section = h->root.u.def.section;
1975       sym->value = h->root.u.def.value;
1976       break;
1977     case bfd_link_hash_common:
1978       sym->value = h->root.u.c.size;
1979       if (! bfd_is_com_section (sym->section))
1980         {
1981           BFD_ASSERT (sym->section == &bfd_und_section);
1982           sym->section = &bfd_com_section;
1983         }
1984       /* Do not set the section; see _bfd_generic_link_output_symbols.  */
1985       break;
1986     case bfd_link_hash_indirect:
1987     case bfd_link_hash_warning:
1988       /* FIXME: What should we do here?  */
1989       break;
1990     }
1991
1992   sym->flags |= BSF_GLOBAL;
1993
1994   if (! generic_add_output_symbol (wginfo->output_bfd, wginfo->psymalloc,
1995                                    sym))
1996     {
1997       /* FIXME: No way to return failure.  */
1998       abort ();
1999     }
2000
2001   return true;
2002 }
2003
2004 /* Create a relocation.  */
2005
2006 boolean
2007 _bfd_generic_reloc_link_order (abfd, info, sec, link_order)
2008      bfd *abfd;
2009      struct bfd_link_info *info;
2010      asection *sec;
2011      struct bfd_link_order *link_order;
2012 {
2013   arelent *r;
2014
2015   if (! info->relocateable)
2016     abort ();
2017   if (sec->orelocation == (arelent **) NULL)
2018     abort ();
2019
2020   r = (arelent *) bfd_alloc (abfd, sizeof (arelent));
2021   if (r == (arelent *) NULL)
2022     {
2023       bfd_set_error (bfd_error_no_memory);
2024       return false;
2025     }
2026
2027   r->address = link_order->offset;
2028   r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc);
2029   if (r->howto == (const reloc_howto_type *) NULL)
2030     {
2031       bfd_set_error (bfd_error_bad_value);
2032       return false;
2033     }
2034
2035   /* Get the symbol to use for the relocation.  */
2036   if (link_order->type == bfd_section_reloc_link_order)
2037     r->sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
2038   else
2039     {
2040       struct generic_link_hash_entry *h;
2041
2042       h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
2043                                          link_order->u.reloc.p->u.name,
2044                                          false, false, true);
2045       if (h == (struct generic_link_hash_entry *) NULL
2046           || ! h->root.written)
2047         {
2048           if (! ((*info->callbacks->unattached_reloc)
2049                  (info, link_order->u.reloc.p->u.name,
2050                   (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2051             return false;
2052           bfd_set_error (bfd_error_bad_value);
2053           return false;
2054         }
2055       r->sym_ptr_ptr = &h->sym;
2056     }
2057
2058   /* If this is an inplace reloc, write the addend to the object file.
2059      Otherwise, store it in the reloc addend.  */
2060   if (! r->howto->partial_inplace)
2061     r->addend = link_order->u.reloc.p->addend;
2062   else
2063     {
2064       bfd_size_type size;
2065       bfd_reloc_status_type rstat;
2066       bfd_byte *buf;
2067       boolean ok;
2068
2069       size = bfd_get_reloc_size (r->howto);
2070       buf = (bfd_byte *) bfd_zmalloc (size);
2071       if (buf == (bfd_byte *) NULL)
2072         {
2073           bfd_set_error (bfd_error_no_memory);
2074           return false;
2075         }
2076       rstat = _bfd_relocate_contents (r->howto, abfd,
2077                                       link_order->u.reloc.p->addend, buf);
2078       switch (rstat)
2079         {
2080         case bfd_reloc_ok:
2081           break;
2082         default:
2083         case bfd_reloc_outofrange:
2084           abort ();
2085         case bfd_reloc_overflow:
2086           if (! ((*info->callbacks->reloc_overflow)
2087                  (info,
2088                   (link_order->type == bfd_section_reloc_link_order
2089                    ? bfd_section_name (abfd, link_order->u.reloc.p->u.section)
2090                    : link_order->u.reloc.p->u.name),
2091                   r->howto->name, link_order->u.reloc.p->addend,
2092                   (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2093             {
2094               free (buf);
2095               return false;
2096             }
2097           break;
2098         }
2099       ok = bfd_set_section_contents (abfd, sec, (PTR) buf,
2100                                      (file_ptr) link_order->offset, size);
2101       free (buf);
2102       if (! ok)
2103         return false;
2104
2105       r->addend = 0;
2106     }
2107
2108   sec->orelocation[sec->reloc_count] = r;
2109   ++sec->reloc_count;
2110
2111   return true;
2112 }
2113 \f
2114 /* Allocate a new link_order for a section.  */
2115
2116 struct bfd_link_order *
2117 bfd_new_link_order (abfd, section)
2118      bfd *abfd;
2119      asection *section;
2120 {
2121   struct bfd_link_order *new;
2122
2123   new = ((struct bfd_link_order *)
2124          bfd_alloc_by_size_t (abfd, sizeof (struct bfd_link_order)));
2125   if (!new)
2126     {
2127       bfd_set_error (bfd_error_no_memory);
2128       return NULL;
2129     }
2130
2131   new->type = bfd_undefined_link_order;
2132   new->offset = 0;
2133   new->size = 0;
2134   new->next = (struct bfd_link_order *) NULL;
2135
2136   if (section->link_order_tail != (struct bfd_link_order *) NULL)
2137     section->link_order_tail->next = new;
2138   else
2139     section->link_order_head = new;
2140   section->link_order_tail = new;
2141
2142   return new;
2143 }
2144
2145 /* Default link order processing routine.  Note that we can not handle
2146    the reloc_link_order types here, since they depend upon the details
2147    of how the particular backends generates relocs.  */
2148
2149 boolean
2150 _bfd_default_link_order (abfd, info, sec, link_order)
2151      bfd *abfd;
2152      struct bfd_link_info *info;
2153      asection *sec;
2154      struct bfd_link_order *link_order;
2155 {
2156   switch (link_order->type)
2157     {
2158     case bfd_undefined_link_order:
2159     case bfd_section_reloc_link_order:
2160     case bfd_symbol_reloc_link_order:
2161     default:
2162       abort ();
2163     case bfd_indirect_link_order:
2164       return default_indirect_link_order (abfd, info, sec, link_order);
2165     case bfd_fill_link_order:
2166       return default_fill_link_order (abfd, info, sec, link_order);
2167     case bfd_data_link_order:
2168       return bfd_set_section_contents (abfd, sec,
2169                                        (PTR) link_order->u.data.contents,
2170                                        (file_ptr) link_order->offset,
2171                                        link_order->size);
2172     }
2173 }
2174
2175 /* Default routine to handle a bfd_fill_link_order.  */
2176
2177 /*ARGSUSED*/
2178 static boolean
2179 default_fill_link_order (abfd, info, sec, link_order)
2180      bfd *abfd;
2181      struct bfd_link_info *info;
2182      asection *sec;
2183      struct bfd_link_order *link_order;
2184 {
2185   size_t size;
2186   char *space;
2187   size_t i;
2188   int fill;
2189   boolean result;
2190
2191   BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0);
2192
2193   size = (size_t) link_order->size;
2194   space = (char *) malloc (size);
2195   if (space == NULL && size != 0)
2196     {
2197       bfd_set_error (bfd_error_no_memory);
2198       return false;
2199     }
2200
2201   fill = link_order->u.fill.value;
2202   for (i = 0; i < size; i += 2)
2203     space[i] = fill >> 8;
2204   for (i = 1; i < size; i += 2)
2205     space[i] = fill;
2206   result = bfd_set_section_contents (abfd, sec, space,
2207                                      (file_ptr) link_order->offset,
2208                                      link_order->size);
2209   free (space);
2210   return result;
2211 }
2212
2213 /* Default routine to handle a bfd_indirect_link_order.  */
2214
2215 static boolean
2216 default_indirect_link_order (output_bfd, info, output_section, link_order)
2217      bfd *output_bfd;
2218      struct bfd_link_info *info;
2219      asection *output_section;
2220      struct bfd_link_order *link_order;
2221 {
2222   asection *input_section;
2223   bfd *input_bfd;
2224   bfd_byte *contents = NULL;
2225   bfd_byte *new_contents;
2226
2227   BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
2228
2229   if (link_order->size == 0)
2230     return true;
2231
2232   input_section = link_order->u.indirect.section;
2233   input_bfd = input_section->owner;
2234
2235   BFD_ASSERT (input_section->output_section == output_section);
2236   BFD_ASSERT (input_section->output_offset == link_order->offset);
2237   BFD_ASSERT (input_section->_cooked_size == link_order->size);
2238
2239   if (info->relocateable
2240       && input_section->reloc_count > 0
2241       && output_section->orelocation == (arelent **) NULL)
2242     {
2243       /* Space has not been allocated for the output relocations.
2244          This can happen when we are called by a specific backend
2245          because somebody is attempting to link together different
2246          types of object files.  Handling this case correctly is
2247          difficult, and sometimes impossible.  */
2248       abort ();
2249     }
2250
2251   /* Get the canonical symbols.  The generic linker will always have
2252      retrieved them by this point, but we may be being called by a
2253      specific linker when linking different types of object files
2254      together.  */
2255   if (bfd_get_outsymbols (input_bfd) == (asymbol **) NULL)
2256     {
2257       size_t symsize;
2258
2259       symsize = get_symtab_upper_bound (input_bfd);
2260       input_bfd->outsymbols = (asymbol **) bfd_alloc (input_bfd, symsize);
2261       if (!input_bfd->outsymbols)
2262         {
2263           bfd_set_error (bfd_error_no_memory);
2264           return false;
2265         }
2266       input_bfd->symcount = bfd_canonicalize_symtab (input_bfd,
2267                                                      input_bfd->outsymbols);
2268     }
2269
2270   /* Get and relocate the section contents.  */
2271   contents = (bfd_byte *) malloc (bfd_section_size (input_bfd, input_section));
2272   if (contents == NULL && bfd_section_size (input_bfd, input_section) != 0)
2273     {
2274       bfd_set_error (bfd_error_no_memory);
2275       goto error_return;
2276     }
2277   new_contents = (bfd_get_relocated_section_contents
2278                   (output_bfd, info, link_order, contents, info->relocateable,
2279                    bfd_get_outsymbols (input_bfd)));
2280   if (!new_contents)
2281     goto error_return;
2282
2283   /* Output the section contents.  */
2284   if (! bfd_set_section_contents (output_bfd, output_section,
2285                                   (PTR) new_contents,
2286                                   link_order->offset, link_order->size))
2287     goto error_return;
2288
2289   if (contents != NULL)
2290     free (contents);
2291   return true;
2292
2293  error_return:
2294   if (contents != NULL)
2295     free (contents);
2296   return false;
2297 }
2298
2299 /* A little routine to count the number of relocs in a link_order
2300    list.  */
2301
2302 unsigned int
2303 _bfd_count_link_order_relocs (link_order)
2304      struct bfd_link_order *link_order;
2305 {
2306   register unsigned int c;
2307   register struct bfd_link_order *l;
2308
2309   c = 0;
2310   for (l = link_order; l != (struct bfd_link_order *) NULL; l = l->next)
2311     {
2312       if (l->type == bfd_section_reloc_link_order
2313           || l->type == bfd_symbol_reloc_link_order)
2314         ++c;
2315     }
2316
2317   return c;
2318 }