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