bfd/linker.c

   1 /* linker.c -- BFD linker routines
   2    Copyright (C) 1993-2018 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_traverse.  This traversal calls func with
 636    the real symbol.  */
 637
 638 void
 639 bfd_link_hash_traverse
 640   (struct bfd_link_hash_table *htab,
 641    bfd_boolean (*func) (struct bfd_link_hash_entry *, void *),
 642    void *info)
 643 {
 644   unsigned int i;
 645
 646   htab->table.frozen = 1;
 647   for (i = 0; i < htab->table.size; i++)
 648     {
 649       struct bfd_link_hash_entry *p;
 650
 651       p = (struct bfd_link_hash_entry *) htab->table.table[i];
 652       for (; p != NULL; p = (struct bfd_link_hash_entry *) p->root.next)
 653         if (!(*func) (p->type == bfd_link_hash_warning ? p->u.i.link : p, info))
 654           goto out;
 655     }
 656  out:
 657   htab->table.frozen = 0;
 658 }
 659
 660 /* Add a symbol to the linker hash table undefs list.  */
 661
 662 void
 663 bfd_link_add_undef (struct bfd_link_hash_table *table,
 664                     struct bfd_link_hash_entry *h)
 665 {
 666   BFD_ASSERT (h->u.undef.next == NULL);
 667   if (table->undefs_tail != NULL)
 668     table->undefs_tail->u.undef.next = h;
 669   if (table->undefs == NULL)
 670     table->undefs = h;
 671   table->undefs_tail = h;
 672 }
 673
 674 /* The undefs list was designed so that in normal use we don't need to
 675    remove entries.  However, if symbols on the list are changed from
 676    bfd_link_hash_undefined to either bfd_link_hash_undefweak or
 677    bfd_link_hash_new for some reason, then they must be removed from the
 678    list.  Failure to do so might result in the linker attempting to add
 679    the symbol to the list again at a later stage.  */
 680
 681 void
 682 bfd_link_repair_undef_list (struct bfd_link_hash_table *table)
 683 {
 684   struct bfd_link_hash_entry **pun;
 685
 686   pun = &table->undefs;
 687   while (*pun != NULL)
 688     {
 689       struct bfd_link_hash_entry *h = *pun;
 690
 691       if (h->type == bfd_link_hash_new
 692           || h->type == bfd_link_hash_undefweak)
 693         {
 694           *pun = h->u.undef.next;
 695           h->u.undef.next = NULL;
 696           if (h == table->undefs_tail)
 697             {
 698               if (pun == &table->undefs)
 699                 table->undefs_tail = NULL;
 700               else
 701                 /* pun points at an u.undef.next field.  Go back to
 702                    the start of the link_hash_entry.  */
 703                 table->undefs_tail = (struct bfd_link_hash_entry *)
 704                   ((char *) pun - ((char *) &h->u.undef.next - (char *) h));
 705               break;
 706             }
 707         }
 708       else
 709         pun = &h->u.undef.next;
 710     }
 711 }
 712 \f
 713 /* Routine to create an entry in a generic link hash table.  */
 714
 715 struct bfd_hash_entry *
 716 _bfd_generic_link_hash_newfunc (struct bfd_hash_entry *entry,
 717                                 struct bfd_hash_table *table,
 718                                 const char *string)
 719 {
 720   /* Allocate the structure if it has not already been allocated by a
 721      subclass.  */
 722   if (entry == NULL)
 723     {
 724       entry = (struct bfd_hash_entry *)
 725         bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry));
 726       if (entry == NULL)
 727         return entry;
 728     }
 729
 730   /* Call the allocation method of the superclass.  */
 731   entry = _bfd_link_hash_newfunc (entry, table, string);
 732   if (entry)
 733     {
 734       struct generic_link_hash_entry *ret;
 735
 736       /* Set local fields.  */
 737       ret = (struct generic_link_hash_entry *) entry;
 738       ret->written = FALSE;
 739       ret->sym = NULL;
 740     }
 741
 742   return entry;
 743 }
 744
 745 /* Create a generic link hash table.  */
 746
 747 struct bfd_link_hash_table *
 748 _bfd_generic_link_hash_table_create (bfd *abfd)
 749 {
 750   struct generic_link_hash_table *ret;
 751   bfd_size_type amt = sizeof (struct generic_link_hash_table);
 752
 753   ret = (struct generic_link_hash_table *) bfd_malloc (amt);
 754   if (ret == NULL)
 755     return NULL;
 756   if (! _bfd_link_hash_table_init (&ret->root, abfd,
 757                                    _bfd_generic_link_hash_newfunc,
 758                                    sizeof (struct generic_link_hash_entry)))
 759     {
 760       free (ret);
 761       return NULL;
 762     }
 763   return &ret->root;
 764 }
 765
 766 void
 767 _bfd_generic_link_hash_table_free (bfd *obfd)
 768 {
 769   struct generic_link_hash_table *ret;
 770
 771   BFD_ASSERT (obfd->is_linker_output && obfd->link.hash);
 772   ret = (struct generic_link_hash_table *) obfd->link.hash;
 773   bfd_hash_table_free (&ret->root.table);
 774   free (ret);
 775   obfd->link.hash = NULL;
 776   obfd->is_linker_output = FALSE;
 777 }
 778
 779 /* Grab the symbols for an object file when doing a generic link.  We
 780    store the symbols in the outsymbols field.  We need to keep them
 781    around for the entire link to ensure that we only read them once.
 782    If we read them multiple times, we might wind up with relocs and
 783    the hash table pointing to different instances of the symbol
 784    structure.  */
 785
 786 bfd_boolean
 787 bfd_generic_link_read_symbols (bfd *abfd)
 788 {
 789   if (bfd_get_outsymbols (abfd) == NULL)
 790     {
 791       long symsize;
 792       long symcount;
 793
 794       symsize = bfd_get_symtab_upper_bound (abfd);
 795       if (symsize < 0)
 796         return FALSE;
 797       bfd_get_outsymbols (abfd) = (struct bfd_symbol **) bfd_alloc (abfd,
 798                                                                     symsize);
 799       if (bfd_get_outsymbols (abfd) == NULL && symsize != 0)
 800         return FALSE;
 801       symcount = bfd_canonicalize_symtab (abfd, bfd_get_outsymbols (abfd));
 802       if (symcount < 0)
 803         return FALSE;
 804       bfd_get_symcount (abfd) = symcount;
 805     }
 806
 807   return TRUE;
 808 }
 809 \f
 810 /* Indicate that we are only retrieving symbol values from this
 811    section.  We want the symbols to act as though the values in the
 812    file are absolute.  */
 813
 814 void
 815 _bfd_generic_link_just_syms (asection *sec,
 816                              struct bfd_link_info *info ATTRIBUTE_UNUSED)
 817 {
 818   sec->sec_info_type = SEC_INFO_TYPE_JUST_SYMS;
 819   sec->output_section = bfd_abs_section_ptr;
 820   sec->output_offset = sec->vma;
 821 }
 822
 823 /* Copy the symbol type and other attributes for a linker script
 824    assignment from HSRC to HDEST.
 825    The default implementation does nothing.  */
 826 void
 827 _bfd_generic_copy_link_hash_symbol_type (bfd *abfd ATTRIBUTE_UNUSED,
 828     struct bfd_link_hash_entry *hdest ATTRIBUTE_UNUSED,
 829     struct bfd_link_hash_entry *hsrc ATTRIBUTE_UNUSED)
 830 {
 831 }
 832
 833 /* Generic function to add symbols from an object file to the
 834    global hash table.  */
 835
 836 bfd_boolean
 837 _bfd_generic_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
 838 {
 839   bfd_boolean ret;
 840
 841   switch (bfd_get_format (abfd))
 842     {
 843     case bfd_object:
 844       ret = generic_link_add_object_symbols (abfd, info);
 845       break;
 846     case bfd_archive:
 847       ret = (_bfd_generic_link_add_archive_symbols
 848              (abfd, info, generic_link_check_archive_element));
 849       break;
 850     default:
 851       bfd_set_error (bfd_error_wrong_format);
 852       ret = FALSE;
 853     }
 854
 855   return ret;
 856 }
 857
 858 /* Add symbols from an object file to the global hash table.  */
 859
 860 static bfd_boolean
 861 generic_link_add_object_symbols (bfd *abfd,
 862                                  struct bfd_link_info *info)
 863 {
 864   bfd_size_type symcount;
 865   struct bfd_symbol **outsyms;
 866
 867   if (!bfd_generic_link_read_symbols (abfd))
 868     return FALSE;
 869   symcount = _bfd_generic_link_get_symcount (abfd);
 870   outsyms = _bfd_generic_link_get_symbols (abfd);
 871   return generic_link_add_symbol_list (abfd, info, symcount, outsyms);
 872 }
 873 \f
 874 /* Generic function to add symbols from an archive file to the global
 875    hash file.  This function presumes that the archive symbol table
 876    has already been read in (this is normally done by the
 877    bfd_check_format entry point).  It looks through the archive symbol
 878    table for symbols that are undefined or common in the linker global
 879    symbol hash table.  When one is found, the CHECKFN argument is used
 880    to see if an object file should be included.  This allows targets
 881    to customize common symbol behaviour.  CHECKFN should set *PNEEDED
 882    to TRUE if the object file should be included, and must also call
 883    the bfd_link_info add_archive_element callback function and handle
 884    adding the symbols to the global hash table.  CHECKFN must notice
 885    if the callback indicates a substitute BFD, and arrange to add
 886    those symbols instead if it does so.  CHECKFN should only return
 887    FALSE if some sort of error occurs.  */
 888
 889 bfd_boolean
 890 _bfd_generic_link_add_archive_symbols
 891   (bfd *abfd,
 892    struct bfd_link_info *info,
 893    bfd_boolean (*checkfn) (bfd *, struct bfd_link_info *,
 894                            struct bfd_link_hash_entry *, const char *,
 895                            bfd_boolean *))
 896 {
 897   bfd_boolean loop;
 898   bfd_size_type amt;
 899   unsigned char *included;
 900
 901   if (! bfd_has_map (abfd))
 902     {
 903       /* An empty archive is a special case.  */
 904       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
 905         return TRUE;
 906       bfd_set_error (bfd_error_no_armap);
 907       return FALSE;
 908     }
 909
 910   amt = bfd_ardata (abfd)->symdef_count;
 911   if (amt == 0)
 912     return TRUE;
 913   amt *= sizeof (*included);
 914   included = (unsigned char *) bfd_zmalloc (amt);
 915   if (included == NULL)
 916     return FALSE;
 917
 918   do
 919     {
 920       carsym *arsyms;
 921       carsym *arsym_end;
 922       carsym *arsym;
 923       unsigned int indx;
 924       file_ptr last_ar_offset = -1;
 925       bfd_boolean needed = FALSE;
 926       bfd *element = NULL;
 927
 928       loop = FALSE;
 929       arsyms = bfd_ardata (abfd)->symdefs;
 930       arsym_end = arsyms + bfd_ardata (abfd)->symdef_count;
 931       for (arsym = arsyms, indx = 0; arsym < arsym_end; arsym++, indx++)
 932         {
 933           struct bfd_link_hash_entry *h;
 934           struct bfd_link_hash_entry *undefs_tail;
 935
 936           if (included[indx])
 937             continue;
 938           if (needed && arsym->file_offset == last_ar_offset)
 939             {
 940               included[indx] = 1;
 941               continue;
 942             }
 943
 944           h = bfd_link_hash_lookup (info->hash, arsym->name,
 945                                     FALSE, FALSE, TRUE);
 946
 947           if (h == NULL
 948               && info->pei386_auto_import
 949               && CONST_STRNEQ (arsym->name, "__imp_"))
 950             h = bfd_link_hash_lookup (info->hash, arsym->name + 6,
 951                                       FALSE, FALSE, TRUE);
 952           if (h == NULL)
 953             continue;
 954
 955           if (h->type != bfd_link_hash_undefined
 956               && h->type != bfd_link_hash_common)
 957             {
 958               if (h->type != bfd_link_hash_undefweak)
 959                 /* Symbol must be defined.  Don't check it again.  */
 960                 included[indx] = 1;
 961               continue;
 962             }
 963
 964           if (last_ar_offset != arsym->file_offset)
 965             {
 966               last_ar_offset = arsym->file_offset;
 967               element = _bfd_get_elt_at_filepos (abfd, last_ar_offset);
 968               if (element == NULL
 969                   || !bfd_check_format (element, bfd_object))
 970                 goto error_return;
 971             }
 972
 973           undefs_tail = info->hash->undefs_tail;
 974
 975           /* CHECKFN will see if this element should be included, and
 976              go ahead and include it if appropriate.  */
 977           if (! (*checkfn) (element, info, h, arsym->name, &needed))
 978             goto error_return;
 979
 980           if (needed)
 981             {
 982               unsigned int mark;
 983
 984               /* Look backward to mark all symbols from this object file
 985                  which we have already seen in this pass.  */
 986               mark = indx;
 987               do
 988                 {
 989                   included[mark] = 1;
 990                   if (mark == 0)
 991                     break;
 992                   --mark;
 993                 }
 994               while (arsyms[mark].file_offset == last_ar_offset);
 995
 996               if (undefs_tail != info->hash->undefs_tail)
 997                 loop = TRUE;
 998             }
 999         }
1000     } while (loop);
1001
1002   free (included);
1003   return TRUE;
1004
1005  error_return:
1006   free (included);
1007   return FALSE;
1008 }
1009 \f
1010 /* See if we should include an archive element.  */
1011
1012 static bfd_boolean
1013 generic_link_check_archive_element (bfd *abfd,
1014                                     struct bfd_link_info *info,
1015                                     struct bfd_link_hash_entry *h,
1016                                     const char *name ATTRIBUTE_UNUSED,
1017                                     bfd_boolean *pneeded)
1018 {
1019   asymbol **pp, **ppend;
1020
1021   *pneeded = FALSE;
1022
1023   if (!bfd_generic_link_read_symbols (abfd))
1024     return FALSE;
1025
1026   pp = _bfd_generic_link_get_symbols (abfd);
1027   ppend = pp + _bfd_generic_link_get_symcount (abfd);
1028   for (; pp < ppend; pp++)
1029     {
1030       asymbol *p;
1031
1032       p = *pp;
1033
1034       /* We are only interested in globally visible symbols.  */
1035       if (! bfd_is_com_section (p->section)
1036           && (p->flags & (BSF_GLOBAL | BSF_INDIRECT | BSF_WEAK)) == 0)
1037         continue;
1038
1039       /* We are only interested if we know something about this
1040          symbol, and it is undefined or common.  An undefined weak
1041          symbol (type bfd_link_hash_undefweak) is not considered to be
1042          a reference when pulling files out of an archive.  See the
1043          SVR4 ABI, p. 4-27.  */
1044       h = bfd_link_hash_lookup (info->hash, bfd_asymbol_name (p), FALSE,
1045                                 FALSE, TRUE);
1046       if (h == NULL
1047           || (h->type != bfd_link_hash_undefined
1048               && h->type != bfd_link_hash_common))
1049         continue;
1050
1051       /* P is a symbol we are looking for.  */
1052
1053       if (! bfd_is_com_section (p->section)
1054           || (h->type == bfd_link_hash_undefined
1055               && h->u.undef.abfd == NULL))
1056         {
1057           /* P is not a common symbol, or an undefined reference was
1058              created from outside BFD such as from a linker -u option.
1059              This object file defines the symbol, so pull it in.  */
1060           *pneeded = TRUE;
1061           if (!(*info->callbacks
1062                 ->add_archive_element) (info, abfd, bfd_asymbol_name (p),
1063                                         &abfd))
1064             return FALSE;
1065           /* Potentially, the add_archive_element hook may have set a
1066              substitute BFD for us.  */
1067           return bfd_link_add_symbols (abfd, info);
1068         }
1069
1070       /* P is a common symbol.  */
1071
1072       if (h->type == bfd_link_hash_undefined)
1073         {
1074           bfd *symbfd;
1075           bfd_vma size;
1076           unsigned int power;
1077
1078           /* Turn the symbol into a common symbol but do not link in
1079              the object file.  This is how a.out works.  Object
1080              formats that require different semantics must implement
1081              this function differently.  This symbol is already on the
1082              undefs list.  We add the section to a common section
1083              attached to symbfd to ensure that it is in a BFD which
1084              will be linked in.  */
1085           symbfd = h->u.undef.abfd;
1086           h->type = bfd_link_hash_common;
1087           h->u.c.p = (struct bfd_link_hash_common_entry *)
1088             bfd_hash_allocate (&info->hash->table,
1089                                sizeof (struct bfd_link_hash_common_entry));
1090           if (h->u.c.p == NULL)
1091             return FALSE;
1092
1093           size = bfd_asymbol_value (p);
1094           h->u.c.size = size;
1095
1096           power = bfd_log2 (size);
1097           if (power > 4)
1098             power = 4;
1099           h->u.c.p->alignment_power = power;
1100
1101           if (p->section == bfd_com_section_ptr)
1102             h->u.c.p->section = bfd_make_section_old_way (symbfd, "COMMON");
1103           else
1104             h->u.c.p->section = bfd_make_section_old_way (symbfd,
1105                                                           p->section->name);
1106           h->u.c.p->section->flags |= SEC_ALLOC;
1107         }
1108       else
1109         {
1110           /* Adjust the size of the common symbol if necessary.  This
1111              is how a.out works.  Object formats that require
1112              different semantics must implement this function
1113              differently.  */
1114           if (bfd_asymbol_value (p) > h->u.c.size)
1115             h->u.c.size = bfd_asymbol_value (p);
1116         }
1117     }
1118
1119   /* This archive element is not needed.  */
1120   return TRUE;
1121 }
1122
1123 /* Add the symbols from an object file to the global hash table.  ABFD
1124    is the object file.  INFO is the linker information.  SYMBOL_COUNT
1125    is the number of symbols.  SYMBOLS is the list of symbols.  */
1126
1127 static bfd_boolean
1128 generic_link_add_symbol_list (bfd *abfd,
1129                               struct bfd_link_info *info,
1130                               bfd_size_type symbol_count,
1131                               asymbol **symbols)
1132 {
1133   asymbol **pp, **ppend;
1134
1135   pp = symbols;
1136   ppend = symbols + symbol_count;
1137   for (; pp < ppend; pp++)
1138     {
1139       asymbol *p;
1140
1141       p = *pp;
1142
1143       if ((p->flags & (BSF_INDIRECT
1144                        | BSF_WARNING
1145                        | BSF_GLOBAL
1146                        | BSF_CONSTRUCTOR
1147                        | BSF_WEAK)) != 0
1148           || bfd_is_und_section (bfd_get_section (p))
1149           || bfd_is_com_section (bfd_get_section (p))
1150           || bfd_is_ind_section (bfd_get_section (p)))
1151         {
1152           const char *name;
1153           const char *string;
1154           struct generic_link_hash_entry *h;
1155           struct bfd_link_hash_entry *bh;
1156
1157           string = name = bfd_asymbol_name (p);
1158           if (((p->flags & BSF_INDIRECT) != 0
1159                || bfd_is_ind_section (p->section))
1160               && pp + 1 < ppend)
1161             {
1162               pp++;
1163               string = bfd_asymbol_name (*pp);
1164             }
1165           else if ((p->flags & BSF_WARNING) != 0
1166                    && pp + 1 < ppend)
1167             {
1168               /* The name of P is actually the warning string, and the
1169                  next symbol is the one to warn about.  */
1170               pp++;
1171               name = bfd_asymbol_name (*pp);
1172             }
1173
1174           bh = NULL;
1175           if (! (_bfd_generic_link_add_one_symbol
1176                  (info, abfd, name, p->flags, bfd_get_section (p),
1177                   p->value, string, FALSE, FALSE, &bh)))
1178             return FALSE;
1179           h = (struct generic_link_hash_entry *) bh;
1180
1181           /* If this is a constructor symbol, and the linker didn't do
1182              anything with it, then we want to just pass the symbol
1183              through to the output file.  This will happen when
1184              linking with -r.  */
1185           if ((p->flags & BSF_CONSTRUCTOR) != 0
1186               && (h == NULL || h->root.type == bfd_link_hash_new))
1187             {
1188               p->udata.p = NULL;
1189               continue;
1190             }
1191
1192           /* Save the BFD symbol so that we don't lose any backend
1193              specific information that may be attached to it.  We only
1194              want this one if it gives more information than the
1195              existing one; we don't want to replace a defined symbol
1196              with an undefined one.  This routine may be called with a
1197              hash table other than the generic hash table, so we only
1198              do this if we are certain that the hash table is a
1199              generic one.  */
1200           if (info->output_bfd->xvec == abfd->xvec)
1201             {
1202               if (h->sym == NULL
1203                   || (! bfd_is_und_section (bfd_get_section (p))
1204                       && (! bfd_is_com_section (bfd_get_section (p))
1205                           || bfd_is_und_section (bfd_get_section (h->sym)))))
1206                 {
1207                   h->sym = p;
1208                   /* BSF_OLD_COMMON is a hack to support COFF reloc
1209                      reading, and it should go away when the COFF
1210                      linker is switched to the new version.  */
1211                   if (bfd_is_com_section (bfd_get_section (p)))
1212                     p->flags |= BSF_OLD_COMMON;
1213                 }
1214             }
1215
1216           /* Store a back pointer from the symbol to the hash
1217              table entry for the benefit of relaxation code until
1218              it gets rewritten to not use asymbol structures.
1219              Setting this is also used to check whether these
1220              symbols were set up by the generic linker.  */
1221           p->udata.p = h;
1222         }
1223     }
1224
1225   return TRUE;
1226 }
1227 \f
1228 /* We use a state table to deal with adding symbols from an object
1229    file.  The first index into the state table describes the symbol
1230    from the object file.  The second index into the state table is the
1231    type of the symbol in the hash table.  */
1232
1233 /* The symbol from the object file is turned into one of these row
1234    values.  */
1235
1236 enum link_row
1237 {
1238   UNDEF_ROW,            /* Undefined.  */
1239   UNDEFW_ROW,           /* Weak undefined.  */
1240   DEF_ROW,              /* Defined.  */
1241   DEFW_ROW,             /* Weak defined.  */
1242   COMMON_ROW,           /* Common.  */
1243   INDR_ROW,             /* Indirect.  */
1244   WARN_ROW,             /* Warning.  */
1245   SET_ROW               /* Member of set.  */
1246 };
1247
1248 /* apparently needed for Hitachi 3050R(HI-UX/WE2)? */
1249 #undef FAIL
1250
1251 /* The actions to take in the state table.  */
1252
1253 enum link_action
1254 {
1255   FAIL,         /* Abort.  */
1256   UND,          /* Mark symbol undefined.  */
1257   WEAK,         /* Mark symbol weak undefined.  */
1258   DEF,          /* Mark symbol defined.  */
1259   DEFW,         /* Mark symbol weak defined.  */
1260   COM,          /* Mark symbol common.  */
1261   REF,          /* Mark defined symbol referenced.  */
1262   CREF,         /* Possibly warn about common reference to defined symbol.  */
1263   CDEF,         /* Define existing common symbol.  */
1264   NOACT,        /* No action.  */
1265   BIG,          /* Mark symbol common using largest size.  */
1266   MDEF,         /* Multiple definition error.  */
1267   MIND,         /* Multiple indirect symbols.  */
1268   IND,          /* Make indirect symbol.  */
1269   CIND,         /* Make indirect symbol from existing common symbol.  */
1270   SET,          /* Add value to set.  */
1271   MWARN,        /* Make warning symbol.  */
1272   WARN,         /* Warn if referenced, else MWARN.  */
1273   CYCLE,        /* Repeat with symbol pointed to.  */
1274   REFC,         /* Mark indirect symbol referenced and then CYCLE.  */
1275   WARNC         /* Issue warning and then CYCLE.  */
1276 };
1277
1278 /* The state table itself.  The first index is a link_row and the
1279    second index is a bfd_link_hash_type.  */
1280
1281 static const enum link_action link_action[8][8] =
1282 {
1283   /* current\prev    new    undef  undefw def    defw   com    indr   warn  */
1284   /* UNDEF_ROW  */  {UND,   NOACT, UND,   REF,   REF,   NOACT, REFC,  WARNC },
1285   /* UNDEFW_ROW */  {WEAK,  NOACT, NOACT, REF,   REF,   NOACT, REFC,  WARNC },
1286   /* DEF_ROW    */  {DEF,   DEF,   DEF,   MDEF,  DEF,   CDEF,  MDEF,  CYCLE },
1287   /* DEFW_ROW   */  {DEFW,  DEFW,  DEFW,  NOACT, NOACT, NOACT, NOACT, CYCLE },
1288   /* COMMON_ROW */  {COM,   COM,   COM,   CREF,  COM,   BIG,   REFC,  WARNC },
1289   /* INDR_ROW   */  {IND,   IND,   IND,   MDEF,  IND,   CIND,  MIND,  CYCLE },
1290   /* WARN_ROW   */  {MWARN, WARN,  WARN,  WARN,  WARN,  WARN,  WARN,  NOACT },
1291   /* SET_ROW    */  {SET,   SET,   SET,   SET,   SET,   SET,   CYCLE, CYCLE }
1292 };
1293
1294 /* Most of the entries in the LINK_ACTION table are straightforward,
1295    but a few are somewhat subtle.
1296
1297    A reference to an indirect symbol (UNDEF_ROW/indr or
1298    UNDEFW_ROW/indr) is counted as a reference both to the indirect
1299    symbol and to the symbol the indirect symbol points to.
1300
1301    A reference to a warning symbol (UNDEF_ROW/warn or UNDEFW_ROW/warn)
1302    causes the warning to be issued.
1303
1304    A common definition of an indirect symbol (COMMON_ROW/indr) is
1305    treated as a multiple definition error.  Likewise for an indirect
1306    definition of a common symbol (INDR_ROW/com).
1307
1308    An indirect definition of a warning (INDR_ROW/warn) does not cause
1309    the warning to be issued.
1310
1311    If a warning is created for an indirect symbol (WARN_ROW/indr) no
1312    warning is created for the symbol the indirect symbol points to.
1313
1314    Adding an entry to a set does not count as a reference to a set,
1315    and no warning is issued (SET_ROW/warn).  */
1316
1317 /* Return the BFD in which a hash entry has been defined, if known.  */
1318
1319 static bfd *
1320 hash_entry_bfd (struct bfd_link_hash_entry *h)
1321 {
1322   while (h->type == bfd_link_hash_warning)
1323     h = h->u.i.link;
1324   switch (h->type)
1325     {
1326     default:
1327       return NULL;
1328     case bfd_link_hash_undefined:
1329     case bfd_link_hash_undefweak:
1330       return h->u.undef.abfd;
1331     case bfd_link_hash_defined:
1332     case bfd_link_hash_defweak:
1333       return h->u.def.section->owner;
1334     case bfd_link_hash_common:
1335       return h->u.c.p->section->owner;
1336     }
1337   /*NOTREACHED*/
1338 }
1339
1340 /* Add a symbol to the global hash table.
1341    ABFD is the BFD the symbol comes from.
1342    NAME is the name of the symbol.
1343    FLAGS is the BSF_* bits associated with the symbol.
1344    SECTION is the section in which the symbol is defined; this may be
1345      bfd_und_section_ptr or bfd_com_section_ptr.
1346    VALUE is the value of the symbol, relative to the section.
1347    STRING is used for either an indirect symbol, in which case it is
1348      the name of the symbol to indirect to, or a warning symbol, in
1349      which case it is the warning string.
1350    COPY is TRUE if NAME or STRING must be copied into locally
1351      allocated memory if they need to be saved.
1352    COLLECT is TRUE if we should automatically collect gcc constructor
1353      or destructor names as collect2 does.
1354    HASHP, if not NULL, is a place to store the created hash table
1355      entry; if *HASHP is not NULL, the caller has already looked up
1356      the hash table entry, and stored it in *HASHP.  */
1357
1358 bfd_boolean
1359 _bfd_generic_link_add_one_symbol (struct bfd_link_info *info,
1360                                   bfd *abfd,
1361                                   const char *name,
1362                                   flagword flags,
1363                                   asection *section,
1364                                   bfd_vma value,
1365                                   const char *string,
1366                                   bfd_boolean copy,
1367                                   bfd_boolean collect,
1368                                   struct bfd_link_hash_entry **hashp)
1369 {
1370   enum link_row row;
1371   struct bfd_link_hash_entry *h;
1372   struct bfd_link_hash_entry *inh = NULL;
1373   bfd_boolean cycle;
1374
1375   BFD_ASSERT (section != NULL);
1376
1377   if (bfd_is_ind_section (section)
1378       || (flags & BSF_INDIRECT) != 0)
1379     {
1380       row = INDR_ROW;
1381       /* Create the indirect symbol here.  This is for the benefit of
1382          the plugin "notice" function.
1383          STRING is the name of the symbol we want to indirect to.  */
1384       inh = bfd_wrapped_link_hash_lookup (abfd, info, string, TRUE,
1385                                           copy, FALSE);
1386       if (inh == NULL)
1387         return FALSE;
1388     }
1389   else if ((flags & BSF_WARNING) != 0)
1390     row = WARN_ROW;
1391   else if ((flags & BSF_CONSTRUCTOR) != 0)
1392     row = SET_ROW;
1393   else if (bfd_is_und_section (section))
1394     {
1395       if ((flags & BSF_WEAK) != 0)
1396         row = UNDEFW_ROW;
1397       else
1398         row = UNDEF_ROW;
1399     }
1400   else if ((flags & BSF_WEAK) != 0)
1401     row = DEFW_ROW;
1402   else if (bfd_is_com_section (section))
1403     {
1404       row = COMMON_ROW;
1405       if (!bfd_link_relocatable (info)
1406           && name[0] == '_'
1407           && name[1] == '_'
1408           && strcmp (name + (name[2] == '_'), "__gnu_lto_slim") == 0)
1409         _bfd_error_handler
1410           (_("%pB: plugin needed to handle lto object"), abfd);
1411     }
1412   else
1413     row = DEF_ROW;
1414
1415   if (hashp != NULL && *hashp != NULL)
1416     h = *hashp;
1417   else
1418     {
1419       if (row == UNDEF_ROW || row == UNDEFW_ROW)
1420         h = bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE);
1421       else
1422         h = bfd_link_hash_lookup (info->hash, name, TRUE, copy, FALSE);
1423       if (h == NULL)
1424         {
1425           if (hashp != NULL)
1426             *hashp = NULL;
1427           return FALSE;
1428         }
1429     }
1430
1431   if (info->notice_all
1432       || (info->notice_hash != NULL
1433           && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1434     {
1435       if (! (*info->callbacks->notice) (info, h, inh,
1436                                         abfd, section, value, flags))
1437         return FALSE;
1438     }
1439
1440   if (hashp != NULL)
1441     *hashp = h;
1442
1443   do
1444     {
1445       enum link_action action;
1446       int prev;
1447
1448       prev = h->type;
1449       /* Treat symbols defined by early linker script pass as undefined.  */
1450       if (h->ldscript_def)
1451         prev = bfd_link_hash_undefined;
1452       cycle = FALSE;
1453       action = link_action[(int) row][prev];
1454       switch (action)
1455         {
1456         case FAIL:
1457           abort ();
1458
1459         case NOACT:
1460           /* Do nothing.  */
1461           break;
1462
1463         case UND:
1464           /* Make a new undefined symbol.  */
1465           h->type = bfd_link_hash_undefined;
1466           h->u.undef.abfd = abfd;
1467           bfd_link_add_undef (info->hash, h);
1468           break;
1469
1470         case WEAK:
1471           /* Make a new weak undefined symbol.  */
1472           h->type = bfd_link_hash_undefweak;
1473           h->u.undef.abfd = abfd;
1474           break;
1475
1476         case CDEF:
1477           /* We have found a definition for a symbol which was
1478              previously common.  */
1479           BFD_ASSERT (h->type == bfd_link_hash_common);
1480           (*info->callbacks->multiple_common) (info, h, abfd,
1481                                                bfd_link_hash_defined, 0);
1482           /* Fall through.  */
1483         case DEF:
1484         case DEFW:
1485           {
1486             enum bfd_link_hash_type oldtype;
1487
1488             /* Define a symbol.  */
1489             oldtype = h->type;
1490             if (action == DEFW)
1491               h->type = bfd_link_hash_defweak;
1492             else
1493               h->type = bfd_link_hash_defined;
1494             h->u.def.section = section;
1495             h->u.def.value = value;
1496             h->linker_def = 0;
1497             h->ldscript_def = 0;
1498
1499             /* If we have been asked to, we act like collect2 and
1500                identify all functions that might be global
1501                constructors and destructors and pass them up in a
1502                callback.  We only do this for certain object file
1503                types, since many object file types can handle this
1504                automatically.  */
1505             if (collect && name[0] == '_')
1506               {
1507                 const char *s;
1508
1509                 /* A constructor or destructor name starts like this:
1510                    _+GLOBAL_[_.$][ID][_.$] where the first [_.$] and
1511                    the second are the same character (we accept any
1512                    character there, in case a new object file format
1513                    comes along with even worse naming restrictions).  */
1514
1515 #define CONS_PREFIX "GLOBAL_"
1516 #define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
1517
1518                 s = name + 1;
1519                 while (*s == '_')
1520                   ++s;
1521                 if (s[0] == 'G' && CONST_STRNEQ (s, CONS_PREFIX))
1522                   {
1523                     char c;
1524
1525                     c = s[CONS_PREFIX_LEN + 1];
1526                     if ((c == 'I' || c == 'D')
1527                         && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
1528                       {
1529                         /* If this is a definition of a symbol which
1530                            was previously weakly defined, we are in
1531                            trouble.  We have already added a
1532                            constructor entry for the weak defined
1533                            symbol, and now we are trying to add one
1534                            for the new symbol.  Fortunately, this case
1535                            should never arise in practice.  */
1536                         if (oldtype == bfd_link_hash_defweak)
1537                           abort ();
1538
1539                         (*info->callbacks->constructor) (info, c == 'I',
1540                                                          h->root.string, abfd,
1541                                                          section, value);
1542                       }
1543                   }
1544               }
1545           }
1546
1547           break;
1548
1549         case COM:
1550           /* We have found a common definition for a symbol.  */
1551           if (h->type == bfd_link_hash_new)
1552             bfd_link_add_undef (info->hash, h);
1553           h->type = bfd_link_hash_common;
1554           h->u.c.p = (struct bfd_link_hash_common_entry *)
1555             bfd_hash_allocate (&info->hash->table,
1556                                sizeof (struct bfd_link_hash_common_entry));
1557           if (h->u.c.p == NULL)
1558             return FALSE;
1559
1560           h->u.c.size = value;
1561
1562           /* Select a default alignment based on the size.  This may
1563              be overridden by the caller.  */
1564           {
1565             unsigned int power;
1566
1567             power = bfd_log2 (value);
1568             if (power > 4)
1569               power = 4;
1570             h->u.c.p->alignment_power = power;
1571           }
1572
1573           /* The section of a common symbol is only used if the common
1574              symbol is actually allocated.  It basically provides a
1575              hook for the linker script to decide which output section
1576              the common symbols should be put in.  In most cases, the
1577              section of a common symbol will be bfd_com_section_ptr,
1578              the code here will choose a common symbol section named
1579              "COMMON", and the linker script will contain *(COMMON) in
1580              the appropriate place.  A few targets use separate common
1581              sections for small symbols, and they require special
1582              handling.  */
1583           if (section == bfd_com_section_ptr)
1584             {
1585               h->u.c.p->section = bfd_make_section_old_way (abfd, "COMMON");
1586               h->u.c.p->section->flags |= SEC_ALLOC;
1587             }
1588           else if (section->owner != abfd)
1589             {
1590               h->u.c.p->section = bfd_make_section_old_way (abfd,
1591                                                             section->name);
1592               h->u.c.p->section->flags |= SEC_ALLOC;
1593             }
1594           else
1595             h->u.c.p->section = section;
1596           h->linker_def = 0;
1597           h->ldscript_def = 0;
1598           break;
1599
1600         case REF:
1601           /* A reference to a defined symbol.  */
1602           if (h->u.undef.next == NULL && info->hash->undefs_tail != h)
1603             h->u.undef.next = h;
1604           break;
1605
1606         case BIG:
1607           /* We have found a common definition for a symbol which
1608              already had a common definition.  Use the maximum of the
1609              two sizes, and use the section required by the larger symbol.  */
1610           BFD_ASSERT (h->type == bfd_link_hash_common);
1611           (*info->callbacks->multiple_common) (info, h, abfd,
1612                                                bfd_link_hash_common, value);
1613           if (value > h->u.c.size)
1614             {
1615               unsigned int power;
1616
1617               h->u.c.size = value;
1618
1619               /* Select a default alignment based on the size.  This may
1620                  be overridden by the caller.  */
1621               power = bfd_log2 (value);
1622               if (power > 4)
1623                 power = 4;
1624               h->u.c.p->alignment_power = power;
1625
1626               /* Some systems have special treatment for small commons,
1627                  hence we want to select the section used by the larger
1628                  symbol.  This makes sure the symbol does not go in a
1629                  small common section if it is now too large.  */
1630               if (section == bfd_com_section_ptr)
1631                 {
1632                   h->u.c.p->section
1633                     = bfd_make_section_old_way (abfd, "COMMON");
1634                   h->u.c.p->section->flags |= SEC_ALLOC;
1635                 }
1636               else if (section->owner != abfd)
1637                 {
1638                   h->u.c.p->section
1639                     = bfd_make_section_old_way (abfd, section->name);
1640                   h->u.c.p->section->flags |= SEC_ALLOC;
1641                 }
1642               else
1643                 h->u.c.p->section = section;
1644             }
1645           break;
1646
1647         case CREF:
1648           /* We have found a common definition for a symbol which
1649              was already defined.  */
1650           (*info->callbacks->multiple_common) (info, h, abfd,
1651                                                bfd_link_hash_common, value);
1652           break;
1653
1654         case MIND:
1655           /* Multiple indirect symbols.  This is OK if they both point
1656              to the same symbol.  */
1657           if (strcmp (h->u.i.link->root.string, string) == 0)
1658             break;
1659           /* Fall through.  */
1660         case MDEF:
1661           /* Handle a multiple definition.  */
1662           (*info->callbacks->multiple_definition) (info, h,
1663                                                    abfd, section, value);
1664           break;
1665
1666         case CIND:
1667           /* Create an indirect symbol from an existing common symbol.  */
1668           BFD_ASSERT (h->type == bfd_link_hash_common);
1669           (*info->callbacks->multiple_common) (info, h, abfd,
1670                                                bfd_link_hash_indirect, 0);
1671           /* Fall through.  */
1672         case IND:
1673           if (inh->type == bfd_link_hash_indirect
1674               && inh->u.i.link == h)
1675             {
1676               _bfd_error_handler
1677                 /* xgettext:c-format */
1678                 (_("%pB: indirect symbol `%s' to `%s' is a loop"),
1679                  abfd, name, string);
1680               bfd_set_error (bfd_error_invalid_operation);
1681               return FALSE;
1682             }
1683           if (inh->type == bfd_link_hash_new)
1684             {
1685               inh->type = bfd_link_hash_undefined;
1686               inh->u.undef.abfd = abfd;
1687               bfd_link_add_undef (info->hash, inh);
1688             }
1689
1690           /* If the indirect symbol has been referenced, we need to
1691              push the reference down to the symbol we are referencing.  */
1692           if (h->type != bfd_link_hash_new)
1693             {
1694               /* ??? If inh->type == bfd_link_hash_undefweak this
1695                  converts inh to bfd_link_hash_undefined.  */
1696               row = UNDEF_ROW;
1697               cycle = TRUE;
1698             }
1699
1700           h->type = bfd_link_hash_indirect;
1701           h->u.i.link = inh;
1702           /* Not setting h = h->u.i.link here means that when cycle is
1703              set above we'll always go to REFC, and then cycle again
1704              to the indirected symbol.  This means that any successful
1705              change of an existing symbol to indirect counts as a
1706              reference.  ??? That may not be correct when the existing
1707              symbol was defweak.  */
1708           break;
1709
1710         case SET:
1711           /* Add an entry to a set.  */
1712           (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR,
1713                                           abfd, section, value);
1714           break;
1715
1716         case WARNC:
1717           /* Issue a warning and cycle, except when the reference is
1718              in LTO IR.  */
1719           if (h->u.i.warning != NULL
1720               && (abfd->flags & BFD_PLUGIN) == 0)
1721             {
1722               (*info->callbacks->warning) (info, h->u.i.warning,
1723                                            h->root.string, abfd, NULL, 0);
1724               /* Only issue a warning once.  */
1725               h->u.i.warning = NULL;
1726             }
1727           /* Fall through.  */
1728         case CYCLE:
1729           /* Try again with the referenced symbol.  */
1730           h = h->u.i.link;
1731           cycle = TRUE;
1732           break;
1733
1734         case REFC:
1735           /* A reference to an indirect symbol.  */
1736           if (h->u.undef.next == NULL && info->hash->undefs_tail != h)
1737             h->u.undef.next = h;
1738           h = h->u.i.link;
1739           cycle = TRUE;
1740           break;
1741
1742         case WARN:
1743           /* Warn if this symbol has been referenced already from non-IR,
1744              otherwise add a warning.  */
1745           if ((!info->lto_plugin_active
1746                && (h->u.undef.next != NULL || info->hash->undefs_tail == h))
1747               || h->non_ir_ref_regular
1748               || h->non_ir_ref_dynamic)
1749             {
1750               (*info->callbacks->warning) (info, string, h->root.string,
1751                                            hash_entry_bfd (h), NULL, 0);
1752               break;
1753             }
1754           /* Fall through.  */
1755         case MWARN:
1756           /* Make a warning symbol.  */
1757           {
1758             struct bfd_link_hash_entry *sub;
1759
1760             /* STRING is the warning to give.  */
1761             sub = ((struct bfd_link_hash_entry *)
1762                    ((*info->hash->table.newfunc)
1763                     (NULL, &info->hash->table, h->root.string)));
1764             if (sub == NULL)
1765               return FALSE;
1766             *sub = *h;
1767             sub->type = bfd_link_hash_warning;
1768             sub->u.i.link = h;
1769             if (! copy)
1770               sub->u.i.warning = string;
1771             else
1772               {
1773                 char *w;
1774                 size_t len = strlen (string) + 1;
1775
1776                 w = (char *) bfd_hash_allocate (&info->hash->table, len);
1777                 if (w == NULL)
1778                   return FALSE;
1779                 memcpy (w, string, len);
1780                 sub->u.i.warning = w;
1781               }
1782
1783             bfd_hash_replace (&info->hash->table,
1784                               (struct bfd_hash_entry *) h,
1785                               (struct bfd_hash_entry *) sub);
1786             if (hashp != NULL)
1787               *hashp = sub;
1788           }
1789           break;
1790         }
1791     }
1792   while (cycle);
1793
1794   return TRUE;
1795 }
1796 \f
1797 /* Generic final link routine.  */
1798
1799 bfd_boolean
1800 _bfd_generic_final_link (bfd *abfd, struct bfd_link_info *info)
1801 {
1802   bfd *sub;
1803   asection *o;
1804   struct bfd_link_order *p;
1805   size_t outsymalloc;
1806   struct generic_write_global_symbol_info wginfo;
1807
1808   bfd_get_outsymbols (abfd) = NULL;
1809   bfd_get_symcount (abfd) = 0;
1810   outsymalloc = 0;
1811
1812   /* Mark all sections which will be included in the output file.  */
1813   for (o = abfd->sections; o != NULL; o = o->next)
1814     for (p = o->map_head.link_order; p != NULL; p = p->next)
1815       if (p->type == bfd_indirect_link_order)
1816         p->u.indirect.section->linker_mark = TRUE;
1817
1818   /* Build the output symbol table.  */
1819   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
1820     if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
1821       return FALSE;
1822
1823   /* Accumulate the global symbols.  */
1824   wginfo.info = info;
1825   wginfo.output_bfd = abfd;
1826   wginfo.psymalloc = &outsymalloc;
1827   _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info),
1828                                    _bfd_generic_link_write_global_symbol,
1829                                    &wginfo);
1830
1831   /* Make sure we have a trailing NULL pointer on OUTSYMBOLS.  We
1832      shouldn't really need one, since we have SYMCOUNT, but some old
1833      code still expects one.  */
1834   if (! generic_add_output_symbol (abfd, &outsymalloc, NULL))
1835     return FALSE;
1836
1837   if (bfd_link_relocatable (info))
1838     {
1839       /* Allocate space for the output relocs for each section.  */
1840       for (o = abfd->sections; o != NULL; o = o->next)
1841         {
1842           o->reloc_count = 0;
1843           for (p = o->map_head.link_order; p != NULL; p = p->next)
1844             {
1845               if (p->type == bfd_section_reloc_link_order
1846                   || p->type == bfd_symbol_reloc_link_order)
1847                 ++o->reloc_count;
1848               else if (p->type == bfd_indirect_link_order)
1849                 {
1850                   asection *input_section;
1851                   bfd *input_bfd;
1852                   long relsize;
1853                   arelent **relocs;
1854                   asymbol **symbols;
1855                   long reloc_count;
1856
1857                   input_section = p->u.indirect.section;
1858                   input_bfd = input_section->owner;
1859                   relsize = bfd_get_reloc_upper_bound (input_bfd,
1860                                                        input_section);
1861                   if (relsize < 0)
1862                     return FALSE;
1863                   relocs = (arelent **) bfd_malloc (relsize);
1864                   if (!relocs && relsize != 0)
1865                     return FALSE;
1866                   symbols = _bfd_generic_link_get_symbols (input_bfd);
1867                   reloc_count = bfd_canonicalize_reloc (input_bfd,
1868                                                         input_section,
1869                                                         relocs,
1870                                                         symbols);
1871                   free (relocs);
1872                   if (reloc_count < 0)
1873                     return FALSE;
1874                   BFD_ASSERT ((unsigned long) reloc_count
1875                               == input_section->reloc_count);
1876                   o->reloc_count += reloc_count;
1877                 }
1878             }
1879           if (o->reloc_count > 0)
1880             {
1881               bfd_size_type amt;
1882
1883               amt = o->reloc_count;
1884               amt *= sizeof (arelent *);
1885               o->orelocation = (struct reloc_cache_entry **) bfd_alloc (abfd, amt);
1886               if (!o->orelocation)
1887                 return FALSE;
1888               o->flags |= SEC_RELOC;
1889               /* Reset the count so that it can be used as an index
1890                  when putting in the output relocs.  */
1891               o->reloc_count = 0;
1892             }
1893         }
1894     }
1895
1896   /* Handle all the link order information for the sections.  */
1897   for (o = abfd->sections; o != NULL; o = o->next)
1898     {
1899       for (p = o->map_head.link_order; p != NULL; p = p->next)
1900         {
1901           switch (p->type)
1902             {
1903             case bfd_section_reloc_link_order:
1904             case bfd_symbol_reloc_link_order:
1905               if (! _bfd_generic_reloc_link_order (abfd, info, o, p))
1906                 return FALSE;
1907               break;
1908             case bfd_indirect_link_order:
1909               if (! default_indirect_link_order (abfd, info, o, p, TRUE))
1910                 return FALSE;
1911               break;
1912             default:
1913               if (! _bfd_default_link_order (abfd, info, o, p))
1914                 return FALSE;
1915               break;
1916             }
1917         }
1918     }
1919
1920   return TRUE;
1921 }
1922
1923 /* Add an output symbol to the output BFD.  */
1924
1925 static bfd_boolean
1926 generic_add_output_symbol (bfd *output_bfd, size_t *psymalloc, asymbol *sym)
1927 {
1928   if (bfd_get_symcount (output_bfd) >= *psymalloc)
1929     {
1930       asymbol **newsyms;
1931       bfd_size_type amt;
1932
1933       if (*psymalloc == 0)
1934         *psymalloc = 124;
1935       else
1936         *psymalloc *= 2;
1937       amt = *psymalloc;
1938       amt *= sizeof (asymbol *);
1939       newsyms = (asymbol **) bfd_realloc (bfd_get_outsymbols (output_bfd), amt);
1940       if (newsyms == NULL)
1941         return FALSE;
1942       bfd_get_outsymbols (output_bfd) = newsyms;
1943     }
1944
1945   bfd_get_outsymbols (output_bfd) [bfd_get_symcount (output_bfd)] = sym;
1946   if (sym != NULL)
1947     ++ bfd_get_symcount (output_bfd);
1948
1949   return TRUE;
1950 }
1951
1952 /* Handle the symbols for an input BFD.  */
1953
1954 bfd_boolean
1955 _bfd_generic_link_output_symbols (bfd *output_bfd,
1956                                   bfd *input_bfd,
1957                                   struct bfd_link_info *info,
1958                                   size_t *psymalloc)
1959 {
1960   asymbol **sym_ptr;
1961   asymbol **sym_end;
1962
1963   if (!bfd_generic_link_read_symbols (input_bfd))
1964     return FALSE;
1965
1966   /* Create a filename symbol if we are supposed to.  */
1967   if (info->create_object_symbols_section != NULL)
1968     {
1969       asection *sec;
1970
1971       for (sec = input_bfd->sections; sec != NULL; sec = sec->next)
1972         {
1973           if (sec->output_section == info->create_object_symbols_section)
1974             {
1975               asymbol *newsym;
1976
1977               newsym = bfd_make_empty_symbol (input_bfd);
1978               if (!newsym)
1979                 return FALSE;
1980               newsym->name = input_bfd->filename;
1981               newsym->value = 0;
1982               newsym->flags = BSF_LOCAL | BSF_FILE;
1983               newsym->section = sec;
1984
1985               if (! generic_add_output_symbol (output_bfd, psymalloc,
1986                                                newsym))
1987                 return FALSE;
1988
1989               break;
1990             }
1991         }
1992     }
1993
1994   /* Adjust the values of the globally visible symbols, and write out
1995      local symbols.  */
1996   sym_ptr = _bfd_generic_link_get_symbols (input_bfd);
1997   sym_end = sym_ptr + _bfd_generic_link_get_symcount (input_bfd);
1998   for (; sym_ptr < sym_end; sym_ptr++)
1999     {
2000       asymbol *sym;
2001       struct generic_link_hash_entry *h;
2002       bfd_boolean output;
2003
2004       h = NULL;
2005       sym = *sym_ptr;
2006       if ((sym->flags & (BSF_INDIRECT
2007                          | BSF_WARNING
2008                          | BSF_GLOBAL
2009                          | BSF_CONSTRUCTOR
2010                          | BSF_WEAK)) != 0
2011           || bfd_is_und_section (bfd_get_section (sym))
2012           || bfd_is_com_section (bfd_get_section (sym))
2013           || bfd_is_ind_section (bfd_get_section (sym)))
2014         {
2015           if (sym->udata.p != NULL)
2016             h = (struct generic_link_hash_entry *) sym->udata.p;
2017           else if ((sym->flags & BSF_CONSTRUCTOR) != 0)
2018             {
2019               /* This case normally means that the main linker code
2020                  deliberately ignored this constructor symbol.  We
2021                  should just pass it through.  This will screw up if
2022                  the constructor symbol is from a different,
2023                  non-generic, object file format, but the case will
2024                  only arise when linking with -r, which will probably
2025                  fail anyhow, since there will be no way to represent
2026                  the relocs in the output format being used.  */
2027               h = NULL;
2028             }
2029           else if (bfd_is_und_section (bfd_get_section (sym)))
2030             h = ((struct generic_link_hash_entry *)
2031                  bfd_wrapped_link_hash_lookup (output_bfd, info,
2032                                                bfd_asymbol_name (sym),
2033                                                FALSE, FALSE, TRUE));
2034           else
2035             h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
2036                                                bfd_asymbol_name (sym),
2037                                                FALSE, FALSE, TRUE);
2038
2039           if (h != NULL)
2040             {
2041               /* Force all references to this symbol to point to
2042                  the same area in memory.  It is possible that
2043                  this routine will be called with a hash table
2044                  other than a generic hash table, so we double
2045                  check that.  */
2046               if (info->output_bfd->xvec == input_bfd->xvec)
2047                 {
2048                   if (h->sym != NULL)
2049                     *sym_ptr = sym = h->sym;
2050                 }
2051
2052               switch (h->root.type)
2053                 {
2054                 default:
2055                 case bfd_link_hash_new:
2056                   abort ();
2057                 case bfd_link_hash_undefined:
2058                   break;
2059                 case bfd_link_hash_undefweak:
2060                   sym->flags |= BSF_WEAK;
2061                   break;
2062                 case bfd_link_hash_indirect:
2063                   h = (struct generic_link_hash_entry *) h->root.u.i.link;
2064                   /* fall through */
2065                 case bfd_link_hash_defined:
2066                   sym->flags |= BSF_GLOBAL;
2067                   sym->flags &=~ (BSF_WEAK | BSF_CONSTRUCTOR);
2068                   sym->value = h->root.u.def.value;
2069                   sym->section = h->root.u.def.section;
2070                   break;
2071                 case bfd_link_hash_defweak:
2072                   sym->flags |= BSF_WEAK;
2073                   sym->flags &=~ BSF_CONSTRUCTOR;
2074                   sym->value = h->root.u.def.value;
2075                   sym->section = h->root.u.def.section;
2076                   break;
2077                 case bfd_link_hash_common:
2078                   sym->value = h->root.u.c.size;
2079                   sym->flags |= BSF_GLOBAL;
2080                   if (! bfd_is_com_section (sym->section))
2081                     {
2082                       BFD_ASSERT (bfd_is_und_section (sym->section));
2083                       sym->section = bfd_com_section_ptr;
2084                     }
2085                   /* We do not set the section of the symbol to
2086                      h->root.u.c.p->section.  That value was saved so
2087                      that we would know where to allocate the symbol
2088                      if it was defined.  In this case the type is
2089                      still bfd_link_hash_common, so we did not define
2090                      it, so we do not want to use that section.  */
2091                   break;
2092                 }
2093             }
2094         }
2095
2096       /* This switch is straight from the old code in
2097          write_file_locals in ldsym.c.  */
2098       if (info->strip == strip_all
2099           || (info->strip == strip_some
2100               && bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym),
2101                                   FALSE, FALSE) == NULL))
2102         output = FALSE;
2103       else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0)
2104         {
2105           /* If this symbol is marked as occurring now, rather
2106              than at the end, output it now.  This is used for
2107              COFF C_EXT FCN symbols.  FIXME: There must be a
2108              better way.  */
2109           if (bfd_asymbol_bfd (sym) == input_bfd
2110               && (sym->flags & BSF_NOT_AT_END) != 0)
2111             output = TRUE;
2112           else
2113             output = FALSE;
2114         }
2115       else if (bfd_is_ind_section (sym->section))
2116         output = FALSE;
2117       else if ((sym->flags & BSF_DEBUGGING) != 0)
2118         {
2119           if (info->strip == strip_none)
2120             output = TRUE;
2121           else
2122             output = FALSE;
2123         }
2124       else if (bfd_is_und_section (sym->section)
2125                || bfd_is_com_section (sym->section))
2126         output = FALSE;
2127       else if ((sym->flags & BSF_LOCAL) != 0)
2128         {
2129           if ((sym->flags & BSF_WARNING) != 0)
2130             output = FALSE;
2131           else
2132             {
2133               switch (info->discard)
2134                 {
2135                 default:
2136                 case discard_all:
2137                   output = FALSE;
2138                   break;
2139                 case discard_sec_merge:
2140                   output = TRUE;
2141                   if (bfd_link_relocatable (info)
2142                       || ! (sym->section->flags & SEC_MERGE))
2143                     break;
2144                   /* FALLTHROUGH */
2145                 case discard_l:
2146                   if (bfd_is_local_label (input_bfd, sym))
2147                     output = FALSE;
2148                   else
2149                     output = TRUE;
2150                   break;
2151                 case discard_none:
2152                   output = TRUE;
2153                   break;
2154                 }
2155             }
2156         }
2157       else if ((sym->flags & BSF_CONSTRUCTOR))
2158         {
2159           if (info->strip != strip_all)
2160             output = TRUE;
2161           else
2162             output = FALSE;
2163         }
2164       else if (sym->flags == 0
2165                && (sym->section->owner->flags & BFD_PLUGIN) != 0)
2166         /* LTO doesn't set symbol information.  We get here with the
2167            generic linker for a symbol that was "common" but no longer
2168            needs to be global.  */
2169         output = FALSE;
2170       else
2171         abort ();
2172
2173       /* If this symbol is in a section which is not being included
2174          in the output file, then we don't want to output the
2175          symbol.  */
2176       if (!bfd_is_abs_section (sym->section)
2177           && bfd_section_removed_from_list (output_bfd,
2178                                             sym->section->output_section))
2179         output = FALSE;
2180
2181       if (output)
2182         {
2183           if (! generic_add_output_symbol (output_bfd, psymalloc, sym))
2184             return FALSE;
2185           if (h != NULL)
2186             h->written = TRUE;
2187         }
2188     }
2189
2190   return TRUE;
2191 }
2192
2193 /* Set the section and value of a generic BFD symbol based on a linker
2194    hash table entry.  */
2195
2196 static void
2197 set_symbol_from_hash (asymbol *sym, struct bfd_link_hash_entry *h)
2198 {
2199   switch (h->type)
2200     {
2201     default:
2202       abort ();
2203       break;
2204     case bfd_link_hash_new:
2205       /* This can happen when a constructor symbol is seen but we are
2206          not building constructors.  */
2207       if (sym->section != NULL)
2208         {
2209           BFD_ASSERT ((sym->flags & BSF_CONSTRUCTOR) != 0);
2210         }
2211       else
2212         {
2213           sym->flags |= BSF_CONSTRUCTOR;
2214           sym->section = bfd_abs_section_ptr;
2215           sym->value = 0;
2216         }
2217       break;
2218     case bfd_link_hash_undefined:
2219       sym->section = bfd_und_section_ptr;
2220       sym->value = 0;
2221       break;
2222     case bfd_link_hash_undefweak:
2223       sym->section = bfd_und_section_ptr;
2224       sym->value = 0;
2225       sym->flags |= BSF_WEAK;
2226       break;
2227     case bfd_link_hash_defined:
2228       sym->section = h->u.def.section;
2229       sym->value = h->u.def.value;
2230       break;
2231     case bfd_link_hash_defweak:
2232       sym->flags |= BSF_WEAK;
2233       sym->section = h->u.def.section;
2234       sym->value = h->u.def.value;
2235       break;
2236     case bfd_link_hash_common:
2237       sym->value = h->u.c.size;
2238       if (sym->section == NULL)
2239         sym->section = bfd_com_section_ptr;
2240       else if (! bfd_is_com_section (sym->section))
2241         {
2242           BFD_ASSERT (bfd_is_und_section (sym->section));
2243           sym->section = bfd_com_section_ptr;
2244         }
2245       /* Do not set the section; see _bfd_generic_link_output_symbols.  */
2246       break;
2247     case bfd_link_hash_indirect:
2248     case bfd_link_hash_warning:
2249       /* FIXME: What should we do here?  */
2250       break;
2251     }
2252 }
2253
2254 /* Write out a global symbol, if it hasn't already been written out.
2255    This is called for each symbol in the hash table.  */
2256
2257 bfd_boolean
2258 _bfd_generic_link_write_global_symbol (struct generic_link_hash_entry *h,
2259                                        void *data)
2260 {
2261   struct generic_write_global_symbol_info *wginfo =
2262       (struct generic_write_global_symbol_info *) data;
2263   asymbol *sym;
2264
2265   if (h->written)
2266     return TRUE;
2267
2268   h->written = TRUE;
2269
2270   if (wginfo->info->strip == strip_all
2271       || (wginfo->info->strip == strip_some
2272           && bfd_hash_lookup (wginfo->info->keep_hash, h->root.root.string,
2273                               FALSE, FALSE) == NULL))
2274     return TRUE;
2275
2276   if (h->sym != NULL)
2277     sym = h->sym;
2278   else
2279     {
2280       sym = bfd_make_empty_symbol (wginfo->output_bfd);
2281       if (!sym)
2282         return FALSE;
2283       sym->name = h->root.root.string;
2284       sym->flags = 0;
2285     }
2286
2287   set_symbol_from_hash (sym, &h->root);
2288
2289   sym->flags |= BSF_GLOBAL;
2290
2291   if (! generic_add_output_symbol (wginfo->output_bfd, wginfo->psymalloc,
2292                                    sym))
2293     {
2294       /* FIXME: No way to return failure.  */
2295       abort ();
2296     }
2297
2298   return TRUE;
2299 }
2300
2301 /* Create a relocation.  */
2302
2303 bfd_boolean
2304 _bfd_generic_reloc_link_order (bfd *abfd,
2305                                struct bfd_link_info *info,
2306                                asection *sec,
2307                                struct bfd_link_order *link_order)
2308 {
2309   arelent *r;
2310
2311   if (! bfd_link_relocatable (info))
2312     abort ();
2313   if (sec->orelocation == NULL)
2314     abort ();
2315
2316   r = (arelent *) bfd_alloc (abfd, sizeof (arelent));
2317   if (r == NULL)
2318     return FALSE;
2319
2320   r->address = link_order->offset;
2321   r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc);
2322   if (r->howto == 0)
2323     {
2324       bfd_set_error (bfd_error_bad_value);
2325       return FALSE;
2326     }
2327
2328   /* Get the symbol to use for the relocation.  */
2329   if (link_order->type == bfd_section_reloc_link_order)
2330     r->sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
2331   else
2332     {
2333       struct generic_link_hash_entry *h;
2334
2335       h = ((struct generic_link_hash_entry *)
2336            bfd_wrapped_link_hash_lookup (abfd, info,
2337                                          link_order->u.reloc.p->u.name,
2338                                          FALSE, FALSE, TRUE));
2339       if (h == NULL
2340           || ! h->written)
2341         {
2342           (*info->callbacks->unattached_reloc)
2343             (info, link_order->u.reloc.p->u.name, NULL, NULL, 0);
2344           bfd_set_error (bfd_error_bad_value);
2345           return FALSE;
2346         }
2347       r->sym_ptr_ptr = &h->sym;
2348     }
2349
2350   /* If this is an inplace reloc, write the addend to the object file.
2351      Otherwise, store it in the reloc addend.  */
2352   if (! r->howto->partial_inplace)
2353     r->addend = link_order->u.reloc.p->addend;
2354   else
2355     {
2356       bfd_size_type size;
2357       bfd_reloc_status_type rstat;
2358       bfd_byte *buf;
2359       bfd_boolean ok;
2360       file_ptr loc;
2361
2362       size = bfd_get_reloc_size (r->howto);
2363       buf = (bfd_byte *) bfd_zmalloc (size);
2364       if (buf == NULL && size != 0)
2365         return FALSE;
2366       rstat = _bfd_relocate_contents (r->howto, abfd,
2367                                       (bfd_vma) link_order->u.reloc.p->addend,
2368                                       buf);
2369       switch (rstat)
2370         {
2371         case bfd_reloc_ok:
2372           break;
2373         default:
2374         case bfd_reloc_outofrange:
2375           abort ();
2376         case bfd_reloc_overflow:
2377           (*info->callbacks->reloc_overflow)
2378             (info, NULL,
2379              (link_order->type == bfd_section_reloc_link_order
2380               ? bfd_section_name (abfd, link_order->u.reloc.p->u.section)
2381               : link_order->u.reloc.p->u.name),
2382              r->howto->name, link_order->u.reloc.p->addend,
2383              NULL, NULL, 0);
2384           break;
2385         }
2386       loc = link_order->offset * bfd_octets_per_byte (abfd);
2387       ok = bfd_set_section_contents (abfd, sec, buf, loc, size);
2388       free (buf);
2389       if (! ok)
2390         return FALSE;
2391
2392       r->addend = 0;
2393     }
2394
2395   sec->orelocation[sec->reloc_count] = r;
2396   ++sec->reloc_count;
2397
2398   return TRUE;
2399 }
2400 \f
2401 /* Allocate a new link_order for a section.  */
2402
2403 struct bfd_link_order *
2404 bfd_new_link_order (bfd *abfd, asection *section)
2405 {
2406   bfd_size_type amt = sizeof (struct bfd_link_order);
2407   struct bfd_link_order *new_lo;
2408
2409   new_lo = (struct bfd_link_order *) bfd_zalloc (abfd, amt);
2410   if (!new_lo)
2411     return NULL;
2412
2413   new_lo->type = bfd_undefined_link_order;
2414
2415   if (section->map_tail.link_order != NULL)
2416     section->map_tail.link_order->next = new_lo;
2417   else
2418     section->map_head.link_order = new_lo;
2419   section->map_tail.link_order = new_lo;
2420
2421   return new_lo;
2422 }
2423
2424 /* Default link order processing routine.  Note that we can not handle
2425    the reloc_link_order types here, since they depend upon the details
2426    of how the particular backends generates relocs.  */
2427
2428 bfd_boolean
2429 _bfd_default_link_order (bfd *abfd,
2430                          struct bfd_link_info *info,
2431                          asection *sec,
2432                          struct bfd_link_order *link_order)
2433 {
2434   switch (link_order->type)
2435     {
2436     case bfd_undefined_link_order:
2437     case bfd_section_reloc_link_order:
2438     case bfd_symbol_reloc_link_order:
2439     default:
2440       abort ();
2441     case bfd_indirect_link_order:
2442       return default_indirect_link_order (abfd, info, sec, link_order,
2443                                           FALSE);
2444     case bfd_data_link_order:
2445       return default_data_link_order (abfd, info, sec, link_order);
2446     }
2447 }
2448
2449 /* Default routine to handle a bfd_data_link_order.  */
2450
2451 static bfd_boolean
2452 default_data_link_order (bfd *abfd,
2453                          struct bfd_link_info *info ATTRIBUTE_UNUSED,
2454                          asection *sec,
2455                          struct bfd_link_order *link_order)
2456 {
2457   bfd_size_type size;
2458   size_t fill_size;
2459   bfd_byte *fill;
2460   file_ptr loc;
2461   bfd_boolean result;
2462
2463   BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0);
2464
2465   size = link_order->size;
2466   if (size == 0)
2467     return TRUE;
2468
2469   fill = link_order->u.data.contents;
2470   fill_size = link_order->u.data.size;
2471   if (fill_size == 0)
2472     {
2473       fill = abfd->arch_info->fill (size, bfd_big_endian (abfd),
2474                                     (sec->flags & SEC_CODE) != 0);
2475       if (fill == NULL)
2476         return FALSE;
2477     }
2478   else if (fill_size < size)
2479     {
2480       bfd_byte *p;
2481       fill = (bfd_byte *) bfd_malloc (size);
2482       if (fill == NULL)
2483         return FALSE;
2484       p = fill;
2485       if (fill_size == 1)
2486         memset (p, (int) link_order->u.data.contents[0], (size_t) size);
2487       else
2488         {
2489           do
2490             {
2491               memcpy (p, link_order->u.data.contents, fill_size);
2492               p += fill_size;
2493               size -= fill_size;
2494             }
2495           while (size >= fill_size);
2496           if (size != 0)
2497             memcpy (p, link_order->u.data.contents, (size_t) size);
2498           size = link_order->size;
2499         }
2500     }
2501
2502   loc = link_order->offset * bfd_octets_per_byte (abfd);
2503   result = bfd_set_section_contents (abfd, sec, fill, loc, size);
2504
2505   if (fill != link_order->u.data.contents)
2506     free (fill);
2507   return result;
2508 }
2509
2510 /* Default routine to handle a bfd_indirect_link_order.  */
2511
2512 static bfd_boolean
2513 default_indirect_link_order (bfd *output_bfd,
2514                              struct bfd_link_info *info,
2515                              asection *output_section,
2516                              struct bfd_link_order *link_order,
2517                              bfd_boolean generic_linker)
2518 {
2519   asection *input_section;
2520   bfd *input_bfd;
2521   bfd_byte *contents = NULL;
2522   bfd_byte *new_contents;
2523   bfd_size_type sec_size;
2524   file_ptr loc;
2525
2526   BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
2527
2528   input_section = link_order->u.indirect.section;
2529   input_bfd = input_section->owner;
2530   if (input_section->size == 0)
2531     return TRUE;
2532
2533   BFD_ASSERT (input_section->output_section == output_section);
2534   BFD_ASSERT (input_section->output_offset == link_order->offset);
2535   BFD_ASSERT (input_section->size == link_order->size);
2536
2537   if (bfd_link_relocatable (info)
2538       && input_section->reloc_count > 0
2539       && output_section->orelocation == NULL)
2540     {
2541       /* Space has not been allocated for the output relocations.
2542          This can happen when we are called by a specific backend
2543          because somebody is attempting to link together different
2544          types of object files.  Handling this case correctly is
2545          difficult, and sometimes impossible.  */
2546       _bfd_error_handler
2547         /* xgettext:c-format */
2548         (_("attempt to do relocatable link with %s input and %s output"),
2549          bfd_get_target (input_bfd), bfd_get_target (output_bfd));
2550       bfd_set_error (bfd_error_wrong_format);
2551       return FALSE;
2552     }
2553
2554   if (! generic_linker)
2555     {
2556       asymbol **sympp;
2557       asymbol **symppend;
2558
2559       /* Get the canonical symbols.  The generic linker will always
2560          have retrieved them by this point, but we are being called by
2561          a specific linker, presumably because we are linking
2562          different types of object files together.  */
2563       if (!bfd_generic_link_read_symbols (input_bfd))
2564         return FALSE;
2565
2566       /* Since we have been called by a specific linker, rather than
2567          the generic linker, the values of the symbols will not be
2568          right.  They will be the values as seen in the input file,
2569          not the values of the final link.  We need to fix them up
2570          before we can relocate the section.  */
2571       sympp = _bfd_generic_link_get_symbols (input_bfd);
2572       symppend = sympp + _bfd_generic_link_get_symcount (input_bfd);
2573       for (; sympp < symppend; sympp++)
2574         {
2575           asymbol *sym;
2576           struct bfd_link_hash_entry *h;
2577
2578           sym = *sympp;
2579
2580           if ((sym->flags & (BSF_INDIRECT
2581                              | BSF_WARNING
2582                              | BSF_GLOBAL
2583                              | BSF_CONSTRUCTOR
2584                              | BSF_WEAK)) != 0
2585               || bfd_is_und_section (bfd_get_section (sym))
2586               || bfd_is_com_section (bfd_get_section (sym))
2587               || bfd_is_ind_section (bfd_get_section (sym)))
2588             {
2589               /* sym->udata may have been set by
2590                  generic_link_add_symbol_list.  */
2591               if (sym->udata.p != NULL)
2592                 h = (struct bfd_link_hash_entry *) sym->udata.p;
2593               else if (bfd_is_und_section (bfd_get_section (sym)))
2594                 h = bfd_wrapped_link_hash_lookup (output_bfd, info,
2595                                                   bfd_asymbol_name (sym),
2596                                                   FALSE, FALSE, TRUE);
2597               else
2598                 h = bfd_link_hash_lookup (info->hash,
2599                                           bfd_asymbol_name (sym),
2600                                           FALSE, FALSE, TRUE);
2601               if (h != NULL)
2602                 set_symbol_from_hash (sym, h);
2603             }
2604         }
2605     }
2606
2607   if ((output_section->flags & (SEC_GROUP | SEC_LINKER_CREATED)) == SEC_GROUP
2608       && input_section->size != 0)
2609     {
2610       /* Group section contents are set by bfd_elf_set_group_contents.  */
2611       if (!output_bfd->output_has_begun)
2612         {
2613           /* FIXME: This hack ensures bfd_elf_set_group_contents is called.  */
2614           if (!bfd_set_section_contents (output_bfd, output_section, "", 0, 1))
2615             goto error_return;
2616         }
2617       new_contents = output_section->contents;
2618       BFD_ASSERT (new_contents != NULL);
2619       BFD_ASSERT (input_section->output_offset == 0);
2620     }
2621   else
2622     {
2623       /* Get and relocate the section contents.  */
2624       sec_size = (input_section->rawsize > input_section->size
2625                   ? input_section->rawsize
2626                   : input_section->size);
2627       contents = (bfd_byte *) bfd_malloc (sec_size);
2628       if (contents == NULL && sec_size != 0)
2629         goto error_return;
2630       new_contents = (bfd_get_relocated_section_contents
2631                       (output_bfd, info, link_order, contents,
2632                        bfd_link_relocatable (info),
2633                        _bfd_generic_link_get_symbols (input_bfd)));
2634       if (!new_contents)
2635         goto error_return;
2636     }
2637
2638   /* Output the section contents.  */
2639   loc = input_section->output_offset * bfd_octets_per_byte (output_bfd);
2640   if (! bfd_set_section_contents (output_bfd, output_section,
2641                                   new_contents, loc, input_section->size))
2642     goto error_return;
2643
2644   if (contents != NULL)
2645     free (contents);
2646   return TRUE;
2647
2648  error_return:
2649   if (contents != NULL)
2650     free (contents);
2651   return FALSE;
2652 }
2653
2654 /* A little routine to count the number of relocs in a link_order
2655    list.  */
2656
2657 unsigned int
2658 _bfd_count_link_order_relocs (struct bfd_link_order *link_order)
2659 {
2660   register unsigned int c;
2661   register struct bfd_link_order *l;
2662
2663   c = 0;
2664   for (l = link_order; l != NULL; l = l->next)
2665     {
2666       if (l->type == bfd_section_reloc_link_order
2667           || l->type == bfd_symbol_reloc_link_order)
2668         ++c;
2669     }
2670
2671   return c;
2672 }
2673
2674 /*
2675 FUNCTION
2676         bfd_link_split_section
2677
2678 SYNOPSIS
2679         bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);
2680
2681 DESCRIPTION
2682         Return nonzero if @var{sec} should be split during a
2683         reloceatable or final link.
2684
2685 .#define bfd_link_split_section(abfd, sec) \
2686 .       BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
2687 .
2688
2689 */
2690
2691 bfd_boolean
2692 _bfd_generic_link_split_section (bfd *abfd ATTRIBUTE_UNUSED,
2693                                  asection *sec ATTRIBUTE_UNUSED)
2694 {
2695   return FALSE;
2696 }
2697
2698 /*
2699 FUNCTION
2700         bfd_section_already_linked
2701
2702 SYNOPSIS
2703         bfd_boolean bfd_section_already_linked (bfd *abfd,
2704                                                 asection *sec,
2705                                                 struct bfd_link_info *info);
2706
2707 DESCRIPTION
2708         Check if @var{data} has been already linked during a reloceatable
2709         or final link.  Return TRUE if it has.
2710
2711 .#define bfd_section_already_linked(abfd, sec, info) \
2712 .       BFD_SEND (abfd, _section_already_linked, (abfd, sec, info))
2713 .
2714
2715 */
2716
2717 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
2718    once into the output.  This routine checks each section, and
2719    arrange to discard it if a section of the same name has already
2720    been linked.  This code assumes that all relevant sections have the
2721    SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
2722    section name.  bfd_section_already_linked is called via
2723    bfd_map_over_sections.  */
2724
2725 /* The hash table.  */
2726
2727 static struct bfd_hash_table _bfd_section_already_linked_table;
2728
2729 /* Support routines for the hash table used by section_already_linked,
2730    initialize the table, traverse, lookup, fill in an entry and remove
2731    the table.  */
2732
2733 void
2734 bfd_section_already_linked_table_traverse
2735   (bfd_boolean (*func) (struct bfd_section_already_linked_hash_entry *,
2736                         void *), void *info)
2737 {
2738   bfd_hash_traverse (&_bfd_section_already_linked_table,
2739                      (bfd_boolean (*) (struct bfd_hash_entry *,
2740                                        void *)) func,
2741                      info);
2742 }
2743
2744 struct bfd_section_already_linked_hash_entry *
2745 bfd_section_already_linked_table_lookup (const char *name)
2746 {
2747   return ((struct bfd_section_already_linked_hash_entry *)
2748           bfd_hash_lookup (&_bfd_section_already_linked_table, name,
2749                            TRUE, FALSE));
2750 }
2751
2752 bfd_boolean
2753 bfd_section_already_linked_table_insert
2754   (struct bfd_section_already_linked_hash_entry *already_linked_list,
2755    asection *sec)
2756 {
2757   struct bfd_section_already_linked *l;
2758
2759   /* Allocate the memory from the same obstack as the hash table is
2760      kept in.  */
2761   l = (struct bfd_section_already_linked *)
2762       bfd_hash_allocate (&_bfd_section_already_linked_table, sizeof *l);
2763   if (l == NULL)
2764     return FALSE;
2765   l->sec = sec;
2766   l->next = already_linked_list->entry;
2767   already_linked_list->entry = l;
2768   return TRUE;
2769 }
2770
2771 static struct bfd_hash_entry *
2772 already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED,
2773                         struct bfd_hash_table *table,
2774                         const char *string ATTRIBUTE_UNUSED)
2775 {
2776   struct bfd_section_already_linked_hash_entry *ret =
2777     (struct bfd_section_already_linked_hash_entry *)
2778       bfd_hash_allocate (table, sizeof *ret);
2779
2780   if (ret == NULL)
2781     return NULL;
2782
2783   ret->entry = NULL;
2784
2785   return &ret->root;
2786 }
2787
2788 bfd_boolean
2789 bfd_section_already_linked_table_init (void)
2790 {
2791   return bfd_hash_table_init_n (&_bfd_section_already_linked_table,
2792                                 already_linked_newfunc,
2793                                 sizeof (struct bfd_section_already_linked_hash_entry),
2794                                 42);
2795 }
2796
2797 void
2798 bfd_section_already_linked_table_free (void)
2799 {
2800   bfd_hash_table_free (&_bfd_section_already_linked_table);
2801 }
2802
2803 /* Report warnings as appropriate for duplicate section SEC.
2804    Return FALSE if we decide to keep SEC after all.  */
2805
2806 bfd_boolean
2807 _bfd_handle_already_linked (asection *sec,
2808                             struct bfd_section_already_linked *l,
2809                             struct bfd_link_info *info)
2810 {
2811   switch (sec->flags & SEC_LINK_DUPLICATES)
2812     {
2813     default:
2814       abort ();
2815
2816     case SEC_LINK_DUPLICATES_DISCARD:
2817       /* If we found an LTO IR match for this comdat group on
2818          the first pass, replace it with the LTO output on the
2819          second pass.  We can't simply choose real object
2820          files over IR because the first pass may contain a
2821          mix of LTO and normal objects and we must keep the
2822          first match, be it IR or real.  */
2823       if (sec->owner->lto_output
2824           && (l->sec->owner->flags & BFD_PLUGIN) != 0)
2825         {
2826           l->sec = sec;
2827           return FALSE;
2828         }
2829       break;
2830
2831     case SEC_LINK_DUPLICATES_ONE_ONLY:
2832       info->callbacks->einfo
2833         /* xgettext:c-format */
2834         (_("%pB: ignoring duplicate section `%pA'\n"),
2835          sec->owner, sec);
2836       break;
2837
2838     case SEC_LINK_DUPLICATES_SAME_SIZE:
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           (_("%pB: duplicate section `%pA' has different size\n"),
2845            sec->owner, sec);
2846       break;
2847
2848     case SEC_LINK_DUPLICATES_SAME_CONTENTS:
2849       if ((l->sec->owner->flags & BFD_PLUGIN) != 0)
2850         ;
2851       else if (sec->size != l->sec->size)
2852         info->callbacks->einfo
2853           /* xgettext:c-format */
2854           (_("%pB: duplicate section `%pA' has different size\n"),
2855            sec->owner, sec);
2856       else if (sec->size != 0)
2857         {
2858           bfd_byte *sec_contents, *l_sec_contents = NULL;
2859
2860           if (!bfd_malloc_and_get_section (sec->owner, sec, &sec_contents))
2861             info->callbacks->einfo
2862               /* xgettext:c-format */
2863               (_("%pB: could not read contents of section `%pA'\n"),
2864                sec->owner, sec);
2865           else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec,
2866                                                 &l_sec_contents))
2867             info->callbacks->einfo
2868               /* xgettext:c-format */
2869               (_("%pB: could not read contents of section `%pA'\n"),
2870                l->sec->owner, l->sec);
2871           else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0)
2872             info->callbacks->einfo
2873               /* xgettext:c-format */
2874               (_("%pB: duplicate section `%pA' has different contents\n"),
2875                sec->owner, sec);
2876
2877           if (sec_contents)
2878             free (sec_contents);
2879           if (l_sec_contents)
2880             free (l_sec_contents);
2881         }
2882       break;
2883     }
2884
2885   /* Set the output_section field so that lang_add_section
2886      does not create a lang_input_section structure for this
2887      section.  Since there might be a symbol in the section
2888      being discarded, we must retain a pointer to the section
2889      which we are really going to use.  */
2890   sec->output_section = bfd_abs_section_ptr;
2891   sec->kept_section = l->sec;
2892   return TRUE;
2893 }
2894
2895 /* This is used on non-ELF inputs.  */
2896
2897 bfd_boolean
2898 _bfd_generic_section_already_linked (bfd *abfd ATTRIBUTE_UNUSED,
2899                                      asection *sec,
2900                                      struct bfd_link_info *info)
2901 {
2902   const char *name;
2903   struct bfd_section_already_linked *l;
2904   struct bfd_section_already_linked_hash_entry *already_linked_list;
2905
2906   if ((sec->flags & SEC_LINK_ONCE) == 0)
2907     return FALSE;
2908
2909   /* The generic linker doesn't handle section groups.  */
2910   if ((sec->flags & SEC_GROUP) != 0)
2911     return FALSE;
2912
2913   /* FIXME: When doing a relocatable link, we may have trouble
2914      copying relocations in other sections that refer to local symbols
2915      in the section being discarded.  Those relocations will have to
2916      be converted somehow; as of this writing I'm not sure that any of
2917      the backends handle that correctly.
2918
2919      It is tempting to instead not discard link once sections when
2920      doing a relocatable link (technically, they should be discarded
2921      whenever we are building constructors).  However, that fails,
2922      because the linker winds up combining all the link once sections
2923      into a single large link once section, which defeats the purpose
2924      of having link once sections in the first place.  */
2925
2926   name = bfd_get_section_name (abfd, sec);
2927
2928   already_linked_list = bfd_section_already_linked_table_lookup (name);
2929
2930   l = already_linked_list->entry;
2931   if (l != NULL)
2932     {
2933       /* The section has already been linked.  See if we should
2934          issue a warning.  */
2935       return _bfd_handle_already_linked (sec, l, info);
2936     }
2937
2938   /* This is the first section with this name.  Record it.  */
2939   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2940     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2941   return FALSE;
2942 }
2943
2944 /* Choose a neighbouring section to S in OBFD that will be output, or
2945    the absolute section if ADDR is out of bounds of the neighbours.  */
2946
2947 asection *
2948 _bfd_nearby_section (bfd *obfd, asection *s, bfd_vma addr)
2949 {
2950   asection *next, *prev, *best;
2951
2952   /* Find preceding kept section.  */
2953   for (prev = s->prev; prev != NULL; prev = prev->prev)
2954     if ((prev->flags & SEC_EXCLUDE) == 0
2955         && !bfd_section_removed_from_list (obfd, prev))
2956       break;
2957
2958   /* Find following kept section.  Start at prev->next because
2959      other sections may have been added after S was removed.  */
2960   if (s->prev != NULL)
2961     next = s->prev->next;
2962   else
2963     next = s->owner->sections;
2964   for (; next != NULL; next = next->next)
2965     if ((next->flags & SEC_EXCLUDE) == 0
2966         && !bfd_section_removed_from_list (obfd, next))
2967       break;
2968
2969   /* Choose better of two sections, based on flags.  The idea
2970      is to choose a section that will be in the same segment
2971      as S would have been if it was kept.  */
2972   best = next;
2973   if (prev == NULL)
2974     {
2975       if (next == NULL)
2976         best = bfd_abs_section_ptr;
2977     }
2978   else if (next == NULL)
2979     best = prev;
2980   else if (((prev->flags ^ next->flags)
2981             & (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_LOAD)) != 0)
2982     {
2983       if (((next->flags ^ s->flags)
2984            & (SEC_ALLOC | SEC_THREAD_LOCAL)) != 0
2985           /* We prefer to choose a loaded section.  Section S
2986              doesn't have SEC_LOAD set (it being excluded, that
2987              part of the flag processing didn't happen) so we
2988              can't compare that flag to those of NEXT and PREV.  */
2989           || ((prev->flags & SEC_LOAD) != 0
2990               && (next->flags & SEC_LOAD) == 0))
2991         best = prev;
2992     }
2993   else if (((prev->flags ^ next->flags) & SEC_READONLY) != 0)
2994     {
2995       if (((next->flags ^ s->flags) & SEC_READONLY) != 0)
2996         best = prev;
2997     }
2998   else if (((prev->flags ^ next->flags) & SEC_CODE) != 0)
2999     {
3000       if (((next->flags ^ s->flags) & SEC_CODE) != 0)
3001         best = prev;
3002     }
3003   else
3004     {
3005       /* Flags we care about are the same.  Prefer the following
3006          section if that will result in a positive valued sym.  */
3007       if (addr < next->vma)
3008         best = prev;
3009     }
3010
3011   return best;
3012 }
3013
3014 /* Convert symbols in excluded output sections to use a kept section.  */
3015
3016 static bfd_boolean
3017 fix_syms (struct bfd_link_hash_entry *h, void *data)
3018 {
3019   bfd *obfd = (bfd *) data;
3020
3021   if (h->type == bfd_link_hash_defined
3022       || h->type == bfd_link_hash_defweak)
3023     {
3024       asection *s = h->u.def.section;
3025       if (s != NULL
3026           && s->output_section != NULL
3027           && (s->output_section->flags & SEC_EXCLUDE) != 0
3028           && bfd_section_removed_from_list (obfd, s->output_section))
3029         {
3030           asection *op;
3031
3032           h->u.def.value += s->output_offset + s->output_section->vma;
3033           op = _bfd_nearby_section (obfd, s->output_section, h->u.def.value);
3034           h->u.def.value -= op->vma;
3035           h->u.def.section = op;
3036         }
3037     }
3038
3039   return TRUE;
3040 }
3041
3042 void
3043 _bfd_fix_excluded_sec_syms (bfd *obfd, struct bfd_link_info *info)
3044 {
3045   bfd_link_hash_traverse (info->hash, fix_syms, obfd);
3046 }
3047
3048 /*
3049 FUNCTION
3050         bfd_generic_define_common_symbol
3051
3052 SYNOPSIS
3053         bfd_boolean bfd_generic_define_common_symbol
3054           (bfd *output_bfd, struct bfd_link_info *info,
3055            struct bfd_link_hash_entry *h);
3056
3057 DESCRIPTION
3058         Convert common symbol @var{h} into a defined symbol.
3059         Return TRUE on success and FALSE on failure.
3060
3061 .#define bfd_define_common_symbol(output_bfd, info, h) \
3062 .       BFD_SEND (output_bfd, _bfd_define_common_symbol, (output_bfd, info, h))
3063 .
3064 */
3065
3066 bfd_boolean
3067 bfd_generic_define_common_symbol (bfd *output_bfd,
3068                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
3069                                   struct bfd_link_hash_entry *h)
3070 {
3071   unsigned int power_of_two;
3072   bfd_vma alignment, size;
3073   asection *section;
3074
3075   BFD_ASSERT (h != NULL && h->type == bfd_link_hash_common);
3076
3077   size = h->u.c.size;
3078   power_of_two = h->u.c.p->alignment_power;
3079   section = h->u.c.p->section;
3080
3081   /* Increase the size of the section to align the common symbol.
3082      The alignment must be a power of two.  */
3083   alignment = bfd_octets_per_byte (output_bfd) << power_of_two;
3084   BFD_ASSERT (alignment != 0 && (alignment & -alignment) == alignment);
3085   section->size += alignment - 1;
3086   section->size &= -alignment;
3087
3088   /* Adjust the section's overall alignment if necessary.  */
3089   if (power_of_two > section->alignment_power)
3090     section->alignment_power = power_of_two;
3091
3092   /* Change the symbol from common to defined.  */
3093   h->type = bfd_link_hash_defined;
3094   h->u.def.section = section;
3095   h->u.def.value = section->size;
3096
3097   /* Increase the size of the section.  */
3098   section->size += size;
3099
3100   /* Make sure the section is allocated in memory, and make sure that
3101      it is no longer a common section.  */
3102   section->flags |= SEC_ALLOC;
3103   section->flags &= ~SEC_IS_COMMON;
3104   return TRUE;
3105 }
3106
3107 /*
3108 FUNCTION
3109         bfd_generic_define_start_stop
3110
3111 SYNOPSIS
3112         struct bfd_link_hash_entry *bfd_generic_define_start_stop
3113           (struct bfd_link_info *info,
3114            const char *symbol, asection *sec);
3115
3116 DESCRIPTION
3117         Define a __start, __stop, .startof. or .sizeof. symbol.
3118         Return the symbol or NULL if no such undefined symbol exists.
3119
3120 .#define bfd_define_start_stop(output_bfd, info, symbol, sec) \
3121 .       BFD_SEND (output_bfd, _bfd_define_start_stop, (info, symbol, sec))
3122 .
3123 */
3124
3125 struct bfd_link_hash_entry *
3126 bfd_generic_define_start_stop (struct bfd_link_info *info,
3127                                const char *symbol, asection *sec)
3128 {
3129   struct bfd_link_hash_entry *h;
3130
3131   h = bfd_link_hash_lookup (info->hash, symbol, FALSE, FALSE, TRUE);
3132   if (h != NULL
3133       && (h->type == bfd_link_hash_undefined
3134           || h->type == bfd_link_hash_undefweak))
3135     {
3136       h->type = bfd_link_hash_defined;
3137       h->u.def.section = sec;
3138       h->u.def.value = 0;
3139       return h;
3140     }
3141   return NULL;
3142 }
3143
3144 /*
3145 FUNCTION
3146         bfd_find_version_for_sym
3147
3148 SYNOPSIS
3149         struct bfd_elf_version_tree * bfd_find_version_for_sym
3150           (struct bfd_elf_version_tree *verdefs,
3151            const char *sym_name, bfd_boolean *hide);
3152
3153 DESCRIPTION
3154         Search an elf version script tree for symbol versioning
3155         info and export / don't-export status for a given symbol.
3156         Return non-NULL on success and NULL on failure; also sets
3157         the output @samp{hide} boolean parameter.
3158
3159 */
3160
3161 struct bfd_elf_version_tree *
3162 bfd_find_version_for_sym (struct bfd_elf_version_tree *verdefs,
3163                           const char *sym_name,
3164                           bfd_boolean *hide)
3165 {
3166   struct bfd_elf_version_tree *t;
3167   struct bfd_elf_version_tree *local_ver, *global_ver, *exist_ver;
3168   struct bfd_elf_version_tree *star_local_ver, *star_global_ver;
3169
3170   local_ver = NULL;
3171   global_ver = NULL;
3172   star_local_ver = NULL;
3173   star_global_ver = NULL;
3174   exist_ver = NULL;
3175   for (t = verdefs; t != NULL; t = t->next)
3176     {
3177       if (t->globals.list != NULL)
3178         {
3179           struct bfd_elf_version_expr *d = NULL;
3180
3181           while ((d = (*t->match) (&t->globals, d, sym_name)) != NULL)
3182             {
3183               if (d->literal || strcmp (d->pattern, "*") != 0)
3184                 global_ver = t;
3185               else
3186                 star_global_ver = t;
3187               if (d->symver)
3188                 exist_ver = t;
3189               d->script = 1;
3190               /* If the match is a wildcard pattern, keep looking for
3191                  a more explicit, perhaps even local, match.  */
3192               if (d->literal)
3193                 break;
3194             }
3195
3196           if (d != NULL)
3197             break;
3198         }
3199
3200       if (t->locals.list != NULL)
3201         {
3202           struct bfd_elf_version_expr *d = NULL;
3203
3204           while ((d = (*t->match) (&t->locals, d, sym_name)) != NULL)
3205             {
3206               if (d->literal || strcmp (d->pattern, "*") != 0)
3207                 local_ver = t;
3208               else
3209                 star_local_ver = t;
3210               /* If the match is a wildcard pattern, keep looking for
3211                  a more explicit, perhaps even global, match.  */
3212               if (d->literal)
3213                 {
3214                   /* An exact match overrides a global wildcard.  */
3215                   global_ver = NULL;
3216                   star_global_ver = NULL;
3217                   break;
3218                 }
3219             }
3220
3221           if (d != NULL)
3222             break;
3223         }
3224     }
3225
3226   if (global_ver == NULL && local_ver == NULL)
3227     global_ver = star_global_ver;
3228
3229   if (global_ver != NULL)
3230     {
3231       /* If we already have a versioned symbol that matches the
3232          node for this symbol, then we don't want to create a
3233          duplicate from the unversioned symbol.  Instead hide the
3234          unversioned symbol.  */
3235       *hide = exist_ver == global_ver;
3236       return global_ver;
3237     }
3238
3239   if (local_ver == NULL)
3240     local_ver = star_local_ver;
3241
3242   if (local_ver != NULL)
3243     {
3244       *hide = TRUE;
3245       return local_ver;
3246     }
3247
3248   return NULL;
3249 }
3250
3251 /*
3252 FUNCTION
3253         bfd_hide_sym_by_version
3254
3255 SYNOPSIS
3256         bfd_boolean bfd_hide_sym_by_version
3257           (struct bfd_elf_version_tree *verdefs, const char *sym_name);
3258
3259 DESCRIPTION
3260         Search an elf version script tree for symbol versioning
3261         info for a given symbol.  Return TRUE if the symbol is hidden.
3262
3263 */
3264
3265 bfd_boolean
3266 bfd_hide_sym_by_version (struct bfd_elf_version_tree *verdefs,
3267                          const char *sym_name)
3268 {
3269   bfd_boolean hidden = FALSE;
3270   bfd_find_version_for_sym (verdefs, sym_name, &hidden);
3271   return hidden;
3272 }
3273
3274 /*
3275 FUNCTION
3276         bfd_link_check_relocs
3277
3278 SYNOPSIS
3279         bfd_boolean bfd_link_check_relocs
3280           (bfd *abfd, struct bfd_link_info *info);
3281
3282 DESCRIPTION
3283         Checks the relocs in ABFD for validity.
3284         Does not execute the relocs.
3285         Return TRUE if everything is OK, FALSE otherwise.
3286         This is the external entry point to this code.
3287 */
3288
3289 bfd_boolean
3290 bfd_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
3291 {
3292   return BFD_SEND (abfd, _bfd_link_check_relocs, (abfd, info));
3293 }
3294
3295 /*
3296 FUNCTION
3297         _bfd_generic_link_check_relocs
3298
3299 SYNOPSIS
3300         bfd_boolean _bfd_generic_link_check_relocs
3301           (bfd *abfd, struct bfd_link_info *info);
3302
3303 DESCRIPTION
3304         Stub function for targets that do not implement reloc checking.
3305         Return TRUE.
3306         This is an internal function.  It should not be called from
3307         outside the BFD library.
3308 */
3309
3310 bfd_boolean
3311 _bfd_generic_link_check_relocs (bfd *abfd ATTRIBUTE_UNUSED,
3312                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3313 {
3314   return TRUE;
3315 }
3316
3317 /*
3318 FUNCTION
3319         bfd_merge_private_bfd_data
3320
3321 SYNOPSIS
3322         bfd_boolean bfd_merge_private_bfd_data
3323           (bfd *ibfd, struct bfd_link_info *info);
3324
3325 DESCRIPTION
3326         Merge private BFD information from the BFD @var{ibfd} to the
3327         the output file BFD when linking.  Return <<TRUE>> on success,
3328         <<FALSE>> on error.  Possible error returns are:
3329
3330         o <<bfd_error_no_memory>> -
3331         Not enough memory exists to create private data for @var{obfd}.
3332
3333 .#define bfd_merge_private_bfd_data(ibfd, info) \
3334 .       BFD_SEND ((info)->output_bfd, _bfd_merge_private_bfd_data, \
3335 .                 (ibfd, info))
3336 */
3337
3338 /*
3339 INTERNAL_FUNCTION
3340         _bfd_generic_verify_endian_match
3341
3342 SYNOPSIS
3343         bfd_boolean _bfd_generic_verify_endian_match
3344           (bfd *ibfd, struct bfd_link_info *info);
3345
3346 DESCRIPTION
3347         Can be used from / for bfd_merge_private_bfd_data to check that
3348         endianness matches between input and output file.  Returns
3349         TRUE for a match, otherwise returns FALSE and emits an error.
3350 */
3351
3352 bfd_boolean
3353 _bfd_generic_verify_endian_match (bfd *ibfd, struct bfd_link_info *info)
3354 {
3355   bfd *obfd = info->output_bfd;
3356
3357   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
3358       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
3359       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
3360     {
3361       if (bfd_big_endian (ibfd))
3362         _bfd_error_handler (_("%pB: compiled for a big endian system "
3363                               "and target is little endian"), ibfd);
3364       else
3365         _bfd_error_handler (_("%pB: compiled for a little endian system "
3366                               "and target is big endian"), ibfd);
3367       bfd_set_error (bfd_error_wrong_format);
3368       return FALSE;
3369     }
3370
3371   return TRUE;
3372 }
3373
3374 int
3375 _bfd_nolink_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
3376                             struct bfd_link_info *info ATTRIBUTE_UNUSED)
3377 {
3378   return 0;
3379 }
3380
3381 bfd_boolean
3382 _bfd_nolink_bfd_relax_section (bfd *abfd,
3383                                asection *section ATTRIBUTE_UNUSED,
3384                                struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
3385                                bfd_boolean *again ATTRIBUTE_UNUSED)
3386 {
3387   return _bfd_bool_bfd_false_error (abfd);
3388 }
3389
3390 bfd_byte *
3391 _bfd_nolink_bfd_get_relocated_section_contents
3392     (bfd *abfd,
3393      struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
3394      struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
3395      bfd_byte *data ATTRIBUTE_UNUSED,
3396      bfd_boolean relocatable ATTRIBUTE_UNUSED,
3397      asymbol **symbols ATTRIBUTE_UNUSED)
3398 {
3399   return (bfd_byte *) _bfd_ptr_bfd_null_error (abfd);
3400 }
3401
3402 bfd_boolean
3403 _bfd_nolink_bfd_lookup_section_flags
3404     (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3405      struct flag_info *flaginfo ATTRIBUTE_UNUSED,
3406      asection *section)
3407 {
3408   return _bfd_bool_bfd_false_error (section->owner);
3409 }
3410
3411 bfd_boolean
3412 _bfd_nolink_bfd_is_group_section (bfd *abfd,
3413                                   const asection *sec ATTRIBUTE_UNUSED)
3414 {
3415   return _bfd_bool_bfd_false_error (abfd);
3416 }
3417
3418 bfd_boolean
3419 _bfd_nolink_bfd_discard_group (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
3420 {
3421   return _bfd_bool_bfd_false_error (abfd);
3422 }
3423
3424 struct bfd_link_hash_table *
3425 _bfd_nolink_bfd_link_hash_table_create (bfd *abfd)
3426 {
3427   return (struct bfd_link_hash_table *) _bfd_ptr_bfd_null_error (abfd);
3428 }
3429
3430 void
3431 _bfd_nolink_bfd_link_just_syms (asection *sec ATTRIBUTE_UNUSED,
3432                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3433 {
3434 }
3435
3436 void
3437 _bfd_nolink_bfd_copy_link_hash_symbol_type
3438     (bfd *abfd ATTRIBUTE_UNUSED,
3439      struct bfd_link_hash_entry *from ATTRIBUTE_UNUSED,
3440      struct bfd_link_hash_entry *to ATTRIBUTE_UNUSED)
3441 {
3442 }
3443
3444 bfd_boolean
3445 _bfd_nolink_bfd_link_split_section (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
3446 {
3447   return _bfd_bool_bfd_false_error (abfd);
3448 }
3449
3450 bfd_boolean
3451 _bfd_nolink_section_already_linked (bfd *abfd,
3452                                     asection *sec ATTRIBUTE_UNUSED,
3453                                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
3454 {
3455   return _bfd_bool_bfd_false_error (abfd);
3456 }
3457
3458 bfd_boolean
3459 _bfd_nolink_bfd_define_common_symbol
3460     (bfd *abfd,
3461      struct bfd_link_info *info ATTRIBUTE_UNUSED,
3462      struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED)
3463 {
3464   return _bfd_bool_bfd_false_error (abfd);
3465 }
3466
3467 struct bfd_link_hash_entry *
3468 _bfd_nolink_bfd_define_start_stop (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3469                                    const char *name ATTRIBUTE_UNUSED,
3470                                    asection *sec)
3471 {
3472   return (struct bfd_link_hash_entry *) _bfd_ptr_bfd_null_error (sec->owner);
3473 }