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