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