bfd/linker.c

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