bfd/linker.c

   1 /* linker.c -- BFD linker routines
   2    Copyright (C) 1993-2018 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       if (!bfd_link_relocatable (info)
1425           && name[0] == '_'
1426           && name[1] == '_'
1427           && strcmp (name + (name[2] == '_'), "__gnu_lto_slim") == 0)
1428         _bfd_error_handler
1429           (_("%pB: plugin needed to handle lto object"), abfd);
1430     }
1431   else
1432     row = DEF_ROW;
1433
1434   if (hashp != NULL && *hashp != NULL)
1435     h = *hashp;
1436   else
1437     {
1438       if (row == UNDEF_ROW || row == UNDEFW_ROW)
1439         h = bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE);
1440       else
1441         h = bfd_link_hash_lookup (info->hash, name, TRUE, copy, FALSE);
1442       if (h == NULL)
1443         {
1444           if (hashp != NULL)
1445             *hashp = NULL;
1446           return FALSE;
1447         }
1448     }
1449
1450   if (info->notice_all
1451       || (info->notice_hash != NULL
1452           && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1453     {
1454       if (! (*info->callbacks->notice) (info, h, inh,
1455                                         abfd, section, value, flags))
1456         return FALSE;
1457     }
1458
1459   if (hashp != NULL)
1460     *hashp = h;
1461
1462   do
1463     {
1464       enum link_action action;
1465       int prev;
1466
1467       prev = h->type;
1468       /* Treat symbols defined by early linker script pass as undefined.  */
1469       if (h->ldscript_def)
1470         prev = bfd_link_hash_undefined;
1471       cycle = FALSE;
1472       action = link_action[(int) row][prev];
1473       switch (action)
1474         {
1475         case FAIL:
1476           abort ();
1477
1478         case NOACT:
1479           /* Do nothing.  */
1480           break;
1481
1482         case UND:
1483           /* Make a new undefined symbol.  */
1484           h->type = bfd_link_hash_undefined;
1485           h->u.undef.abfd = abfd;
1486           bfd_link_add_undef (info->hash, h);
1487           break;
1488
1489         case WEAK:
1490           /* Make a new weak undefined symbol.  */
1491           h->type = bfd_link_hash_undefweak;
1492           h->u.undef.abfd = abfd;
1493           break;
1494
1495         case CDEF:
1496           /* We have found a definition for a symbol which was
1497              previously common.  */
1498           BFD_ASSERT (h->type == bfd_link_hash_common);
1499           (*info->callbacks->multiple_common) (info, h, abfd,
1500                                                bfd_link_hash_defined, 0);
1501           /* Fall through.  */
1502         case DEF:
1503         case DEFW:
1504           {
1505             enum bfd_link_hash_type oldtype;
1506
1507             /* Define a symbol.  */
1508             oldtype = h->type;
1509             if (action == DEFW)
1510               h->type = bfd_link_hash_defweak;
1511             else
1512               h->type = bfd_link_hash_defined;
1513             h->u.def.section = section;
1514             h->u.def.value = value;
1515             h->linker_def = 0;
1516             h->ldscript_def = 0;
1517
1518             /* If we have been asked to, we act like collect2 and
1519                identify all functions that might be global
1520                constructors and destructors and pass them up in a
1521                callback.  We only do this for certain object file
1522                types, since many object file types can handle this
1523                automatically.  */
1524             if (collect && name[0] == '_')
1525               {
1526                 const char *s;
1527
1528                 /* A constructor or destructor name starts like this:
1529                    _+GLOBAL_[_.$][ID][_.$] where the first [_.$] and
1530                    the second are the same character (we accept any
1531                    character there, in case a new object file format
1532                    comes along with even worse naming restrictions).  */
1533
1534 #define CONS_PREFIX "GLOBAL_"
1535 #define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
1536
1537                 s = name + 1;
1538                 while (*s == '_')
1539                   ++s;
1540                 if (s[0] == 'G' && CONST_STRNEQ (s, CONS_PREFIX))
1541                   {
1542                     char c;
1543
1544                     c = s[CONS_PREFIX_LEN + 1];
1545                     if ((c == 'I' || c == 'D')
1546                         && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
1547                       {
1548                         /* If this is a definition of a symbol which
1549                            was previously weakly defined, we are in
1550                            trouble.  We have already added a
1551                            constructor entry for the weak defined
1552                            symbol, and now we are trying to add one
1553                            for the new symbol.  Fortunately, this case
1554                            should never arise in practice.  */
1555                         if (oldtype == bfd_link_hash_defweak)
1556                           abort ();
1557
1558                         (*info->callbacks->constructor) (info, c == 'I',
1559                                                          h->root.string, abfd,
1560                                                          section, value);
1561                       }
1562                   }
1563               }
1564           }
1565
1566           break;
1567
1568         case COM:
1569           /* We have found a common definition for a symbol.  */
1570           if (h->type == bfd_link_hash_new)
1571             bfd_link_add_undef (info->hash, h);
1572           h->type = bfd_link_hash_common;
1573           h->u.c.p = (struct bfd_link_hash_common_entry *)
1574             bfd_hash_allocate (&info->hash->table,
1575                                sizeof (struct bfd_link_hash_common_entry));
1576           if (h->u.c.p == NULL)
1577             return FALSE;
1578
1579           h->u.c.size = value;
1580
1581           /* Select a default alignment based on the size.  This may
1582              be overridden by the caller.  */
1583           {
1584             unsigned int power;
1585
1586             power = bfd_log2 (value);
1587             if (power > 4)
1588               power = 4;
1589             h->u.c.p->alignment_power = power;
1590           }
1591
1592           /* The section of a common symbol is only used if the common
1593              symbol is actually allocated.  It basically provides a
1594              hook for the linker script to decide which output section
1595              the common symbols should be put in.  In most cases, the
1596              section of a common symbol will be bfd_com_section_ptr,
1597              the code here will choose a common symbol section named
1598              "COMMON", and the linker script will contain *(COMMON) in
1599              the appropriate place.  A few targets use separate common
1600              sections for small symbols, and they require special
1601              handling.  */
1602           if (section == bfd_com_section_ptr)
1603             {
1604               h->u.c.p->section = bfd_make_section_old_way (abfd, "COMMON");
1605               h->u.c.p->section->flags |= SEC_ALLOC;
1606             }
1607           else if (section->owner != abfd)
1608             {
1609               h->u.c.p->section = bfd_make_section_old_way (abfd,
1610                                                             section->name);
1611               h->u.c.p->section->flags |= SEC_ALLOC;
1612             }
1613           else
1614             h->u.c.p->section = section;
1615           h->linker_def = 0;
1616           h->ldscript_def = 0;
1617           break;
1618
1619         case REF:
1620           /* A reference to a defined symbol.  */
1621           if (h->u.undef.next == NULL && info->hash->undefs_tail != h)
1622             h->u.undef.next = h;
1623           break;
1624
1625         case BIG:
1626           /* We have found a common definition for a symbol which
1627              already had a common definition.  Use the maximum of the
1628              two sizes, and use the section required by the larger symbol.  */
1629           BFD_ASSERT (h->type == bfd_link_hash_common);
1630           (*info->callbacks->multiple_common) (info, h, abfd,
1631                                                bfd_link_hash_common, value);
1632           if (value > h->u.c.size)
1633             {
1634               unsigned int power;
1635
1636               h->u.c.size = value;
1637
1638               /* Select a default alignment based on the size.  This may
1639                  be overridden by the caller.  */
1640               power = bfd_log2 (value);
1641               if (power > 4)
1642                 power = 4;
1643               h->u.c.p->alignment_power = power;
1644
1645               /* Some systems have special treatment for small commons,
1646                  hence we want to select the section used by the larger
1647                  symbol.  This makes sure the symbol does not go in a
1648                  small common section if it is now too large.  */
1649               if (section == bfd_com_section_ptr)
1650                 {
1651                   h->u.c.p->section
1652                     = bfd_make_section_old_way (abfd, "COMMON");
1653                   h->u.c.p->section->flags |= SEC_ALLOC;
1654                 }
1655               else if (section->owner != abfd)
1656                 {
1657                   h->u.c.p->section
1658                     = bfd_make_section_old_way (abfd, section->name);
1659                   h->u.c.p->section->flags |= SEC_ALLOC;
1660                 }
1661               else
1662                 h->u.c.p->section = section;
1663             }
1664           break;
1665
1666         case CREF:
1667           /* We have found a common definition for a symbol which
1668              was already defined.  */
1669           (*info->callbacks->multiple_common) (info, h, abfd,
1670                                                bfd_link_hash_common, value);
1671           break;
1672
1673         case MIND:
1674           /* Multiple indirect symbols.  This is OK if they both point
1675              to the same symbol.  */
1676           if (strcmp (h->u.i.link->root.string, string) == 0)
1677             break;
1678           /* Fall through.  */
1679         case MDEF:
1680           /* Handle a multiple definition.  */
1681           (*info->callbacks->multiple_definition) (info, h,
1682                                                    abfd, section, value);
1683           break;
1684
1685         case CIND:
1686           /* Create an indirect symbol from an existing common symbol.  */
1687           BFD_ASSERT (h->type == bfd_link_hash_common);
1688           (*info->callbacks->multiple_common) (info, h, abfd,
1689                                                bfd_link_hash_indirect, 0);
1690           /* Fall through.  */
1691         case IND:
1692           if (inh->type == bfd_link_hash_indirect
1693               && inh->u.i.link == h)
1694             {
1695               _bfd_error_handler
1696                 /* xgettext:c-format */
1697                 (_("%pB: indirect symbol `%s' to `%s' is a loop"),
1698                  abfd, name, string);
1699               bfd_set_error (bfd_error_invalid_operation);
1700               return FALSE;
1701             }
1702           if (inh->type == bfd_link_hash_new)
1703             {
1704               inh->type = bfd_link_hash_undefined;
1705               inh->u.undef.abfd = abfd;
1706               bfd_link_add_undef (info->hash, inh);
1707             }
1708
1709           /* If the indirect symbol has been referenced, we need to
1710              push the reference down to the symbol we are referencing.  */
1711           if (h->type != bfd_link_hash_new)
1712             {
1713               /* ??? If inh->type == bfd_link_hash_undefweak this
1714                  converts inh to bfd_link_hash_undefined.  */
1715               row = UNDEF_ROW;
1716               cycle = TRUE;
1717             }
1718
1719           h->type = bfd_link_hash_indirect;
1720           h->u.i.link = inh;
1721           /* Not setting h = h->u.i.link here means that when cycle is
1722              set above we'll always go to REFC, and then cycle again
1723              to the indirected symbol.  This means that any successful
1724              change of an existing symbol to indirect counts as a
1725              reference.  ??? That may not be correct when the existing
1726              symbol was defweak.  */
1727           break;
1728
1729         case SET:
1730           /* Add an entry to a set.  */
1731           (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR,
1732                                           abfd, section, value);
1733           break;
1734
1735         case WARNC:
1736           /* Issue a warning and cycle, except when the reference is
1737              in LTO IR.  */
1738           if (h->u.i.warning != NULL
1739               && (abfd->flags & BFD_PLUGIN) == 0)
1740             {
1741               (*info->callbacks->warning) (info, h->u.i.warning,
1742                                            h->root.string, abfd, NULL, 0);
1743               /* Only issue a warning once.  */
1744               h->u.i.warning = NULL;
1745             }
1746           /* Fall through.  */
1747         case CYCLE:
1748           /* Try again with the referenced symbol.  */
1749           h = h->u.i.link;
1750           cycle = TRUE;
1751           break;
1752
1753         case REFC:
1754           /* A reference to an indirect symbol.  */
1755           if (h->u.undef.next == NULL && info->hash->undefs_tail != h)
1756             h->u.undef.next = h;
1757           h = h->u.i.link;
1758           cycle = TRUE;
1759           break;
1760
1761         case WARN:
1762           /* Warn if this symbol has been referenced already from non-IR,
1763              otherwise add a warning.  */
1764           if ((!info->lto_plugin_active
1765                && (h->u.undef.next != NULL || info->hash->undefs_tail == h))
1766               || h->non_ir_ref_regular
1767               || h->non_ir_ref_dynamic)
1768             {
1769               (*info->callbacks->warning) (info, string, h->root.string,
1770                                            hash_entry_bfd (h), NULL, 0);
1771               break;
1772             }
1773           /* Fall through.  */
1774         case MWARN:
1775           /* Make a warning symbol.  */
1776           {
1777             struct bfd_link_hash_entry *sub;
1778
1779             /* STRING is the warning to give.  */
1780             sub = ((struct bfd_link_hash_entry *)
1781                    ((*info->hash->table.newfunc)
1782                     (NULL, &info->hash->table, h->root.string)));
1783             if (sub == NULL)
1784               return FALSE;
1785             *sub = *h;
1786             sub->type = bfd_link_hash_warning;
1787             sub->u.i.link = h;
1788             if (! copy)
1789               sub->u.i.warning = string;
1790             else
1791               {
1792                 char *w;
1793                 size_t len = strlen (string) + 1;
1794
1795                 w = (char *) bfd_hash_allocate (&info->hash->table, len);
1796                 if (w == NULL)
1797                   return FALSE;
1798                 memcpy (w, string, len);
1799                 sub->u.i.warning = w;
1800               }
1801
1802             bfd_hash_replace (&info->hash->table,
1803                               (struct bfd_hash_entry *) h,
1804                               (struct bfd_hash_entry *) sub);
1805             if (hashp != NULL)
1806               *hashp = sub;
1807           }
1808           break;
1809         }
1810     }
1811   while (cycle);
1812
1813   return TRUE;
1814 }
1815 \f
1816 /* Generic final link routine.  */
1817
1818 bfd_boolean
1819 _bfd_generic_final_link (bfd *abfd, struct bfd_link_info *info)
1820 {
1821   bfd *sub;
1822   asection *o;
1823   struct bfd_link_order *p;
1824   size_t outsymalloc;
1825   struct generic_write_global_symbol_info wginfo;
1826
1827   bfd_get_outsymbols (abfd) = NULL;
1828   bfd_get_symcount (abfd) = 0;
1829   outsymalloc = 0;
1830
1831   /* Mark all sections which will be included in the output file.  */
1832   for (o = abfd->sections; o != NULL; o = o->next)
1833     for (p = o->map_head.link_order; p != NULL; p = p->next)
1834       if (p->type == bfd_indirect_link_order)
1835         p->u.indirect.section->linker_mark = TRUE;
1836
1837   /* Build the output symbol table.  */
1838   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
1839     if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
1840       return FALSE;
1841
1842   /* Accumulate the global symbols.  */
1843   wginfo.info = info;
1844   wginfo.output_bfd = abfd;
1845   wginfo.psymalloc = &outsymalloc;
1846   _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info),
1847                                    _bfd_generic_link_write_global_symbol,
1848                                    &wginfo);
1849
1850   /* Make sure we have a trailing NULL pointer on OUTSYMBOLS.  We
1851      shouldn't really need one, since we have SYMCOUNT, but some old
1852      code still expects one.  */
1853   if (! generic_add_output_symbol (abfd, &outsymalloc, NULL))
1854     return FALSE;
1855
1856   if (bfd_link_relocatable (info))
1857     {
1858       /* Allocate space for the output relocs for each section.  */
1859       for (o = abfd->sections; o != NULL; o = o->next)
1860         {
1861           o->reloc_count = 0;
1862           for (p = o->map_head.link_order; p != NULL; p = p->next)
1863             {
1864               if (p->type == bfd_section_reloc_link_order
1865                   || p->type == bfd_symbol_reloc_link_order)
1866                 ++o->reloc_count;
1867               else if (p->type == bfd_indirect_link_order)
1868                 {
1869                   asection *input_section;
1870                   bfd *input_bfd;
1871                   long relsize;
1872                   arelent **relocs;
1873                   asymbol **symbols;
1874                   long reloc_count;
1875
1876                   input_section = p->u.indirect.section;
1877                   input_bfd = input_section->owner;
1878                   relsize = bfd_get_reloc_upper_bound (input_bfd,
1879                                                        input_section);
1880                   if (relsize < 0)
1881                     return FALSE;
1882                   relocs = (arelent **) bfd_malloc (relsize);
1883                   if (!relocs && relsize != 0)
1884                     return FALSE;
1885                   symbols = _bfd_generic_link_get_symbols (input_bfd);
1886                   reloc_count = bfd_canonicalize_reloc (input_bfd,
1887                                                         input_section,
1888                                                         relocs,
1889                                                         symbols);
1890                   free (relocs);
1891                   if (reloc_count < 0)
1892                     return FALSE;
1893                   BFD_ASSERT ((unsigned long) reloc_count
1894                               == input_section->reloc_count);
1895                   o->reloc_count += reloc_count;
1896                 }
1897             }
1898           if (o->reloc_count > 0)
1899             {
1900               bfd_size_type amt;
1901
1902               amt = o->reloc_count;
1903               amt *= sizeof (arelent *);
1904               o->orelocation = (struct reloc_cache_entry **) bfd_alloc (abfd, amt);
1905               if (!o->orelocation)
1906                 return FALSE;
1907               o->flags |= SEC_RELOC;
1908               /* Reset the count so that it can be used as an index
1909                  when putting in the output relocs.  */
1910               o->reloc_count = 0;
1911             }
1912         }
1913     }
1914
1915   /* Handle all the link order information for the sections.  */
1916   for (o = abfd->sections; o != NULL; o = o->next)
1917     {
1918       for (p = o->map_head.link_order; p != NULL; p = p->next)
1919         {
1920           switch (p->type)
1921             {
1922             case bfd_section_reloc_link_order:
1923             case bfd_symbol_reloc_link_order:
1924               if (! _bfd_generic_reloc_link_order (abfd, info, o, p))
1925                 return FALSE;
1926               break;
1927             case bfd_indirect_link_order:
1928               if (! default_indirect_link_order (abfd, info, o, p, TRUE))
1929                 return FALSE;
1930               break;
1931             default:
1932               if (! _bfd_default_link_order (abfd, info, o, p))
1933                 return FALSE;
1934               break;
1935             }
1936         }
1937     }
1938
1939   return TRUE;
1940 }
1941
1942 /* Add an output symbol to the output BFD.  */
1943
1944 static bfd_boolean
1945 generic_add_output_symbol (bfd *output_bfd, size_t *psymalloc, asymbol *sym)
1946 {
1947   if (bfd_get_symcount (output_bfd) >= *psymalloc)
1948     {
1949       asymbol **newsyms;
1950       bfd_size_type amt;
1951
1952       if (*psymalloc == 0)
1953         *psymalloc = 124;
1954       else
1955         *psymalloc *= 2;
1956       amt = *psymalloc;
1957       amt *= sizeof (asymbol *);
1958       newsyms = (asymbol **) bfd_realloc (bfd_get_outsymbols (output_bfd), amt);
1959       if (newsyms == NULL)
1960         return FALSE;
1961       bfd_get_outsymbols (output_bfd) = newsyms;
1962     }
1963
1964   bfd_get_outsymbols (output_bfd) [bfd_get_symcount (output_bfd)] = sym;
1965   if (sym != NULL)
1966     ++ bfd_get_symcount (output_bfd);
1967
1968   return TRUE;
1969 }
1970
1971 /* Handle the symbols for an input BFD.  */
1972
1973 bfd_boolean
1974 _bfd_generic_link_output_symbols (bfd *output_bfd,
1975                                   bfd *input_bfd,
1976                                   struct bfd_link_info *info,
1977                                   size_t *psymalloc)
1978 {
1979   asymbol **sym_ptr;
1980   asymbol **sym_end;
1981
1982   if (!bfd_generic_link_read_symbols (input_bfd))
1983     return FALSE;
1984
1985   /* Create a filename symbol if we are supposed to.  */
1986   if (info->create_object_symbols_section != NULL)
1987     {
1988       asection *sec;
1989
1990       for (sec = input_bfd->sections; sec != NULL; sec = sec->next)
1991         {
1992           if (sec->output_section == info->create_object_symbols_section)
1993             {
1994               asymbol *newsym;
1995
1996               newsym = bfd_make_empty_symbol (input_bfd);
1997               if (!newsym)
1998                 return FALSE;
1999               newsym->name = input_bfd->filename;
2000               newsym->value = 0;
2001               newsym->flags = BSF_LOCAL | BSF_FILE;
2002               newsym->section = sec;
2003
2004               if (! generic_add_output_symbol (output_bfd, psymalloc,
2005                                                newsym))
2006                 return FALSE;
2007
2008               break;
2009             }
2010         }
2011     }
2012
2013   /* Adjust the values of the globally visible symbols, and write out
2014      local symbols.  */
2015   sym_ptr = _bfd_generic_link_get_symbols (input_bfd);
2016   sym_end = sym_ptr + _bfd_generic_link_get_symcount (input_bfd);
2017   for (; sym_ptr < sym_end; sym_ptr++)
2018     {
2019       asymbol *sym;
2020       struct generic_link_hash_entry *h;
2021       bfd_boolean output;
2022
2023       h = NULL;
2024       sym = *sym_ptr;
2025       if ((sym->flags & (BSF_INDIRECT
2026                          | BSF_WARNING
2027                          | BSF_GLOBAL
2028                          | BSF_CONSTRUCTOR
2029                          | BSF_WEAK)) != 0
2030           || bfd_is_und_section (bfd_get_section (sym))
2031           || bfd_is_com_section (bfd_get_section (sym))
2032           || bfd_is_ind_section (bfd_get_section (sym)))
2033         {
2034           if (sym->udata.p != NULL)
2035             h = (struct generic_link_hash_entry *) sym->udata.p;
2036           else if ((sym->flags & BSF_CONSTRUCTOR) != 0)
2037             {
2038               /* This case normally means that the main linker code
2039                  deliberately ignored this constructor symbol.  We
2040                  should just pass it through.  This will screw up if
2041                  the constructor symbol is from a different,
2042                  non-generic, object file format, but the case will
2043                  only arise when linking with -r, which will probably
2044                  fail anyhow, since there will be no way to represent
2045                  the relocs in the output format being used.  */
2046               h = NULL;
2047             }
2048           else if (bfd_is_und_section (bfd_get_section (sym)))
2049             h = ((struct generic_link_hash_entry *)
2050                  bfd_wrapped_link_hash_lookup (output_bfd, info,
2051                                                bfd_asymbol_name (sym),
2052                                                FALSE, FALSE, TRUE));
2053           else
2054             h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
2055                                                bfd_asymbol_name (sym),
2056                                                FALSE, FALSE, TRUE);
2057
2058           if (h != NULL)
2059             {
2060               /* Force all references to this symbol to point to
2061                  the same area in memory.  It is possible that
2062                  this routine will be called with a hash table
2063                  other than a generic hash table, so we double
2064                  check that.  */
2065               if (info->output_bfd->xvec == input_bfd->xvec)
2066                 {
2067                   if (h->sym != NULL)
2068                     *sym_ptr = sym = h->sym;
2069                 }
2070
2071               switch (h->root.type)
2072                 {
2073                 default:
2074                 case bfd_link_hash_new:
2075                   abort ();
2076                 case bfd_link_hash_undefined:
2077                   break;
2078                 case bfd_link_hash_undefweak:
2079                   sym->flags |= BSF_WEAK;
2080                   break;
2081                 case bfd_link_hash_indirect:
2082                   h = (struct generic_link_hash_entry *) h->root.u.i.link;
2083                   /* fall through */
2084                 case bfd_link_hash_defined:
2085                   sym->flags |= BSF_GLOBAL;
2086                   sym->flags &=~ (BSF_WEAK | BSF_CONSTRUCTOR);
2087                   sym->value = h->root.u.def.value;
2088                   sym->section = h->root.u.def.section;
2089                   break;
2090                 case bfd_link_hash_defweak:
2091                   sym->flags |= BSF_WEAK;
2092                   sym->flags &=~ BSF_CONSTRUCTOR;
2093                   sym->value = h->root.u.def.value;
2094                   sym->section = h->root.u.def.section;
2095                   break;
2096                 case bfd_link_hash_common:
2097                   sym->value = h->root.u.c.size;
2098                   sym->flags |= BSF_GLOBAL;
2099                   if (! bfd_is_com_section (sym->section))
2100                     {
2101                       BFD_ASSERT (bfd_is_und_section (sym->section));
2102                       sym->section = bfd_com_section_ptr;
2103                     }
2104                   /* We do not set the section of the symbol to
2105                      h->root.u.c.p->section.  That value was saved so
2106                      that we would know where to allocate the symbol
2107                      if it was defined.  In this case the type is
2108                      still bfd_link_hash_common, so we did not define
2109                      it, so we do not want to use that section.  */
2110                   break;
2111                 }
2112             }
2113         }
2114
2115       /* This switch is straight from the old code in
2116          write_file_locals in ldsym.c.  */
2117       if (info->strip == strip_all
2118           || (info->strip == strip_some
2119               && bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym),
2120                                   FALSE, FALSE) == NULL))
2121         output = FALSE;
2122       else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0)
2123         {
2124           /* If this symbol is marked as occurring now, rather
2125              than at the end, output it now.  This is used for
2126              COFF C_EXT FCN symbols.  FIXME: There must be a
2127              better way.  */
2128           if (bfd_asymbol_bfd (sym) == input_bfd
2129               && (sym->flags & BSF_NOT_AT_END) != 0)
2130             output = TRUE;
2131           else
2132             output = FALSE;
2133         }
2134       else if (bfd_is_ind_section (sym->section))
2135         output = FALSE;
2136       else if ((sym->flags & BSF_DEBUGGING) != 0)
2137         {
2138           if (info->strip == strip_none)
2139             output = TRUE;
2140           else
2141             output = FALSE;
2142         }
2143       else if (bfd_is_und_section (sym->section)
2144                || bfd_is_com_section (sym->section))
2145         output = FALSE;
2146       else if ((sym->flags & BSF_LOCAL) != 0)
2147         {
2148           if ((sym->flags & BSF_WARNING) != 0)
2149             output = FALSE;
2150           else
2151             {
2152               switch (info->discard)
2153                 {
2154                 default:
2155                 case discard_all:
2156                   output = FALSE;
2157                   break;
2158                 case discard_sec_merge:
2159                   output = TRUE;
2160                   if (bfd_link_relocatable (info)
2161                       || ! (sym->section->flags & SEC_MERGE))
2162                     break;
2163                   /* FALLTHROUGH */
2164                 case discard_l:
2165                   if (bfd_is_local_label (input_bfd, sym))
2166                     output = FALSE;
2167                   else
2168                     output = TRUE;
2169                   break;
2170                 case discard_none:
2171                   output = TRUE;
2172                   break;
2173                 }
2174             }
2175         }
2176       else if ((sym->flags & BSF_CONSTRUCTOR))
2177         {
2178           if (info->strip != strip_all)
2179             output = TRUE;
2180           else
2181             output = FALSE;
2182         }
2183       else if (sym->flags == 0
2184                && (sym->section->owner->flags & BFD_PLUGIN) != 0)
2185         /* LTO doesn't set symbol information.  We get here with the
2186            generic linker for a symbol that was "common" but no longer
2187            needs to be global.  */
2188         output = FALSE;
2189       else
2190         abort ();
2191
2192       /* If this symbol is in a section which is not being included
2193          in the output file, then we don't want to output the
2194          symbol.  */
2195       if (!bfd_is_abs_section (sym->section)
2196           && bfd_section_removed_from_list (output_bfd,
2197                                             sym->section->output_section))
2198         output = FALSE;
2199
2200       if (output)
2201         {
2202           if (! generic_add_output_symbol (output_bfd, psymalloc, sym))
2203             return FALSE;
2204           if (h != NULL)
2205             h->written = TRUE;
2206         }
2207     }
2208
2209   return TRUE;
2210 }
2211
2212 /* Set the section and value of a generic BFD symbol based on a linker
2213    hash table entry.  */
2214
2215 static void
2216 set_symbol_from_hash (asymbol *sym, struct bfd_link_hash_entry *h)
2217 {
2218   switch (h->type)
2219     {
2220     default:
2221       abort ();
2222       break;
2223     case bfd_link_hash_new:
2224       /* This can happen when a constructor symbol is seen but we are
2225          not building constructors.  */
2226       if (sym->section != NULL)
2227         {
2228           BFD_ASSERT ((sym->flags & BSF_CONSTRUCTOR) != 0);
2229         }
2230       else
2231         {
2232           sym->flags |= BSF_CONSTRUCTOR;
2233           sym->section = bfd_abs_section_ptr;
2234           sym->value = 0;
2235         }
2236       break;
2237     case bfd_link_hash_undefined:
2238       sym->section = bfd_und_section_ptr;
2239       sym->value = 0;
2240       break;
2241     case bfd_link_hash_undefweak:
2242       sym->section = bfd_und_section_ptr;
2243       sym->value = 0;
2244       sym->flags |= BSF_WEAK;
2245       break;
2246     case bfd_link_hash_defined:
2247       sym->section = h->u.def.section;
2248       sym->value = h->u.def.value;
2249       break;
2250     case bfd_link_hash_defweak:
2251       sym->flags |= BSF_WEAK;
2252       sym->section = h->u.def.section;
2253       sym->value = h->u.def.value;
2254       break;
2255     case bfd_link_hash_common:
2256       sym->value = h->u.c.size;
2257       if (sym->section == NULL)
2258         sym->section = bfd_com_section_ptr;
2259       else if (! bfd_is_com_section (sym->section))
2260         {
2261           BFD_ASSERT (bfd_is_und_section (sym->section));
2262           sym->section = bfd_com_section_ptr;
2263         }
2264       /* Do not set the section; see _bfd_generic_link_output_symbols.  */
2265       break;
2266     case bfd_link_hash_indirect:
2267     case bfd_link_hash_warning:
2268       /* FIXME: What should we do here?  */
2269       break;
2270     }
2271 }
2272
2273 /* Write out a global symbol, if it hasn't already been written out.
2274    This is called for each symbol in the hash table.  */
2275
2276 bfd_boolean
2277 _bfd_generic_link_write_global_symbol (struct generic_link_hash_entry *h,
2278                                        void *data)
2279 {
2280   struct generic_write_global_symbol_info *wginfo =
2281       (struct generic_write_global_symbol_info *) data;
2282   asymbol *sym;
2283
2284   if (h->written)
2285     return TRUE;
2286
2287   h->written = TRUE;
2288
2289   if (wginfo->info->strip == strip_all
2290       || (wginfo->info->strip == strip_some
2291           && bfd_hash_lookup (wginfo->info->keep_hash, h->root.root.string,
2292                               FALSE, FALSE) == NULL))
2293     return TRUE;
2294
2295   if (h->sym != NULL)
2296     sym = h->sym;
2297   else
2298     {
2299       sym = bfd_make_empty_symbol (wginfo->output_bfd);
2300       if (!sym)
2301         return FALSE;
2302       sym->name = h->root.root.string;
2303       sym->flags = 0;
2304     }
2305
2306   set_symbol_from_hash (sym, &h->root);
2307
2308   sym->flags |= BSF_GLOBAL;
2309
2310   if (! generic_add_output_symbol (wginfo->output_bfd, wginfo->psymalloc,
2311                                    sym))
2312     {
2313       /* FIXME: No way to return failure.  */
2314       abort ();
2315     }
2316
2317   return TRUE;
2318 }
2319
2320 /* Create a relocation.  */
2321
2322 bfd_boolean
2323 _bfd_generic_reloc_link_order (bfd *abfd,
2324                                struct bfd_link_info *info,
2325                                asection *sec,
2326                                struct bfd_link_order *link_order)
2327 {
2328   arelent *r;
2329
2330   if (! bfd_link_relocatable (info))
2331     abort ();
2332   if (sec->orelocation == NULL)
2333     abort ();
2334
2335   r = (arelent *) bfd_alloc (abfd, sizeof (arelent));
2336   if (r == NULL)
2337     return FALSE;
2338
2339   r->address = link_order->offset;
2340   r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc);
2341   if (r->howto == 0)
2342     {
2343       bfd_set_error (bfd_error_bad_value);
2344       return FALSE;
2345     }
2346
2347   /* Get the symbol to use for the relocation.  */
2348   if (link_order->type == bfd_section_reloc_link_order)
2349     r->sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
2350   else
2351     {
2352       struct generic_link_hash_entry *h;
2353
2354       h = ((struct generic_link_hash_entry *)
2355            bfd_wrapped_link_hash_lookup (abfd, info,
2356                                          link_order->u.reloc.p->u.name,
2357                                          FALSE, FALSE, TRUE));
2358       if (h == NULL
2359           || ! h->written)
2360         {
2361           (*info->callbacks->unattached_reloc)
2362             (info, link_order->u.reloc.p->u.name, NULL, NULL, 0);
2363           bfd_set_error (bfd_error_bad_value);
2364           return FALSE;
2365         }
2366       r->sym_ptr_ptr = &h->sym;
2367     }
2368
2369   /* If this is an inplace reloc, write the addend to the object file.
2370      Otherwise, store it in the reloc addend.  */
2371   if (! r->howto->partial_inplace)
2372     r->addend = link_order->u.reloc.p->addend;
2373   else
2374     {
2375       bfd_size_type size;
2376       bfd_reloc_status_type rstat;
2377       bfd_byte *buf;
2378       bfd_boolean ok;
2379       file_ptr loc;
2380
2381       size = bfd_get_reloc_size (r->howto);
2382       buf = (bfd_byte *) bfd_zmalloc (size);
2383       if (buf == NULL && size != 0)
2384         return FALSE;
2385       rstat = _bfd_relocate_contents (r->howto, abfd,
2386                                       (bfd_vma) link_order->u.reloc.p->addend,
2387                                       buf);
2388       switch (rstat)
2389         {
2390         case bfd_reloc_ok:
2391           break;
2392         default:
2393         case bfd_reloc_outofrange:
2394           abort ();
2395         case bfd_reloc_overflow:
2396           (*info->callbacks->reloc_overflow)
2397             (info, NULL,
2398              (link_order->type == bfd_section_reloc_link_order
2399               ? bfd_section_name (abfd, link_order->u.reloc.p->u.section)
2400               : link_order->u.reloc.p->u.name),
2401              r->howto->name, link_order->u.reloc.p->addend,
2402              NULL, NULL, 0);
2403           break;
2404         }
2405       loc = link_order->offset * bfd_octets_per_byte (abfd);
2406       ok = bfd_set_section_contents (abfd, sec, buf, loc, size);
2407       free (buf);
2408       if (! ok)
2409         return FALSE;
2410
2411       r->addend = 0;
2412     }
2413
2414   sec->orelocation[sec->reloc_count] = r;
2415   ++sec->reloc_count;
2416
2417   return TRUE;
2418 }
2419 \f
2420 /* Allocate a new link_order for a section.  */
2421
2422 struct bfd_link_order *
2423 bfd_new_link_order (bfd *abfd, asection *section)
2424 {
2425   bfd_size_type amt = sizeof (struct bfd_link_order);
2426   struct bfd_link_order *new_lo;
2427
2428   new_lo = (struct bfd_link_order *) bfd_zalloc (abfd, amt);
2429   if (!new_lo)
2430     return NULL;
2431
2432   new_lo->type = bfd_undefined_link_order;
2433
2434   if (section->map_tail.link_order != NULL)
2435     section->map_tail.link_order->next = new_lo;
2436   else
2437     section->map_head.link_order = new_lo;
2438   section->map_tail.link_order = new_lo;
2439
2440   return new_lo;
2441 }
2442
2443 /* Default link order processing routine.  Note that we can not handle
2444    the reloc_link_order types here, since they depend upon the details
2445    of how the particular backends generates relocs.  */
2446
2447 bfd_boolean
2448 _bfd_default_link_order (bfd *abfd,
2449                          struct bfd_link_info *info,
2450                          asection *sec,
2451                          struct bfd_link_order *link_order)
2452 {
2453   switch (link_order->type)
2454     {
2455     case bfd_undefined_link_order:
2456     case bfd_section_reloc_link_order:
2457     case bfd_symbol_reloc_link_order:
2458     default:
2459       abort ();
2460     case bfd_indirect_link_order:
2461       return default_indirect_link_order (abfd, info, sec, link_order,
2462                                           FALSE);
2463     case bfd_data_link_order:
2464       return default_data_link_order (abfd, info, sec, link_order);
2465     }
2466 }
2467
2468 /* Default routine to handle a bfd_data_link_order.  */
2469
2470 static bfd_boolean
2471 default_data_link_order (bfd *abfd,
2472                          struct bfd_link_info *info ATTRIBUTE_UNUSED,
2473                          asection *sec,
2474                          struct bfd_link_order *link_order)
2475 {
2476   bfd_size_type size;
2477   size_t fill_size;
2478   bfd_byte *fill;
2479   file_ptr loc;
2480   bfd_boolean result;
2481
2482   BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0);
2483
2484   size = link_order->size;
2485   if (size == 0)
2486     return TRUE;
2487
2488   fill = link_order->u.data.contents;
2489   fill_size = link_order->u.data.size;
2490   if (fill_size == 0)
2491     {
2492       fill = abfd->arch_info->fill (size, bfd_big_endian (abfd),
2493                                     (sec->flags & SEC_CODE) != 0);
2494       if (fill == NULL)
2495         return FALSE;
2496     }
2497   else if (fill_size < size)
2498     {
2499       bfd_byte *p;
2500       fill = (bfd_byte *) bfd_malloc (size);
2501       if (fill == NULL)
2502         return FALSE;
2503       p = fill;
2504       if (fill_size == 1)
2505         memset (p, (int) link_order->u.data.contents[0], (size_t) size);
2506       else
2507         {
2508           do
2509             {
2510               memcpy (p, link_order->u.data.contents, fill_size);
2511               p += fill_size;
2512               size -= fill_size;
2513             }
2514           while (size >= fill_size);
2515           if (size != 0)
2516             memcpy (p, link_order->u.data.contents, (size_t) size);
2517           size = link_order->size;
2518         }
2519     }
2520
2521   loc = link_order->offset * bfd_octets_per_byte (abfd);
2522   result = bfd_set_section_contents (abfd, sec, fill, loc, size);
2523
2524   if (fill != link_order->u.data.contents)
2525     free (fill);
2526   return result;
2527 }
2528
2529 /* Default routine to handle a bfd_indirect_link_order.  */
2530
2531 static bfd_boolean
2532 default_indirect_link_order (bfd *output_bfd,
2533                              struct bfd_link_info *info,
2534                              asection *output_section,
2535                              struct bfd_link_order *link_order,
2536                              bfd_boolean generic_linker)
2537 {
2538   asection *input_section;
2539   bfd *input_bfd;
2540   bfd_byte *contents = NULL;
2541   bfd_byte *new_contents;
2542   bfd_size_type sec_size;
2543   file_ptr loc;
2544
2545   BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
2546
2547   input_section = link_order->u.indirect.section;
2548   input_bfd = input_section->owner;
2549   if (input_section->size == 0)
2550     return TRUE;
2551
2552   BFD_ASSERT (input_section->output_section == output_section);
2553   BFD_ASSERT (input_section->output_offset == link_order->offset);
2554   BFD_ASSERT (input_section->size == link_order->size);
2555
2556   if (bfd_link_relocatable (info)
2557       && input_section->reloc_count > 0
2558       && output_section->orelocation == NULL)
2559     {
2560       /* Space has not been allocated for the output relocations.
2561          This can happen when we are called by a specific backend
2562          because somebody is attempting to link together different
2563          types of object files.  Handling this case correctly is
2564          difficult, and sometimes impossible.  */
2565       _bfd_error_handler
2566         /* xgettext:c-format */
2567         (_("attempt to do relocatable link with %s input and %s output"),
2568          bfd_get_target (input_bfd), bfd_get_target (output_bfd));
2569       bfd_set_error (bfd_error_wrong_format);
2570       return FALSE;
2571     }
2572
2573   if (! generic_linker)
2574     {
2575       asymbol **sympp;
2576       asymbol **symppend;
2577
2578       /* Get the canonical symbols.  The generic linker will always
2579          have retrieved them by this point, but we are being called by
2580          a specific linker, presumably because we are linking
2581          different types of object files together.  */
2582       if (!bfd_generic_link_read_symbols (input_bfd))
2583         return FALSE;
2584
2585       /* Since we have been called by a specific linker, rather than
2586          the generic linker, the values of the symbols will not be
2587          right.  They will be the values as seen in the input file,
2588          not the values of the final link.  We need to fix them up
2589          before we can relocate the section.  */
2590       sympp = _bfd_generic_link_get_symbols (input_bfd);
2591       symppend = sympp + _bfd_generic_link_get_symcount (input_bfd);
2592       for (; sympp < symppend; sympp++)
2593         {
2594           asymbol *sym;
2595           struct bfd_link_hash_entry *h;
2596
2597           sym = *sympp;
2598
2599           if ((sym->flags & (BSF_INDIRECT
2600                              | BSF_WARNING
2601                              | BSF_GLOBAL
2602                              | BSF_CONSTRUCTOR
2603                              | BSF_WEAK)) != 0
2604               || bfd_is_und_section (bfd_get_section (sym))
2605               || bfd_is_com_section (bfd_get_section (sym))
2606               || bfd_is_ind_section (bfd_get_section (sym)))
2607             {
2608               /* sym->udata may have been set by
2609                  generic_link_add_symbol_list.  */
2610               if (sym->udata.p != NULL)
2611                 h = (struct bfd_link_hash_entry *) sym->udata.p;
2612               else if (bfd_is_und_section (bfd_get_section (sym)))
2613                 h = bfd_wrapped_link_hash_lookup (output_bfd, info,
2614                                                   bfd_asymbol_name (sym),
2615                                                   FALSE, FALSE, TRUE);
2616               else
2617                 h = bfd_link_hash_lookup (info->hash,
2618                                           bfd_asymbol_name (sym),
2619                                           FALSE, FALSE, TRUE);
2620               if (h != NULL)
2621                 set_symbol_from_hash (sym, h);
2622             }
2623         }
2624     }
2625
2626   if ((output_section->flags & (SEC_GROUP | SEC_LINKER_CREATED)) == SEC_GROUP
2627       && input_section->size != 0)
2628     {
2629       /* Group section contents are set by bfd_elf_set_group_contents.  */
2630       if (!output_bfd->output_has_begun)
2631         {
2632           /* FIXME: This hack ensures bfd_elf_set_group_contents is called.  */
2633           if (!bfd_set_section_contents (output_bfd, output_section, "", 0, 1))
2634             goto error_return;
2635         }
2636       new_contents = output_section->contents;
2637       BFD_ASSERT (new_contents != NULL);
2638       BFD_ASSERT (input_section->output_offset == 0);
2639     }
2640   else
2641     {
2642       /* Get and relocate the section contents.  */
2643       sec_size = (input_section->rawsize > input_section->size
2644                   ? input_section->rawsize
2645                   : input_section->size);
2646       contents = (bfd_byte *) bfd_malloc (sec_size);
2647       if (contents == NULL && sec_size != 0)
2648         goto error_return;
2649       new_contents = (bfd_get_relocated_section_contents
2650                       (output_bfd, info, link_order, contents,
2651                        bfd_link_relocatable (info),
2652                        _bfd_generic_link_get_symbols (input_bfd)));
2653       if (!new_contents)
2654         goto error_return;
2655     }
2656
2657   /* Output the section contents.  */
2658   loc = input_section->output_offset * bfd_octets_per_byte (output_bfd);
2659   if (! bfd_set_section_contents (output_bfd, output_section,
2660                                   new_contents, loc, input_section->size))
2661     goto error_return;
2662
2663   if (contents != NULL)
2664     free (contents);
2665   return TRUE;
2666
2667  error_return:
2668   if (contents != NULL)
2669     free (contents);
2670   return FALSE;
2671 }
2672
2673 /* A little routine to count the number of relocs in a link_order
2674    list.  */
2675
2676 unsigned int
2677 _bfd_count_link_order_relocs (struct bfd_link_order *link_order)
2678 {
2679   register unsigned int c;
2680   register struct bfd_link_order *l;
2681
2682   c = 0;
2683   for (l = link_order; l != NULL; l = l->next)
2684     {
2685       if (l->type == bfd_section_reloc_link_order
2686           || l->type == bfd_symbol_reloc_link_order)
2687         ++c;
2688     }
2689
2690   return c;
2691 }
2692
2693 /*
2694 FUNCTION
2695         bfd_link_split_section
2696
2697 SYNOPSIS
2698         bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);
2699
2700 DESCRIPTION
2701         Return nonzero if @var{sec} should be split during a
2702         reloceatable or final link.
2703
2704 .#define bfd_link_split_section(abfd, sec) \
2705 .       BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
2706 .
2707
2708 */
2709
2710 bfd_boolean
2711 _bfd_generic_link_split_section (bfd *abfd ATTRIBUTE_UNUSED,
2712                                  asection *sec ATTRIBUTE_UNUSED)
2713 {
2714   return FALSE;
2715 }
2716
2717 /*
2718 FUNCTION
2719         bfd_section_already_linked
2720
2721 SYNOPSIS
2722         bfd_boolean bfd_section_already_linked (bfd *abfd,
2723                                                 asection *sec,
2724                                                 struct bfd_link_info *info);
2725
2726 DESCRIPTION
2727         Check if @var{data} has been already linked during a reloceatable
2728         or final link.  Return TRUE if it has.
2729
2730 .#define bfd_section_already_linked(abfd, sec, info) \
2731 .       BFD_SEND (abfd, _section_already_linked, (abfd, sec, info))
2732 .
2733
2734 */
2735
2736 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
2737    once into the output.  This routine checks each section, and
2738    arrange to discard it if a section of the same name has already
2739    been linked.  This code assumes that all relevant sections have the
2740    SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
2741    section name.  bfd_section_already_linked is called via
2742    bfd_map_over_sections.  */
2743
2744 /* The hash table.  */
2745
2746 static struct bfd_hash_table _bfd_section_already_linked_table;
2747
2748 /* Support routines for the hash table used by section_already_linked,
2749    initialize the table, traverse, lookup, fill in an entry and remove
2750    the table.  */
2751
2752 void
2753 bfd_section_already_linked_table_traverse
2754   (bfd_boolean (*func) (struct bfd_section_already_linked_hash_entry *,
2755                         void *), void *info)
2756 {
2757   bfd_hash_traverse (&_bfd_section_already_linked_table,
2758                      (bfd_boolean (*) (struct bfd_hash_entry *,
2759                                        void *)) func,
2760                      info);
2761 }
2762
2763 struct bfd_section_already_linked_hash_entry *
2764 bfd_section_already_linked_table_lookup (const char *name)
2765 {
2766   return ((struct bfd_section_already_linked_hash_entry *)
2767           bfd_hash_lookup (&_bfd_section_already_linked_table, name,
2768                            TRUE, FALSE));
2769 }
2770
2771 bfd_boolean
2772 bfd_section_already_linked_table_insert
2773   (struct bfd_section_already_linked_hash_entry *already_linked_list,
2774    asection *sec)
2775 {
2776   struct bfd_section_already_linked *l;
2777
2778   /* Allocate the memory from the same obstack as the hash table is
2779      kept in.  */
2780   l = (struct bfd_section_already_linked *)
2781       bfd_hash_allocate (&_bfd_section_already_linked_table, sizeof *l);
2782   if (l == NULL)
2783     return FALSE;
2784   l->sec = sec;
2785   l->next = already_linked_list->entry;
2786   already_linked_list->entry = l;
2787   return TRUE;
2788 }
2789
2790 static struct bfd_hash_entry *
2791 already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED,
2792                         struct bfd_hash_table *table,
2793                         const char *string ATTRIBUTE_UNUSED)
2794 {
2795   struct bfd_section_already_linked_hash_entry *ret =
2796     (struct bfd_section_already_linked_hash_entry *)
2797       bfd_hash_allocate (table, sizeof *ret);
2798
2799   if (ret == NULL)
2800     return NULL;
2801
2802   ret->entry = NULL;
2803
2804   return &ret->root;
2805 }
2806
2807 bfd_boolean
2808 bfd_section_already_linked_table_init (void)
2809 {
2810   return bfd_hash_table_init_n (&_bfd_section_already_linked_table,
2811                                 already_linked_newfunc,
2812                                 sizeof (struct bfd_section_already_linked_hash_entry),
2813                                 42);
2814 }
2815
2816 void
2817 bfd_section_already_linked_table_free (void)
2818 {
2819   bfd_hash_table_free (&_bfd_section_already_linked_table);
2820 }
2821
2822 /* Report warnings as appropriate for duplicate section SEC.
2823    Return FALSE if we decide to keep SEC after all.  */
2824
2825 bfd_boolean
2826 _bfd_handle_already_linked (asection *sec,
2827                             struct bfd_section_already_linked *l,
2828                             struct bfd_link_info *info)
2829 {
2830   switch (sec->flags & SEC_LINK_DUPLICATES)
2831     {
2832     default:
2833       abort ();
2834
2835     case SEC_LINK_DUPLICATES_DISCARD:
2836       /* If we found an LTO IR match for this comdat group on
2837          the first pass, replace it with the LTO output on the
2838          second pass.  We can't simply choose real object
2839          files over IR because the first pass may contain a
2840          mix of LTO and normal objects and we must keep the
2841          first match, be it IR or real.  */
2842       if (sec->owner->lto_output
2843           && (l->sec->owner->flags & BFD_PLUGIN) != 0)
2844         {
2845           l->sec = sec;
2846           return FALSE;
2847         }
2848       break;
2849
2850     case SEC_LINK_DUPLICATES_ONE_ONLY:
2851       info->callbacks->einfo
2852         /* xgettext:c-format */
2853         (_("%pB: ignoring duplicate section `%pA'\n"),
2854          sec->owner, sec);
2855       break;
2856
2857     case SEC_LINK_DUPLICATES_SAME_SIZE:
2858       if ((l->sec->owner->flags & BFD_PLUGIN) != 0)
2859         ;
2860       else if (sec->size != l->sec->size)
2861         info->callbacks->einfo
2862           /* xgettext:c-format */
2863           (_("%pB: duplicate section `%pA' has different size\n"),
2864            sec->owner, sec);
2865       break;
2866
2867     case SEC_LINK_DUPLICATES_SAME_CONTENTS:
2868       if ((l->sec->owner->flags & BFD_PLUGIN) != 0)
2869         ;
2870       else if (sec->size != l->sec->size)
2871         info->callbacks->einfo
2872           /* xgettext:c-format */
2873           (_("%pB: duplicate section `%pA' has different size\n"),
2874            sec->owner, sec);
2875       else if (sec->size != 0)
2876         {
2877           bfd_byte *sec_contents, *l_sec_contents = NULL;
2878
2879           if (!bfd_malloc_and_get_section (sec->owner, sec, &sec_contents))
2880             info->callbacks->einfo
2881               /* xgettext:c-format */
2882               (_("%pB: could not read contents of section `%pA'\n"),
2883                sec->owner, sec);
2884           else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec,
2885                                                 &l_sec_contents))
2886             info->callbacks->einfo
2887               /* xgettext:c-format */
2888               (_("%pB: could not read contents of section `%pA'\n"),
2889                l->sec->owner, l->sec);
2890           else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0)
2891             info->callbacks->einfo
2892               /* xgettext:c-format */
2893               (_("%pB: duplicate section `%pA' has different contents\n"),
2894                sec->owner, sec);
2895
2896           if (sec_contents)
2897             free (sec_contents);
2898           if (l_sec_contents)
2899             free (l_sec_contents);
2900         }
2901       break;
2902     }
2903
2904   /* Set the output_section field so that lang_add_section
2905      does not create a lang_input_section structure for this
2906      section.  Since there might be a symbol in the section
2907      being discarded, we must retain a pointer to the section
2908      which we are really going to use.  */
2909   sec->output_section = bfd_abs_section_ptr;
2910   sec->kept_section = l->sec;
2911   return TRUE;
2912 }
2913
2914 /* This is used on non-ELF inputs.  */
2915
2916 bfd_boolean
2917 _bfd_generic_section_already_linked (bfd *abfd ATTRIBUTE_UNUSED,
2918                                      asection *sec,
2919                                      struct bfd_link_info *info)
2920 {
2921   const char *name;
2922   struct bfd_section_already_linked *l;
2923   struct bfd_section_already_linked_hash_entry *already_linked_list;
2924
2925   if ((sec->flags & SEC_LINK_ONCE) == 0)
2926     return FALSE;
2927
2928   /* The generic linker doesn't handle section groups.  */
2929   if ((sec->flags & SEC_GROUP) != 0)
2930     return FALSE;
2931
2932   /* FIXME: When doing a relocatable link, we may have trouble
2933      copying relocations in other sections that refer to local symbols
2934      in the section being discarded.  Those relocations will have to
2935      be converted somehow; as of this writing I'm not sure that any of
2936      the backends handle that correctly.
2937
2938      It is tempting to instead not discard link once sections when
2939      doing a relocatable link (technically, they should be discarded
2940      whenever we are building constructors).  However, that fails,
2941      because the linker winds up combining all the link once sections
2942      into a single large link once section, which defeats the purpose
2943      of having link once sections in the first place.  */
2944
2945   name = bfd_get_section_name (abfd, sec);
2946
2947   already_linked_list = bfd_section_already_linked_table_lookup (name);
2948
2949   l = already_linked_list->entry;
2950   if (l != NULL)
2951     {
2952       /* The section has already been linked.  See if we should
2953          issue a warning.  */
2954       return _bfd_handle_already_linked (sec, l, info);
2955     }
2956
2957   /* This is the first section with this name.  Record it.  */
2958   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2959     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2960   return FALSE;
2961 }
2962
2963 /* Choose a neighbouring section to S in OBFD that will be output, or
2964    the absolute section if ADDR is out of bounds of the neighbours.  */
2965
2966 asection *
2967 _bfd_nearby_section (bfd *obfd, asection *s, bfd_vma addr)
2968 {
2969   asection *next, *prev, *best;
2970
2971   /* Find preceding kept section.  */
2972   for (prev = s->prev; prev != NULL; prev = prev->prev)
2973     if ((prev->flags & SEC_EXCLUDE) == 0
2974         && !bfd_section_removed_from_list (obfd, prev))
2975       break;
2976
2977   /* Find following kept section.  Start at prev->next because
2978      other sections may have been added after S was removed.  */
2979   if (s->prev != NULL)
2980     next = s->prev->next;
2981   else
2982     next = s->owner->sections;
2983   for (; next != NULL; next = next->next)
2984     if ((next->flags & SEC_EXCLUDE) == 0
2985         && !bfd_section_removed_from_list (obfd, next))
2986       break;
2987
2988   /* Choose better of two sections, based on flags.  The idea
2989      is to choose a section that will be in the same segment
2990      as S would have been if it was kept.  */
2991   best = next;
2992   if (prev == NULL)
2993     {
2994       if (next == NULL)
2995         best = bfd_abs_section_ptr;
2996     }
2997   else if (next == NULL)
2998     best = prev;
2999   else if (((prev->flags ^ next->flags)
3000             & (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_LOAD)) != 0)
3001     {
3002       if (((next->flags ^ s->flags)
3003            & (SEC_ALLOC | SEC_THREAD_LOCAL)) != 0
3004           /* We prefer to choose a loaded section.  Section S
3005              doesn't have SEC_LOAD set (it being excluded, that
3006              part of the flag processing didn't happen) so we
3007              can't compare that flag to those of NEXT and PREV.  */
3008           || ((prev->flags & SEC_LOAD) != 0
3009               && (next->flags & SEC_LOAD) == 0))
3010         best = prev;
3011     }
3012   else if (((prev->flags ^ next->flags) & SEC_READONLY) != 0)
3013     {
3014       if (((next->flags ^ s->flags) & SEC_READONLY) != 0)
3015         best = prev;
3016     }
3017   else if (((prev->flags ^ next->flags) & SEC_CODE) != 0)
3018     {
3019       if (((next->flags ^ s->flags) & SEC_CODE) != 0)
3020         best = prev;
3021     }
3022   else
3023     {
3024       /* Flags we care about are the same.  Prefer the following
3025          section if that will result in a positive valued sym.  */
3026       if (addr < next->vma)
3027         best = prev;
3028     }
3029
3030   return best;
3031 }
3032
3033 /* Convert symbols in excluded output sections to use a kept section.  */
3034
3035 static bfd_boolean
3036 fix_syms (struct bfd_link_hash_entry *h, void *data)
3037 {
3038   bfd *obfd = (bfd *) data;
3039
3040   if (h->type == bfd_link_hash_defined
3041       || h->type == bfd_link_hash_defweak)
3042     {
3043       asection *s = h->u.def.section;
3044       if (s != NULL
3045           && s->output_section != NULL
3046           && (s->output_section->flags & SEC_EXCLUDE) != 0
3047           && bfd_section_removed_from_list (obfd, s->output_section))
3048         {
3049           asection *op;
3050
3051           h->u.def.value += s->output_offset + s->output_section->vma;
3052           op = _bfd_nearby_section (obfd, s->output_section, h->u.def.value);
3053           h->u.def.value -= op->vma;
3054           h->u.def.section = op;
3055         }
3056     }
3057
3058   return TRUE;
3059 }
3060
3061 void
3062 _bfd_fix_excluded_sec_syms (bfd *obfd, struct bfd_link_info *info)
3063 {
3064   bfd_link_hash_traverse (info->hash, fix_syms, obfd);
3065 }
3066
3067 /*
3068 FUNCTION
3069         bfd_generic_define_common_symbol
3070
3071 SYNOPSIS
3072         bfd_boolean bfd_generic_define_common_symbol
3073           (bfd *output_bfd, struct bfd_link_info *info,
3074            struct bfd_link_hash_entry *h);
3075
3076 DESCRIPTION
3077         Convert common symbol @var{h} into a defined symbol.
3078         Return TRUE on success and FALSE on failure.
3079
3080 .#define bfd_define_common_symbol(output_bfd, info, h) \
3081 .       BFD_SEND (output_bfd, _bfd_define_common_symbol, (output_bfd, info, h))
3082 .
3083 */
3084
3085 bfd_boolean
3086 bfd_generic_define_common_symbol (bfd *output_bfd,
3087                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
3088                                   struct bfd_link_hash_entry *h)
3089 {
3090   unsigned int power_of_two;
3091   bfd_vma alignment, size;
3092   asection *section;
3093
3094   BFD_ASSERT (h != NULL && h->type == bfd_link_hash_common);
3095
3096   size = h->u.c.size;
3097   power_of_two = h->u.c.p->alignment_power;
3098   section = h->u.c.p->section;
3099
3100   /* Increase the size of the section to align the common symbol.
3101      The alignment must be a power of two.  */
3102   alignment = bfd_octets_per_byte (output_bfd) << power_of_two;
3103   BFD_ASSERT (alignment != 0 && (alignment & -alignment) == alignment);
3104   section->size += alignment - 1;
3105   section->size &= -alignment;
3106
3107   /* Adjust the section's overall alignment if necessary.  */
3108   if (power_of_two > section->alignment_power)
3109     section->alignment_power = power_of_two;
3110
3111   /* Change the symbol from common to defined.  */
3112   h->type = bfd_link_hash_defined;
3113   h->u.def.section = section;
3114   h->u.def.value = section->size;
3115
3116   /* Increase the size of the section.  */
3117   section->size += size;
3118
3119   /* Make sure the section is allocated in memory, and make sure that
3120      it is no longer a common section.  */
3121   section->flags |= SEC_ALLOC;
3122   section->flags &= ~SEC_IS_COMMON;
3123   return TRUE;
3124 }
3125
3126 /*
3127 FUNCTION
3128         _bfd_generic_link_hide_symbol
3129
3130 SYNOPSIS
3131         void _bfd_generic_link_hide_symbol
3132           (bfd *output_bfd, struct bfd_link_info *info,
3133            struct bfd_link_hash_entry *h);
3134
3135 DESCRIPTION
3136         Hide symbol @var{h}.
3137         This is an internal function.  It should not be called from
3138         outside the BFD library.
3139
3140 .#define bfd_link_hide_symbol(output_bfd, info, h) \
3141 .       BFD_SEND (output_bfd, _bfd_link_hide_symbol, (output_bfd, info, h))
3142 .
3143 */
3144
3145 void
3146 _bfd_generic_link_hide_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3147                                struct bfd_link_info *info ATTRIBUTE_UNUSED,
3148                                struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED)
3149 {
3150 }
3151
3152 /*
3153 FUNCTION
3154         bfd_generic_define_start_stop
3155
3156 SYNOPSIS
3157         struct bfd_link_hash_entry *bfd_generic_define_start_stop
3158           (struct bfd_link_info *info,
3159            const char *symbol, asection *sec);
3160
3161 DESCRIPTION
3162         Define a __start, __stop, .startof. or .sizeof. symbol.
3163         Return the symbol or NULL if no such undefined symbol exists.
3164
3165 .#define bfd_define_start_stop(output_bfd, info, symbol, sec) \
3166 .       BFD_SEND (output_bfd, _bfd_define_start_stop, (info, symbol, sec))
3167 .
3168 */
3169
3170 struct bfd_link_hash_entry *
3171 bfd_generic_define_start_stop (struct bfd_link_info *info,
3172                                const char *symbol, asection *sec)
3173 {
3174   struct bfd_link_hash_entry *h;
3175
3176   h = bfd_link_hash_lookup (info->hash, symbol, FALSE, FALSE, TRUE);
3177   if (h != NULL
3178       && (h->type == bfd_link_hash_undefined
3179           || h->type == bfd_link_hash_undefweak))
3180     {
3181       h->type = bfd_link_hash_defined;
3182       h->u.def.section = sec;
3183       h->u.def.value = 0;
3184       return h;
3185     }
3186   return NULL;
3187 }
3188
3189 /*
3190 FUNCTION
3191         bfd_find_version_for_sym
3192
3193 SYNOPSIS
3194         struct bfd_elf_version_tree * bfd_find_version_for_sym
3195           (struct bfd_elf_version_tree *verdefs,
3196            const char *sym_name, bfd_boolean *hide);
3197
3198 DESCRIPTION
3199         Search an elf version script tree for symbol versioning
3200         info and export / don't-export status for a given symbol.
3201         Return non-NULL on success and NULL on failure; also sets
3202         the output @samp{hide} boolean parameter.
3203
3204 */
3205
3206 struct bfd_elf_version_tree *
3207 bfd_find_version_for_sym (struct bfd_elf_version_tree *verdefs,
3208                           const char *sym_name,
3209                           bfd_boolean *hide)
3210 {
3211   struct bfd_elf_version_tree *t;
3212   struct bfd_elf_version_tree *local_ver, *global_ver, *exist_ver;
3213   struct bfd_elf_version_tree *star_local_ver, *star_global_ver;
3214
3215   local_ver = NULL;
3216   global_ver = NULL;
3217   star_local_ver = NULL;
3218   star_global_ver = NULL;
3219   exist_ver = NULL;
3220   for (t = verdefs; t != NULL; t = t->next)
3221     {
3222       if (t->globals.list != NULL)
3223         {
3224           struct bfd_elf_version_expr *d = NULL;
3225
3226           while ((d = (*t->match) (&t->globals, d, sym_name)) != NULL)
3227             {
3228               if (d->literal || strcmp (d->pattern, "*") != 0)
3229                 global_ver = t;
3230               else
3231                 star_global_ver = t;
3232               if (d->symver)
3233                 exist_ver = t;
3234               d->script = 1;
3235               /* If the match is a wildcard pattern, keep looking for
3236                  a more explicit, perhaps even local, match.  */
3237               if (d->literal)
3238                 break;
3239             }
3240
3241           if (d != NULL)
3242             break;
3243         }
3244
3245       if (t->locals.list != NULL)
3246         {
3247           struct bfd_elf_version_expr *d = NULL;
3248
3249           while ((d = (*t->match) (&t->locals, d, sym_name)) != NULL)
3250             {
3251               if (d->literal || strcmp (d->pattern, "*") != 0)
3252                 local_ver = t;
3253               else
3254                 star_local_ver = t;
3255               /* If the match is a wildcard pattern, keep looking for
3256                  a more explicit, perhaps even global, match.  */
3257               if (d->literal)
3258                 {
3259                   /* An exact match overrides a global wildcard.  */
3260                   global_ver = NULL;
3261                   star_global_ver = NULL;
3262                   break;
3263                 }
3264             }
3265
3266           if (d != NULL)
3267             break;
3268         }
3269     }
3270
3271   if (global_ver == NULL && local_ver == NULL)
3272     global_ver = star_global_ver;
3273
3274   if (global_ver != NULL)
3275     {
3276       /* If we already have a versioned symbol that matches the
3277          node for this symbol, then we don't want to create a
3278          duplicate from the unversioned symbol.  Instead hide the
3279          unversioned symbol.  */
3280       *hide = exist_ver == global_ver;
3281       return global_ver;
3282     }
3283
3284   if (local_ver == NULL)
3285     local_ver = star_local_ver;
3286
3287   if (local_ver != NULL)
3288     {
3289       *hide = TRUE;
3290       return local_ver;
3291     }
3292
3293   return NULL;
3294 }
3295
3296 /*
3297 FUNCTION
3298         bfd_hide_sym_by_version
3299
3300 SYNOPSIS
3301         bfd_boolean bfd_hide_sym_by_version
3302           (struct bfd_elf_version_tree *verdefs, const char *sym_name);
3303
3304 DESCRIPTION
3305         Search an elf version script tree for symbol versioning
3306         info for a given symbol.  Return TRUE if the symbol is hidden.
3307
3308 */
3309
3310 bfd_boolean
3311 bfd_hide_sym_by_version (struct bfd_elf_version_tree *verdefs,
3312                          const char *sym_name)
3313 {
3314   bfd_boolean hidden = FALSE;
3315   bfd_find_version_for_sym (verdefs, sym_name, &hidden);
3316   return hidden;
3317 }
3318
3319 /*
3320 FUNCTION
3321         bfd_link_check_relocs
3322
3323 SYNOPSIS
3324         bfd_boolean bfd_link_check_relocs
3325           (bfd *abfd, struct bfd_link_info *info);
3326
3327 DESCRIPTION
3328         Checks the relocs in ABFD for validity.
3329         Does not execute the relocs.
3330         Return TRUE if everything is OK, FALSE otherwise.
3331         This is the external entry point to this code.
3332 */
3333
3334 bfd_boolean
3335 bfd_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
3336 {
3337   return BFD_SEND (abfd, _bfd_link_check_relocs, (abfd, info));
3338 }
3339
3340 /*
3341 FUNCTION
3342         _bfd_generic_link_check_relocs
3343
3344 SYNOPSIS
3345         bfd_boolean _bfd_generic_link_check_relocs
3346           (bfd *abfd, struct bfd_link_info *info);
3347
3348 DESCRIPTION
3349         Stub function for targets that do not implement reloc checking.
3350         Return TRUE.
3351         This is an internal function.  It should not be called from
3352         outside the BFD library.
3353 */
3354
3355 bfd_boolean
3356 _bfd_generic_link_check_relocs (bfd *abfd ATTRIBUTE_UNUSED,
3357                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3358 {
3359   return TRUE;
3360 }
3361
3362 /*
3363 FUNCTION
3364         bfd_merge_private_bfd_data
3365
3366 SYNOPSIS
3367         bfd_boolean bfd_merge_private_bfd_data
3368           (bfd *ibfd, struct bfd_link_info *info);
3369
3370 DESCRIPTION
3371         Merge private BFD information from the BFD @var{ibfd} to the
3372         the output file BFD when linking.  Return <<TRUE>> on success,
3373         <<FALSE>> on error.  Possible error returns are:
3374
3375         o <<bfd_error_no_memory>> -
3376         Not enough memory exists to create private data for @var{obfd}.
3377
3378 .#define bfd_merge_private_bfd_data(ibfd, info) \
3379 .       BFD_SEND ((info)->output_bfd, _bfd_merge_private_bfd_data, \
3380 .                 (ibfd, info))
3381 */
3382
3383 /*
3384 INTERNAL_FUNCTION
3385         _bfd_generic_verify_endian_match
3386
3387 SYNOPSIS
3388         bfd_boolean _bfd_generic_verify_endian_match
3389           (bfd *ibfd, struct bfd_link_info *info);
3390
3391 DESCRIPTION
3392         Can be used from / for bfd_merge_private_bfd_data to check that
3393         endianness matches between input and output file.  Returns
3394         TRUE for a match, otherwise returns FALSE and emits an error.
3395 */
3396
3397 bfd_boolean
3398 _bfd_generic_verify_endian_match (bfd *ibfd, struct bfd_link_info *info)
3399 {
3400   bfd *obfd = info->output_bfd;
3401
3402   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
3403       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
3404       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
3405     {
3406       if (bfd_big_endian (ibfd))
3407         _bfd_error_handler (_("%pB: compiled for a big endian system "
3408                               "and target is little endian"), ibfd);
3409       else
3410         _bfd_error_handler (_("%pB: compiled for a little endian system "
3411                               "and target is big endian"), ibfd);
3412       bfd_set_error (bfd_error_wrong_format);
3413       return FALSE;
3414     }
3415
3416   return TRUE;
3417 }
3418
3419 int
3420 _bfd_nolink_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
3421                             struct bfd_link_info *info ATTRIBUTE_UNUSED)
3422 {
3423   return 0;
3424 }
3425
3426 bfd_boolean
3427 _bfd_nolink_bfd_relax_section (bfd *abfd,
3428                                asection *section ATTRIBUTE_UNUSED,
3429                                struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
3430                                bfd_boolean *again ATTRIBUTE_UNUSED)
3431 {
3432   return _bfd_bool_bfd_false_error (abfd);
3433 }
3434
3435 bfd_byte *
3436 _bfd_nolink_bfd_get_relocated_section_contents
3437     (bfd *abfd,
3438      struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
3439      struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
3440      bfd_byte *data ATTRIBUTE_UNUSED,
3441      bfd_boolean relocatable ATTRIBUTE_UNUSED,
3442      asymbol **symbols ATTRIBUTE_UNUSED)
3443 {
3444   return (bfd_byte *) _bfd_ptr_bfd_null_error (abfd);
3445 }
3446
3447 bfd_boolean
3448 _bfd_nolink_bfd_lookup_section_flags
3449     (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3450      struct flag_info *flaginfo ATTRIBUTE_UNUSED,
3451      asection *section)
3452 {
3453   return _bfd_bool_bfd_false_error (section->owner);
3454 }
3455
3456 bfd_boolean
3457 _bfd_nolink_bfd_is_group_section (bfd *abfd,
3458                                   const asection *sec ATTRIBUTE_UNUSED)
3459 {
3460   return _bfd_bool_bfd_false_error (abfd);
3461 }
3462
3463 bfd_boolean
3464 _bfd_nolink_bfd_discard_group (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
3465 {
3466   return _bfd_bool_bfd_false_error (abfd);
3467 }
3468
3469 struct bfd_link_hash_table *
3470 _bfd_nolink_bfd_link_hash_table_create (bfd *abfd)
3471 {
3472   return (struct bfd_link_hash_table *) _bfd_ptr_bfd_null_error (abfd);
3473 }
3474
3475 void
3476 _bfd_nolink_bfd_link_just_syms (asection *sec ATTRIBUTE_UNUSED,
3477                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3478 {
3479 }
3480
3481 void
3482 _bfd_nolink_bfd_copy_link_hash_symbol_type
3483     (bfd *abfd ATTRIBUTE_UNUSED,
3484      struct bfd_link_hash_entry *from ATTRIBUTE_UNUSED,
3485      struct bfd_link_hash_entry *to ATTRIBUTE_UNUSED)
3486 {
3487 }
3488
3489 bfd_boolean
3490 _bfd_nolink_bfd_link_split_section (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
3491 {
3492   return _bfd_bool_bfd_false_error (abfd);
3493 }
3494
3495 bfd_boolean
3496 _bfd_nolink_section_already_linked (bfd *abfd,
3497                                     asection *sec ATTRIBUTE_UNUSED,
3498                                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
3499 {
3500   return _bfd_bool_bfd_false_error (abfd);
3501 }
3502
3503 bfd_boolean
3504 _bfd_nolink_bfd_define_common_symbol
3505     (bfd *abfd,
3506      struct bfd_link_info *info ATTRIBUTE_UNUSED,
3507      struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED)
3508 {
3509   return _bfd_bool_bfd_false_error (abfd);
3510 }
3511
3512 struct bfd_link_hash_entry *
3513 _bfd_nolink_bfd_define_start_stop (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3514                                    const char *name ATTRIBUTE_UNUSED,
3515                                    asection *sec)
3516 {
3517   return (struct bfd_link_hash_entry *) _bfd_ptr_bfd_null_error (sec->owner);
3518 }