contrib/gdb-6/bfd/linker.c

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