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