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