bfd/linker.c

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