bfd/linker.c

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