bfd/linker.c

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