bfd/linker.c

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