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