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