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, 2010, 2011
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support
7 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
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
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.
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
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.
66 @* Creating a Linker Hash Table::
67 @* Adding Symbols to the Hash Table::
68 @* Performing the Final Link::
72 Creating a Linker Hash Table, Adding Symbols to the Hash Table, Linker Functions, Linker Functions
74 Creating a linker hash table
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.
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.
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
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.
110 Adding Symbols to the Hash Table, Performing the Final Link, Creating a Linker Hash Table, Linker Functions
112 Adding symbols to the hash table
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
126 The a.out version of this entry point is
127 <<NAME(aout,link_add_symbols)>>.
130 @* Differing file formats::
131 @* Adding symbols from an object file::
132 @* Adding symbols from an archive::
136 Differing file formats, Adding symbols from an object file, Adding Symbols to the Hash Table, Adding Symbols to the Hash Table
138 Differing file formats
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>>.
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.
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.
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
173 Adding symbols from an object file, Adding symbols from an archive, Differing file formats, Adding Symbols to the Hash Table
175 Adding symbols from an object file
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>>.
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.
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.
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.
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.
217 Adding symbols from an archive, , Adding symbols from an object file, Adding Symbols to the Hash Table
219 Adding symbols from an archive
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.)
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.
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.
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.
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.
277 Performing the Final Link, , Adding Symbols to the Hash Table, Linker Functions
279 Performing the final link
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.
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.
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)>>.
303 @* Information provided by the linker::
304 @* Relocating the section contents::
305 @* Writing the symbol table::
309 Information provided by the linker, Relocating the section contents, Performing the Final Link, Performing the Final Link
311 Information provided by the linker
313 Before the linker calls the <<_bfd_final_link>> entry point,
314 it sets up some data structures for the function to use.
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.
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.
333 Relocating the section contents, Writing the symbol table, Information provided by the linker, Performing the Final Link
335 Relocating the section contents
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>>).
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.
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>>.
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>>.
371 Writing the symbol table, , Relocating the section contents, Performing the Final Link
373 Writing the symbol table
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.
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.
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.
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.
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.
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)>>.
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
**,
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
*,
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
444 /* Routine to create an entry in the link hash table. */
446 struct bfd_hash_entry
*
447 _bfd_link_hash_newfunc (struct bfd_hash_entry
*entry
,
448 struct bfd_hash_table
*table
,
451 /* Allocate the structure if it has not already been allocated by a
455 entry
= (struct bfd_hash_entry
*)
456 bfd_hash_allocate (table
, sizeof (struct bfd_link_hash_entry
));
461 /* Call the allocation method of the superclass. */
462 entry
= bfd_hash_newfunc (entry
, table
, string
);
465 struct bfd_link_hash_entry
*h
= (struct bfd_link_hash_entry
*) entry
;
467 /* Initialize the local fields. */
468 memset ((char *) &h
->root
+ sizeof (h
->root
), 0,
469 sizeof (*h
) - sizeof (h
->root
));
475 /* Initialize a link hash table. The BFD argument is the one
476 responsible for creating this table. */
479 _bfd_link_hash_table_init
480 (struct bfd_link_hash_table
*table
,
481 bfd
*abfd ATTRIBUTE_UNUSED
,
482 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
483 struct bfd_hash_table
*,
485 unsigned int entsize
)
487 table
->undefs
= NULL
;
488 table
->undefs_tail
= NULL
;
489 table
->type
= bfd_link_generic_hash_table
;
491 return bfd_hash_table_init (&table
->table
, newfunc
, entsize
);
494 /* Look up a symbol in a link hash table. If follow is TRUE, we
495 follow bfd_link_hash_indirect and bfd_link_hash_warning links to
498 struct bfd_link_hash_entry
*
499 bfd_link_hash_lookup (struct bfd_link_hash_table
*table
,
505 struct bfd_link_hash_entry
*ret
;
507 ret
= ((struct bfd_link_hash_entry
*)
508 bfd_hash_lookup (&table
->table
, string
, create
, copy
));
510 if (follow
&& ret
!= NULL
)
512 while (ret
->type
== bfd_link_hash_indirect
513 || ret
->type
== bfd_link_hash_warning
)
520 /* Look up a symbol in the main linker hash table if the symbol might
521 be wrapped. This should only be used for references to an
522 undefined symbol, not for definitions of a symbol. */
524 struct bfd_link_hash_entry
*
525 bfd_wrapped_link_hash_lookup (bfd
*abfd
,
526 struct bfd_link_info
*info
,
534 if (info
->wrap_hash
!= NULL
)
540 if (*l
== bfd_get_symbol_leading_char (abfd
) || *l
== info
->wrap_char
)
547 #define WRAP "__wrap_"
549 if (bfd_hash_lookup (info
->wrap_hash
, l
, FALSE
, FALSE
) != NULL
)
552 struct bfd_link_hash_entry
*h
;
554 /* This symbol is being wrapped. We want to replace all
555 references to SYM with references to __wrap_SYM. */
557 amt
= strlen (l
) + sizeof WRAP
+ 1;
558 n
= (char *) bfd_malloc (amt
);
566 h
= bfd_link_hash_lookup (info
->hash
, n
, create
, TRUE
, follow
);
574 #define REAL "__real_"
577 && CONST_STRNEQ (l
, REAL
)
578 && bfd_hash_lookup (info
->wrap_hash
, l
+ sizeof REAL
- 1,
579 FALSE
, FALSE
) != NULL
)
582 struct bfd_link_hash_entry
*h
;
584 /* This is a reference to __real_SYM, where SYM is being
585 wrapped. We want to replace all references to __real_SYM
586 with references to SYM. */
588 amt
= strlen (l
+ sizeof REAL
- 1) + 2;
589 n
= (char *) bfd_malloc (amt
);
595 strcat (n
, l
+ sizeof REAL
- 1);
596 h
= bfd_link_hash_lookup (info
->hash
, n
, create
, TRUE
, follow
);
604 return bfd_link_hash_lookup (info
->hash
, string
, create
, copy
, follow
);
607 /* Traverse a generic link hash table. The only reason this is not a
608 macro is to do better type checking. This code presumes that an
609 argument passed as a struct bfd_hash_entry * may be caught as a
610 struct bfd_link_hash_entry * with no explicit cast required on the
614 bfd_link_hash_traverse
615 (struct bfd_link_hash_table
*table
,
616 bfd_boolean (*func
) (struct bfd_link_hash_entry
*, void *),
619 bfd_hash_traverse (&table
->table
,
620 (bfd_boolean (*) (struct bfd_hash_entry
*, void *)) func
,
624 /* Add a symbol to the linker hash table undefs list. */
627 bfd_link_add_undef (struct bfd_link_hash_table
*table
,
628 struct bfd_link_hash_entry
*h
)
630 BFD_ASSERT (h
->u
.undef
.next
== NULL
);
631 if (table
->undefs_tail
!= NULL
)
632 table
->undefs_tail
->u
.undef
.next
= h
;
633 if (table
->undefs
== NULL
)
635 table
->undefs_tail
= h
;
638 /* The undefs list was designed so that in normal use we don't need to
639 remove entries. However, if symbols on the list are changed from
640 bfd_link_hash_undefined to either bfd_link_hash_undefweak or
641 bfd_link_hash_new for some reason, then they must be removed from the
642 list. Failure to do so might result in the linker attempting to add
643 the symbol to the list again at a later stage. */
646 bfd_link_repair_undef_list (struct bfd_link_hash_table
*table
)
648 struct bfd_link_hash_entry
**pun
;
650 pun
= &table
->undefs
;
653 struct bfd_link_hash_entry
*h
= *pun
;
655 if (h
->type
== bfd_link_hash_new
656 || h
->type
== bfd_link_hash_undefweak
)
658 *pun
= h
->u
.undef
.next
;
659 h
->u
.undef
.next
= NULL
;
660 if (h
== table
->undefs_tail
)
662 if (pun
== &table
->undefs
)
663 table
->undefs_tail
= NULL
;
665 /* pun points at an u.undef.next field. Go back to
666 the start of the link_hash_entry. */
667 table
->undefs_tail
= (struct bfd_link_hash_entry
*)
668 ((char *) pun
- ((char *) &h
->u
.undef
.next
- (char *) h
));
673 pun
= &h
->u
.undef
.next
;
677 /* Routine to create an entry in a generic link hash table. */
679 struct bfd_hash_entry
*
680 _bfd_generic_link_hash_newfunc (struct bfd_hash_entry
*entry
,
681 struct bfd_hash_table
*table
,
684 /* Allocate the structure if it has not already been allocated by a
688 entry
= (struct bfd_hash_entry
*)
689 bfd_hash_allocate (table
, sizeof (struct generic_link_hash_entry
));
694 /* Call the allocation method of the superclass. */
695 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
698 struct generic_link_hash_entry
*ret
;
700 /* Set local fields. */
701 ret
= (struct generic_link_hash_entry
*) entry
;
702 ret
->written
= FALSE
;
709 /* Create a generic link hash table. */
711 struct bfd_link_hash_table
*
712 _bfd_generic_link_hash_table_create (bfd
*abfd
)
714 struct generic_link_hash_table
*ret
;
715 bfd_size_type amt
= sizeof (struct generic_link_hash_table
);
717 ret
= (struct generic_link_hash_table
*) bfd_malloc (amt
);
720 if (! _bfd_link_hash_table_init (&ret
->root
, abfd
,
721 _bfd_generic_link_hash_newfunc
,
722 sizeof (struct generic_link_hash_entry
)))
731 _bfd_generic_link_hash_table_free (struct bfd_link_hash_table
*hash
)
733 struct generic_link_hash_table
*ret
734 = (struct generic_link_hash_table
*) hash
;
736 bfd_hash_table_free (&ret
->root
.table
);
740 /* Grab the symbols for an object file when doing a generic link. We
741 store the symbols in the outsymbols field. We need to keep them
742 around for the entire link to ensure that we only read them once.
743 If we read them multiple times, we might wind up with relocs and
744 the hash table pointing to different instances of the symbol
748 bfd_generic_link_read_symbols (bfd
*abfd
)
750 if (bfd_get_outsymbols (abfd
) == NULL
)
755 symsize
= bfd_get_symtab_upper_bound (abfd
);
758 bfd_get_outsymbols (abfd
) = (struct bfd_symbol
**) bfd_alloc (abfd
,
760 if (bfd_get_outsymbols (abfd
) == NULL
&& symsize
!= 0)
762 symcount
= bfd_canonicalize_symtab (abfd
, bfd_get_outsymbols (abfd
));
765 bfd_get_symcount (abfd
) = symcount
;
771 /* Generic function to add symbols to from an object file to the
772 global hash table. This version does not automatically collect
773 constructors by name. */
776 _bfd_generic_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
778 return generic_link_add_symbols (abfd
, info
, FALSE
);
781 /* Generic function to add symbols from an object file to the global
782 hash table. This version automatically collects constructors by
783 name, as the collect2 program does. It should be used for any
784 target which does not provide some other mechanism for setting up
785 constructors and destructors; these are approximately those targets
786 for which gcc uses collect2 and do not support stabs. */
789 _bfd_generic_link_add_symbols_collect (bfd
*abfd
, struct bfd_link_info
*info
)
791 return generic_link_add_symbols (abfd
, info
, TRUE
);
794 /* Indicate that we are only retrieving symbol values from this
795 section. We want the symbols to act as though the values in the
796 file are absolute. */
799 _bfd_generic_link_just_syms (asection
*sec
,
800 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
802 sec
->output_section
= bfd_abs_section_ptr
;
803 sec
->output_offset
= sec
->vma
;
806 /* Copy the type of a symbol assiciated with a linker hast table entry.
807 Override this so that symbols created in linker scripts get their
808 type from the RHS of the assignment.
809 The default implementation does nothing. */
811 _bfd_generic_copy_link_hash_symbol_type (bfd
*abfd ATTRIBUTE_UNUSED
,
812 struct bfd_link_hash_entry
* hdest ATTRIBUTE_UNUSED
,
813 struct bfd_link_hash_entry
* hsrc ATTRIBUTE_UNUSED
)
817 /* Add symbols from an object file to the global hash table. */
820 generic_link_add_symbols (bfd
*abfd
,
821 struct bfd_link_info
*info
,
826 switch (bfd_get_format (abfd
))
829 ret
= generic_link_add_object_symbols (abfd
, info
, collect
);
832 ret
= (_bfd_generic_link_add_archive_symbols
835 ? generic_link_check_archive_element_collect
836 : generic_link_check_archive_element_no_collect
)));
839 bfd_set_error (bfd_error_wrong_format
);
846 /* Add symbols from an object file to the global hash table. */
849 generic_link_add_object_symbols (bfd
*abfd
,
850 struct bfd_link_info
*info
,
853 bfd_size_type symcount
;
854 struct bfd_symbol
**outsyms
;
856 if (!bfd_generic_link_read_symbols (abfd
))
858 symcount
= _bfd_generic_link_get_symcount (abfd
);
859 outsyms
= _bfd_generic_link_get_symbols (abfd
);
860 return generic_link_add_symbol_list (abfd
, info
, symcount
, outsyms
, collect
);
863 /* We build a hash table of all symbols defined in an archive. */
865 /* An archive symbol may be defined by multiple archive elements.
866 This linked list is used to hold the elements. */
870 struct archive_list
*next
;
874 /* An entry in an archive hash table. */
876 struct archive_hash_entry
878 struct bfd_hash_entry root
;
879 /* Where the symbol is defined. */
880 struct archive_list
*defs
;
883 /* An archive hash table itself. */
885 struct archive_hash_table
887 struct bfd_hash_table table
;
890 /* Create a new entry for an archive hash table. */
892 static struct bfd_hash_entry
*
893 archive_hash_newfunc (struct bfd_hash_entry
*entry
,
894 struct bfd_hash_table
*table
,
897 struct archive_hash_entry
*ret
= (struct archive_hash_entry
*) entry
;
899 /* Allocate the structure if it has not already been allocated by a
902 ret
= (struct archive_hash_entry
*)
903 bfd_hash_allocate (table
, sizeof (struct archive_hash_entry
));
907 /* Call the allocation method of the superclass. */
908 ret
= ((struct archive_hash_entry
*)
909 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
913 /* Initialize the local fields. */
920 /* Initialize an archive hash table. */
923 archive_hash_table_init
924 (struct archive_hash_table
*table
,
925 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
926 struct bfd_hash_table
*,
928 unsigned int entsize
)
930 return bfd_hash_table_init (&table
->table
, newfunc
, entsize
);
933 /* Look up an entry in an archive hash table. */
935 #define archive_hash_lookup(t, string, create, copy) \
936 ((struct archive_hash_entry *) \
937 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
939 /* Allocate space in an archive hash table. */
941 #define archive_hash_allocate(t, size) bfd_hash_allocate (&(t)->table, (size))
943 /* Free an archive hash table. */
945 #define archive_hash_table_free(t) bfd_hash_table_free (&(t)->table)
947 /* Generic function to add symbols from an archive file to the global
948 hash file. This function presumes that the archive symbol table
949 has already been read in (this is normally done by the
950 bfd_check_format entry point). It looks through the undefined and
951 common symbols and searches the archive symbol table for them. If
952 it finds an entry, it includes the associated object file in the
955 The old linker looked through the archive symbol table for
956 undefined symbols. We do it the other way around, looking through
957 undefined symbols for symbols defined in the archive. The
958 advantage of the newer scheme is that we only have to look through
959 the list of undefined symbols once, whereas the old method had to
960 re-search the symbol table each time a new object file was added.
962 The CHECKFN argument is used to see if an object file should be
963 included. CHECKFN should set *PNEEDED to TRUE if the object file
964 should be included, and must also call the bfd_link_info
965 add_archive_element callback function and handle adding the symbols
966 to the global hash table. CHECKFN must notice if the callback
967 indicates a substitute BFD, and arrange to add those symbols instead
968 if it does so. CHECKFN should only return FALSE if some sort of
971 For some formats, such as a.out, it is possible to look through an
972 object file but not actually include it in the link. The
973 archive_pass field in a BFD is used to avoid checking the symbols
974 of an object files too many times. When an object is included in
975 the link, archive_pass is set to -1. If an object is scanned but
976 not included, archive_pass is set to the pass number. The pass
977 number is incremented each time a new object file is included. The
978 pass number is used because when a new object file is included it
979 may create new undefined symbols which cause a previously examined
980 object file to be included. */
983 _bfd_generic_link_add_archive_symbols
985 struct bfd_link_info
*info
,
986 bfd_boolean (*checkfn
) (bfd
*, struct bfd_link_info
*, bfd_boolean
*))
990 register carsym
*arsym
;
992 struct archive_hash_table arsym_hash
;
994 struct bfd_link_hash_entry
**pundef
;
996 if (! bfd_has_map (abfd
))
998 /* An empty archive is a special case. */
999 if (bfd_openr_next_archived_file (abfd
, NULL
) == NULL
)
1001 bfd_set_error (bfd_error_no_armap
);
1005 arsyms
= bfd_ardata (abfd
)->symdefs
;
1006 arsym_end
= arsyms
+ bfd_ardata (abfd
)->symdef_count
;
1008 /* In order to quickly determine whether an symbol is defined in
1009 this archive, we build a hash table of the symbols. */
1010 if (! archive_hash_table_init (&arsym_hash
, archive_hash_newfunc
,
1011 sizeof (struct archive_hash_entry
)))
1013 for (arsym
= arsyms
, indx
= 0; arsym
< arsym_end
; arsym
++, indx
++)
1015 struct archive_hash_entry
*arh
;
1016 struct archive_list
*l
, **pp
;
1018 arh
= archive_hash_lookup (&arsym_hash
, arsym
->name
, TRUE
, FALSE
);
1021 l
= ((struct archive_list
*)
1022 archive_hash_allocate (&arsym_hash
, sizeof (struct archive_list
)));
1026 for (pp
= &arh
->defs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1032 /* The archive_pass field in the archive itself is used to
1033 initialize PASS, sine we may search the same archive multiple
1035 pass
= abfd
->archive_pass
+ 1;
1037 /* New undefined symbols are added to the end of the list, so we
1038 only need to look through it once. */
1039 pundef
= &info
->hash
->undefs
;
1040 while (*pundef
!= NULL
)
1042 struct bfd_link_hash_entry
*h
;
1043 struct archive_hash_entry
*arh
;
1044 struct archive_list
*l
;
1048 /* When a symbol is defined, it is not necessarily removed from
1050 if (h
->type
!= bfd_link_hash_undefined
1051 && h
->type
!= bfd_link_hash_common
)
1053 /* Remove this entry from the list, for general cleanliness
1054 and because we are going to look through the list again
1055 if we search any more libraries. We can't remove the
1056 entry if it is the tail, because that would lose any
1057 entries we add to the list later on (it would also cause
1058 us to lose track of whether the symbol has been
1060 if (*pundef
!= info
->hash
->undefs_tail
)
1061 *pundef
= (*pundef
)->u
.undef
.next
;
1063 pundef
= &(*pundef
)->u
.undef
.next
;
1067 /* Look for this symbol in the archive symbol map. */
1068 arh
= archive_hash_lookup (&arsym_hash
, h
->root
.string
, FALSE
, FALSE
);
1071 /* If we haven't found the exact symbol we're looking for,
1072 let's look for its import thunk */
1073 if (info
->pei386_auto_import
)
1075 bfd_size_type amt
= strlen (h
->root
.string
) + 10;
1076 char *buf
= (char *) bfd_malloc (amt
);
1080 sprintf (buf
, "__imp_%s", h
->root
.string
);
1081 arh
= archive_hash_lookup (&arsym_hash
, buf
, FALSE
, FALSE
);
1086 pundef
= &(*pundef
)->u
.undef
.next
;
1090 /* Look at all the objects which define this symbol. */
1091 for (l
= arh
->defs
; l
!= NULL
; l
= l
->next
)
1096 /* If the symbol has gotten defined along the way, quit. */
1097 if (h
->type
!= bfd_link_hash_undefined
1098 && h
->type
!= bfd_link_hash_common
)
1101 element
= bfd_get_elt_at_index (abfd
, l
->indx
);
1102 if (element
== NULL
)
1105 /* If we've already included this element, or if we've
1106 already checked it on this pass, continue. */
1107 if (element
->archive_pass
== -1
1108 || element
->archive_pass
== pass
)
1111 /* If we can't figure this element out, just ignore it. */
1112 if (! bfd_check_format (element
, bfd_object
))
1114 element
->archive_pass
= -1;
1118 /* CHECKFN will see if this element should be included, and
1119 go ahead and include it if appropriate. */
1120 if (! (*checkfn
) (element
, info
, &needed
))
1124 element
->archive_pass
= pass
;
1127 element
->archive_pass
= -1;
1129 /* Increment the pass count to show that we may need to
1130 recheck object files which were already checked. */
1135 pundef
= &(*pundef
)->u
.undef
.next
;
1138 archive_hash_table_free (&arsym_hash
);
1140 /* Save PASS in case we are called again. */
1141 abfd
->archive_pass
= pass
;
1146 archive_hash_table_free (&arsym_hash
);
1150 /* See if we should include an archive element. This version is used
1151 when we do not want to automatically collect constructors based on
1152 the symbol name, presumably because we have some other mechanism
1153 for finding them. */
1156 generic_link_check_archive_element_no_collect (
1158 struct bfd_link_info
*info
,
1159 bfd_boolean
*pneeded
)
1161 return generic_link_check_archive_element (abfd
, info
, pneeded
, FALSE
);
1164 /* See if we should include an archive element. This version is used
1165 when we want to automatically collect constructors based on the
1166 symbol name, as collect2 does. */
1169 generic_link_check_archive_element_collect (bfd
*abfd
,
1170 struct bfd_link_info
*info
,
1171 bfd_boolean
*pneeded
)
1173 return generic_link_check_archive_element (abfd
, info
, pneeded
, TRUE
);
1176 /* See if we should include an archive element. Optionally collect
1180 generic_link_check_archive_element (bfd
*abfd
,
1181 struct bfd_link_info
*info
,
1182 bfd_boolean
*pneeded
,
1183 bfd_boolean collect
)
1185 asymbol
**pp
, **ppend
;
1189 if (!bfd_generic_link_read_symbols (abfd
))
1192 pp
= _bfd_generic_link_get_symbols (abfd
);
1193 ppend
= pp
+ _bfd_generic_link_get_symcount (abfd
);
1194 for (; pp
< ppend
; pp
++)
1197 struct bfd_link_hash_entry
*h
;
1201 /* We are only interested in globally visible symbols. */
1202 if (! bfd_is_com_section (p
->section
)
1203 && (p
->flags
& (BSF_GLOBAL
| BSF_INDIRECT
| BSF_WEAK
)) == 0)
1206 /* We are only interested if we know something about this
1207 symbol, and it is undefined or common. An undefined weak
1208 symbol (type bfd_link_hash_undefweak) is not considered to be
1209 a reference when pulling files out of an archive. See the
1210 SVR4 ABI, p. 4-27. */
1211 h
= bfd_link_hash_lookup (info
->hash
, bfd_asymbol_name (p
), FALSE
,
1214 || (h
->type
!= bfd_link_hash_undefined
1215 && h
->type
!= bfd_link_hash_common
))
1218 /* P is a symbol we are looking for. */
1220 if (! bfd_is_com_section (p
->section
))
1222 bfd_size_type symcount
;
1226 /* This object file defines this symbol, so pull it in. */
1227 if (!(*info
->callbacks
1228 ->add_archive_element
) (info
, abfd
, bfd_asymbol_name (p
),
1231 /* Potentially, the add_archive_element hook may have set a
1232 substitute BFD for us. */
1234 && !bfd_generic_link_read_symbols (abfd
))
1236 symcount
= _bfd_generic_link_get_symcount (abfd
);
1237 symbols
= _bfd_generic_link_get_symbols (abfd
);
1238 if (! generic_link_add_symbol_list (abfd
, info
, symcount
,
1245 /* P is a common symbol. */
1247 if (h
->type
== bfd_link_hash_undefined
)
1253 symbfd
= h
->u
.undef
.abfd
;
1256 /* This symbol was created as undefined from outside
1257 BFD. We assume that we should link in the object
1258 file. This is for the -u option in the linker. */
1259 if (!(*info
->callbacks
1260 ->add_archive_element
) (info
, abfd
, bfd_asymbol_name (p
),
1263 /* Potentially, the add_archive_element hook may have set a
1264 substitute BFD for us. But no symbols are going to get
1265 registered by anything we're returning to from here. */
1270 /* Turn the symbol into a common symbol but do not link in
1271 the object file. This is how a.out works. Object
1272 formats that require different semantics must implement
1273 this function differently. This symbol is already on the
1274 undefs list. We add the section to a common section
1275 attached to symbfd to ensure that it is in a BFD which
1276 will be linked in. */
1277 h
->type
= bfd_link_hash_common
;
1278 h
->u
.c
.p
= (struct bfd_link_hash_common_entry
*)
1279 bfd_hash_allocate (&info
->hash
->table
,
1280 sizeof (struct bfd_link_hash_common_entry
));
1281 if (h
->u
.c
.p
== NULL
)
1284 size
= bfd_asymbol_value (p
);
1287 power
= bfd_log2 (size
);
1290 h
->u
.c
.p
->alignment_power
= power
;
1292 if (p
->section
== bfd_com_section_ptr
)
1293 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
, "COMMON");
1295 h
->u
.c
.p
->section
= bfd_make_section_old_way (symbfd
,
1297 h
->u
.c
.p
->section
->flags
|= SEC_ALLOC
;
1301 /* Adjust the size of the common symbol if necessary. This
1302 is how a.out works. Object formats that require
1303 different semantics must implement this function
1305 if (bfd_asymbol_value (p
) > h
->u
.c
.size
)
1306 h
->u
.c
.size
= bfd_asymbol_value (p
);
1310 /* This archive element is not needed. */
1314 /* Add the symbols from an object file to the global hash table. ABFD
1315 is the object file. INFO is the linker information. SYMBOL_COUNT
1316 is the number of symbols. SYMBOLS is the list of symbols. COLLECT
1317 is TRUE if constructors should be automatically collected by name
1318 as is done by collect2. */
1321 generic_link_add_symbol_list (bfd
*abfd
,
1322 struct bfd_link_info
*info
,
1323 bfd_size_type symbol_count
,
1325 bfd_boolean collect
)
1327 asymbol
**pp
, **ppend
;
1330 ppend
= symbols
+ symbol_count
;
1331 for (; pp
< ppend
; pp
++)
1337 if ((p
->flags
& (BSF_INDIRECT
1342 || bfd_is_und_section (bfd_get_section (p
))
1343 || bfd_is_com_section (bfd_get_section (p
))
1344 || bfd_is_ind_section (bfd_get_section (p
)))
1348 struct generic_link_hash_entry
*h
;
1349 struct bfd_link_hash_entry
*bh
;
1351 string
= name
= bfd_asymbol_name (p
);
1352 if (((p
->flags
& BSF_INDIRECT
) != 0
1353 || bfd_is_ind_section (p
->section
))
1357 string
= bfd_asymbol_name (*pp
);
1359 else if ((p
->flags
& BSF_WARNING
) != 0
1362 /* The name of P is actually the warning string, and the
1363 next symbol is the one to warn about. */
1365 name
= bfd_asymbol_name (*pp
);
1369 if (! (_bfd_generic_link_add_one_symbol
1370 (info
, abfd
, name
, p
->flags
, bfd_get_section (p
),
1371 p
->value
, string
, FALSE
, collect
, &bh
)))
1373 h
= (struct generic_link_hash_entry
*) bh
;
1375 /* If this is a constructor symbol, and the linker didn't do
1376 anything with it, then we want to just pass the symbol
1377 through to the output file. This will happen when
1379 if ((p
->flags
& BSF_CONSTRUCTOR
) != 0
1380 && (h
== NULL
|| h
->root
.type
== bfd_link_hash_new
))
1386 /* Save the BFD symbol so that we don't lose any backend
1387 specific information that may be attached to it. We only
1388 want this one if it gives more information than the
1389 existing one; we don't want to replace a defined symbol
1390 with an undefined one. This routine may be called with a
1391 hash table other than the generic hash table, so we only
1392 do this if we are certain that the hash table is a
1394 if (info
->output_bfd
->xvec
== abfd
->xvec
)
1397 || (! bfd_is_und_section (bfd_get_section (p
))
1398 && (! bfd_is_com_section (bfd_get_section (p
))
1399 || bfd_is_und_section (bfd_get_section (h
->sym
)))))
1402 /* BSF_OLD_COMMON is a hack to support COFF reloc
1403 reading, and it should go away when the COFF
1404 linker is switched to the new version. */
1405 if (bfd_is_com_section (bfd_get_section (p
)))
1406 p
->flags
|= BSF_OLD_COMMON
;
1410 /* Store a back pointer from the symbol to the hash
1411 table entry for the benefit of relaxation code until
1412 it gets rewritten to not use asymbol structures.
1413 Setting this is also used to check whether these
1414 symbols were set up by the generic linker. */
1422 /* We use a state table to deal with adding symbols from an object
1423 file. The first index into the state table describes the symbol
1424 from the object file. The second index into the state table is the
1425 type of the symbol in the hash table. */
1427 /* The symbol from the object file is turned into one of these row
1432 UNDEF_ROW
, /* Undefined. */
1433 UNDEFW_ROW
, /* Weak undefined. */
1434 DEF_ROW
, /* Defined. */
1435 DEFW_ROW
, /* Weak defined. */
1436 COMMON_ROW
, /* Common. */
1437 INDR_ROW
, /* Indirect. */
1438 WARN_ROW
, /* Warning. */
1439 SET_ROW
/* Member of set. */
1442 /* apparently needed for Hitachi 3050R(HI-UX/WE2)? */
1445 /* The actions to take in the state table. */
1450 UND
, /* Mark symbol undefined. */
1451 WEAK
, /* Mark symbol weak undefined. */
1452 DEF
, /* Mark symbol defined. */
1453 DEFW
, /* Mark symbol weak defined. */
1454 COM
, /* Mark symbol common. */
1455 REF
, /* Mark defined symbol referenced. */
1456 CREF
, /* Possibly warn about common reference to defined symbol. */
1457 CDEF
, /* Define existing common symbol. */
1458 NOACT
, /* No action. */
1459 BIG
, /* Mark symbol common using largest size. */
1460 MDEF
, /* Multiple definition error. */
1461 MIND
, /* Multiple indirect symbols. */
1462 IND
, /* Make indirect symbol. */
1463 CIND
, /* Make indirect symbol from existing common symbol. */
1464 SET
, /* Add value to set. */
1465 MWARN
, /* Make warning symbol. */
1466 WARN
, /* Issue warning. */
1467 CWARN
, /* Warn if referenced, else MWARN. */
1468 CYCLE
, /* Repeat with symbol pointed to. */
1469 REFC
, /* Mark indirect symbol referenced and then CYCLE. */
1470 WARNC
/* Issue warning and then CYCLE. */
1473 /* The state table itself. The first index is a link_row and the
1474 second index is a bfd_link_hash_type. */
1476 static const enum link_action link_action
[8][8] =
1478 /* current\prev new undef undefw def defw com indr warn */
1479 /* UNDEF_ROW */ {UND
, NOACT
, UND
, REF
, REF
, NOACT
, REFC
, WARNC
},
1480 /* UNDEFW_ROW */ {WEAK
, NOACT
, NOACT
, REF
, REF
, NOACT
, REFC
, WARNC
},
1481 /* DEF_ROW */ {DEF
, DEF
, DEF
, MDEF
, DEF
, CDEF
, MDEF
, CYCLE
},
1482 /* DEFW_ROW */ {DEFW
, DEFW
, DEFW
, NOACT
, NOACT
, NOACT
, NOACT
, CYCLE
},
1483 /* COMMON_ROW */ {COM
, COM
, COM
, CREF
, COM
, BIG
, REFC
, WARNC
},
1484 /* INDR_ROW */ {IND
, IND
, IND
, MDEF
, IND
, CIND
, MIND
, CYCLE
},
1485 /* WARN_ROW */ {MWARN
, WARN
, WARN
, CWARN
, CWARN
, WARN
, CWARN
, NOACT
},
1486 /* SET_ROW */ {SET
, SET
, SET
, SET
, SET
, SET
, CYCLE
, CYCLE
}
1489 /* Most of the entries in the LINK_ACTION table are straightforward,
1490 but a few are somewhat subtle.
1492 A reference to an indirect symbol (UNDEF_ROW/indr or
1493 UNDEFW_ROW/indr) is counted as a reference both to the indirect
1494 symbol and to the symbol the indirect symbol points to.
1496 A reference to a warning symbol (UNDEF_ROW/warn or UNDEFW_ROW/warn)
1497 causes the warning to be issued.
1499 A common definition of an indirect symbol (COMMON_ROW/indr) is
1500 treated as a multiple definition error. Likewise for an indirect
1501 definition of a common symbol (INDR_ROW/com).
1503 An indirect definition of a warning (INDR_ROW/warn) does not cause
1504 the warning to be issued.
1506 If a warning is created for an indirect symbol (WARN_ROW/indr) no
1507 warning is created for the symbol the indirect symbol points to.
1509 Adding an entry to a set does not count as a reference to a set,
1510 and no warning is issued (SET_ROW/warn). */
1512 /* Return the BFD in which a hash entry has been defined, if known. */
1515 hash_entry_bfd (struct bfd_link_hash_entry
*h
)
1517 while (h
->type
== bfd_link_hash_warning
)
1523 case bfd_link_hash_undefined
:
1524 case bfd_link_hash_undefweak
:
1525 return h
->u
.undef
.abfd
;
1526 case bfd_link_hash_defined
:
1527 case bfd_link_hash_defweak
:
1528 return h
->u
.def
.section
->owner
;
1529 case bfd_link_hash_common
:
1530 return h
->u
.c
.p
->section
->owner
;
1535 /* Add a symbol to the global hash table.
1536 ABFD is the BFD the symbol comes from.
1537 NAME is the name of the symbol.
1538 FLAGS is the BSF_* bits associated with the symbol.
1539 SECTION is the section in which the symbol is defined; this may be
1540 bfd_und_section_ptr or bfd_com_section_ptr.
1541 VALUE is the value of the symbol, relative to the section.
1542 STRING is used for either an indirect symbol, in which case it is
1543 the name of the symbol to indirect to, or a warning symbol, in
1544 which case it is the warning string.
1545 COPY is TRUE if NAME or STRING must be copied into locally
1546 allocated memory if they need to be saved.
1547 COLLECT is TRUE if we should automatically collect gcc constructor
1548 or destructor names as collect2 does.
1549 HASHP, if not NULL, is a place to store the created hash table
1550 entry; if *HASHP is not NULL, the caller has already looked up
1551 the hash table entry, and stored it in *HASHP. */
1554 _bfd_generic_link_add_one_symbol (struct bfd_link_info
*info
,
1562 bfd_boolean collect
,
1563 struct bfd_link_hash_entry
**hashp
)
1566 struct bfd_link_hash_entry
*h
;
1569 if (bfd_is_ind_section (section
)
1570 || (flags
& BSF_INDIRECT
) != 0)
1572 else if ((flags
& BSF_WARNING
) != 0)
1574 else if ((flags
& BSF_CONSTRUCTOR
) != 0)
1576 else if (bfd_is_und_section (section
))
1578 if ((flags
& BSF_WEAK
) != 0)
1583 else if ((flags
& BSF_WEAK
) != 0)
1585 else if (bfd_is_com_section (section
))
1590 if (hashp
!= NULL
&& *hashp
!= NULL
)
1594 if (row
== UNDEF_ROW
|| row
== UNDEFW_ROW
)
1595 h
= bfd_wrapped_link_hash_lookup (abfd
, info
, name
, TRUE
, copy
, FALSE
);
1597 h
= bfd_link_hash_lookup (info
->hash
, name
, TRUE
, copy
, FALSE
);
1606 if (info
->notice_all
1607 || (info
->notice_hash
!= NULL
1608 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1610 if (! (*info
->callbacks
->notice
) (info
, h
, abfd
, section
, value
))
1619 enum link_action action
;
1622 action
= link_action
[(int) row
][(int) h
->type
];
1633 /* Make a new undefined symbol. */
1634 h
->type
= bfd_link_hash_undefined
;
1635 h
->u
.undef
.abfd
= abfd
;
1636 bfd_link_add_undef (info
->hash
, h
);
1640 /* Make a new weak undefined symbol. */
1641 h
->type
= bfd_link_hash_undefweak
;
1642 h
->u
.undef
.abfd
= abfd
;
1646 /* We have found a definition for a symbol which was
1647 previously common. */
1648 BFD_ASSERT (h
->type
== bfd_link_hash_common
);
1649 if (! ((*info
->callbacks
->multiple_common
)
1650 (info
, h
, abfd
, bfd_link_hash_defined
, 0)))
1656 enum bfd_link_hash_type oldtype
;
1658 /* Define a symbol. */
1661 h
->type
= bfd_link_hash_defweak
;
1663 h
->type
= bfd_link_hash_defined
;
1664 h
->u
.def
.section
= section
;
1665 h
->u
.def
.value
= value
;
1667 /* If we have been asked to, we act like collect2 and
1668 identify all functions that might be global
1669 constructors and destructors and pass them up in a
1670 callback. We only do this for certain object file
1671 types, since many object file types can handle this
1673 if (collect
&& name
[0] == '_')
1677 /* A constructor or destructor name starts like this:
1678 _+GLOBAL_[_.$][ID][_.$] where the first [_.$] and
1679 the second are the same character (we accept any
1680 character there, in case a new object file format
1681 comes along with even worse naming restrictions). */
1683 #define CONS_PREFIX "GLOBAL_"
1684 #define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
1689 if (s
[0] == 'G' && CONST_STRNEQ (s
, CONS_PREFIX
))
1693 c
= s
[CONS_PREFIX_LEN
+ 1];
1694 if ((c
== 'I' || c
== 'D')
1695 && s
[CONS_PREFIX_LEN
] == s
[CONS_PREFIX_LEN
+ 2])
1697 /* If this is a definition of a symbol which
1698 was previously weakly defined, we are in
1699 trouble. We have already added a
1700 constructor entry for the weak defined
1701 symbol, and now we are trying to add one
1702 for the new symbol. Fortunately, this case
1703 should never arise in practice. */
1704 if (oldtype
== bfd_link_hash_defweak
)
1707 if (! ((*info
->callbacks
->constructor
)
1709 h
->root
.string
, abfd
, section
, value
)))
1719 /* We have found a common definition for a symbol. */
1720 if (h
->type
== bfd_link_hash_new
)
1721 bfd_link_add_undef (info
->hash
, h
);
1722 h
->type
= bfd_link_hash_common
;
1723 h
->u
.c
.p
= (struct bfd_link_hash_common_entry
*)
1724 bfd_hash_allocate (&info
->hash
->table
,
1725 sizeof (struct bfd_link_hash_common_entry
));
1726 if (h
->u
.c
.p
== NULL
)
1729 h
->u
.c
.size
= value
;
1731 /* Select a default alignment based on the size. This may
1732 be overridden by the caller. */
1736 power
= bfd_log2 (value
);
1739 h
->u
.c
.p
->alignment_power
= power
;
1742 /* The section of a common symbol is only used if the common
1743 symbol is actually allocated. It basically provides a
1744 hook for the linker script to decide which output section
1745 the common symbols should be put in. In most cases, the
1746 section of a common symbol will be bfd_com_section_ptr,
1747 the code here will choose a common symbol section named
1748 "COMMON", and the linker script will contain *(COMMON) in
1749 the appropriate place. A few targets use separate common
1750 sections for small symbols, and they require special
1752 if (section
== bfd_com_section_ptr
)
1754 h
->u
.c
.p
->section
= bfd_make_section_old_way (abfd
, "COMMON");
1755 h
->u
.c
.p
->section
->flags
|= SEC_ALLOC
;
1757 else if (section
->owner
!= abfd
)
1759 h
->u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
1761 h
->u
.c
.p
->section
->flags
|= SEC_ALLOC
;
1764 h
->u
.c
.p
->section
= section
;
1768 /* A reference to a defined symbol. */
1769 if (h
->u
.undef
.next
== NULL
&& info
->hash
->undefs_tail
!= h
)
1770 h
->u
.undef
.next
= h
;
1774 /* We have found a common definition for a symbol which
1775 already had a common definition. Use the maximum of the
1776 two sizes, and use the section required by the larger symbol. */
1777 BFD_ASSERT (h
->type
== bfd_link_hash_common
);
1778 if (! ((*info
->callbacks
->multiple_common
)
1779 (info
, h
, abfd
, bfd_link_hash_common
, value
)))
1781 if (value
> h
->u
.c
.size
)
1785 h
->u
.c
.size
= value
;
1787 /* Select a default alignment based on the size. This may
1788 be overridden by the caller. */
1789 power
= bfd_log2 (value
);
1792 h
->u
.c
.p
->alignment_power
= power
;
1794 /* Some systems have special treatment for small commons,
1795 hence we want to select the section used by the larger
1796 symbol. This makes sure the symbol does not go in a
1797 small common section if it is now too large. */
1798 if (section
== bfd_com_section_ptr
)
1801 = bfd_make_section_old_way (abfd
, "COMMON");
1802 h
->u
.c
.p
->section
->flags
|= SEC_ALLOC
;
1804 else if (section
->owner
!= abfd
)
1807 = bfd_make_section_old_way (abfd
, section
->name
);
1808 h
->u
.c
.p
->section
->flags
|= SEC_ALLOC
;
1811 h
->u
.c
.p
->section
= section
;
1816 /* We have found a common definition for a symbol which
1817 was already defined. */
1818 if (! ((*info
->callbacks
->multiple_common
)
1819 (info
, h
, abfd
, bfd_link_hash_common
, value
)))
1824 /* Multiple indirect symbols. This is OK if they both point
1825 to the same symbol. */
1826 if (strcmp (h
->u
.i
.link
->root
.string
, string
) == 0)
1830 /* Handle a multiple definition. */
1831 if (! ((*info
->callbacks
->multiple_definition
)
1832 (info
, h
, abfd
, section
, value
)))
1837 /* Create an indirect symbol from an existing common symbol. */
1838 BFD_ASSERT (h
->type
== bfd_link_hash_common
);
1839 if (! ((*info
->callbacks
->multiple_common
)
1840 (info
, h
, abfd
, bfd_link_hash_indirect
, 0)))
1844 /* Create an indirect symbol. */
1846 struct bfd_link_hash_entry
*inh
;
1848 /* STRING is the name of the symbol we want to indirect
1850 inh
= bfd_wrapped_link_hash_lookup (abfd
, info
, string
, TRUE
,
1854 if (inh
->type
== bfd_link_hash_indirect
1855 && inh
->u
.i
.link
== h
)
1857 (*_bfd_error_handler
)
1858 (_("%B: indirect symbol `%s' to `%s' is a loop"),
1859 abfd
, name
, string
);
1860 bfd_set_error (bfd_error_invalid_operation
);
1863 if (inh
->type
== bfd_link_hash_new
)
1865 inh
->type
= bfd_link_hash_undefined
;
1866 inh
->u
.undef
.abfd
= abfd
;
1867 bfd_link_add_undef (info
->hash
, inh
);
1870 /* If the indirect symbol has been referenced, we need to
1871 push the reference down to the symbol we are
1873 if (h
->type
!= bfd_link_hash_new
)
1879 h
->type
= bfd_link_hash_indirect
;
1885 /* Add an entry to a set. */
1886 if (! (*info
->callbacks
->add_to_set
) (info
, h
, BFD_RELOC_CTOR
,
1887 abfd
, section
, value
))
1892 /* Issue a warning and cycle. */
1893 if (h
->u
.i
.warning
!= NULL
)
1895 if (! (*info
->callbacks
->warning
) (info
, h
->u
.i
.warning
,
1896 h
->root
.string
, abfd
,
1899 /* Only issue a warning once. */
1900 h
->u
.i
.warning
= NULL
;
1904 /* Try again with the referenced symbol. */
1910 /* A reference to an indirect symbol. */
1911 if (h
->u
.undef
.next
== NULL
&& info
->hash
->undefs_tail
!= h
)
1912 h
->u
.undef
.next
= h
;
1918 /* Issue a warning. */
1919 if (! (*info
->callbacks
->warning
) (info
, string
, h
->root
.string
,
1920 hash_entry_bfd (h
), NULL
, 0))
1925 /* Warn if this symbol has been referenced already,
1926 otherwise add a warning. A symbol has been referenced if
1927 the u.undef.next field is not NULL, or it is the tail of the
1928 undefined symbol list. The REF case above helps to
1930 if (h
->u
.undef
.next
!= NULL
|| info
->hash
->undefs_tail
== h
)
1932 if (! (*info
->callbacks
->warning
) (info
, string
, h
->root
.string
,
1933 hash_entry_bfd (h
), NULL
, 0))
1939 /* Make a warning symbol. */
1941 struct bfd_link_hash_entry
*sub
;
1943 /* STRING is the warning to give. */
1944 sub
= ((struct bfd_link_hash_entry
*)
1945 ((*info
->hash
->table
.newfunc
)
1946 (NULL
, &info
->hash
->table
, h
->root
.string
)));
1950 sub
->type
= bfd_link_hash_warning
;
1953 sub
->u
.i
.warning
= string
;
1957 size_t len
= strlen (string
) + 1;
1959 w
= (char *) bfd_hash_allocate (&info
->hash
->table
, len
);
1962 memcpy (w
, string
, len
);
1963 sub
->u
.i
.warning
= w
;
1966 bfd_hash_replace (&info
->hash
->table
,
1967 (struct bfd_hash_entry
*) h
,
1968 (struct bfd_hash_entry
*) sub
);
1980 /* Generic final link routine. */
1983 _bfd_generic_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
1987 struct bfd_link_order
*p
;
1989 struct generic_write_global_symbol_info wginfo
;
1991 bfd_get_outsymbols (abfd
) = NULL
;
1992 bfd_get_symcount (abfd
) = 0;
1995 /* Mark all sections which will be included in the output file. */
1996 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1997 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
1998 if (p
->type
== bfd_indirect_link_order
)
1999 p
->u
.indirect
.section
->linker_mark
= TRUE
;
2001 /* Build the output symbol table. */
2002 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
2003 if (! _bfd_generic_link_output_symbols (abfd
, sub
, info
, &outsymalloc
))
2006 /* Accumulate the global symbols. */
2008 wginfo
.output_bfd
= abfd
;
2009 wginfo
.psymalloc
= &outsymalloc
;
2010 _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info
),
2011 _bfd_generic_link_write_global_symbol
,
2014 /* Make sure we have a trailing NULL pointer on OUTSYMBOLS. We
2015 shouldn't really need one, since we have SYMCOUNT, but some old
2016 code still expects one. */
2017 if (! generic_add_output_symbol (abfd
, &outsymalloc
, NULL
))
2020 if (info
->relocatable
)
2022 /* Allocate space for the output relocs for each section. */
2023 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2026 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
2028 if (p
->type
== bfd_section_reloc_link_order
2029 || p
->type
== bfd_symbol_reloc_link_order
)
2031 else if (p
->type
== bfd_indirect_link_order
)
2033 asection
*input_section
;
2040 input_section
= p
->u
.indirect
.section
;
2041 input_bfd
= input_section
->owner
;
2042 relsize
= bfd_get_reloc_upper_bound (input_bfd
,
2046 relocs
= (arelent
**) bfd_malloc (relsize
);
2047 if (!relocs
&& relsize
!= 0)
2049 symbols
= _bfd_generic_link_get_symbols (input_bfd
);
2050 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
2055 if (reloc_count
< 0)
2057 BFD_ASSERT ((unsigned long) reloc_count
2058 == input_section
->reloc_count
);
2059 o
->reloc_count
+= reloc_count
;
2062 if (o
->reloc_count
> 0)
2066 amt
= o
->reloc_count
;
2067 amt
*= sizeof (arelent
*);
2068 o
->orelocation
= (struct reloc_cache_entry
**) bfd_alloc (abfd
, amt
);
2069 if (!o
->orelocation
)
2071 o
->flags
|= SEC_RELOC
;
2072 /* Reset the count so that it can be used as an index
2073 when putting in the output relocs. */
2079 /* Handle all the link order information for the sections. */
2080 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
2082 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
2086 case bfd_section_reloc_link_order
:
2087 case bfd_symbol_reloc_link_order
:
2088 if (! _bfd_generic_reloc_link_order (abfd
, info
, o
, p
))
2091 case bfd_indirect_link_order
:
2092 if (! default_indirect_link_order (abfd
, info
, o
, p
, TRUE
))
2096 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
2106 /* Add an output symbol to the output BFD. */
2109 generic_add_output_symbol (bfd
*output_bfd
, size_t *psymalloc
, asymbol
*sym
)
2111 if (bfd_get_symcount (output_bfd
) >= *psymalloc
)
2116 if (*psymalloc
== 0)
2121 amt
*= sizeof (asymbol
*);
2122 newsyms
= (asymbol
**) bfd_realloc (bfd_get_outsymbols (output_bfd
), amt
);
2123 if (newsyms
== NULL
)
2125 bfd_get_outsymbols (output_bfd
) = newsyms
;
2128 bfd_get_outsymbols (output_bfd
) [bfd_get_symcount (output_bfd
)] = sym
;
2130 ++ bfd_get_symcount (output_bfd
);
2135 /* Handle the symbols for an input BFD. */
2138 _bfd_generic_link_output_symbols (bfd
*output_bfd
,
2140 struct bfd_link_info
*info
,
2146 if (!bfd_generic_link_read_symbols (input_bfd
))
2149 /* Create a filename symbol if we are supposed to. */
2150 if (info
->create_object_symbols_section
!= NULL
)
2154 for (sec
= input_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2156 if (sec
->output_section
== info
->create_object_symbols_section
)
2160 newsym
= bfd_make_empty_symbol (input_bfd
);
2163 newsym
->name
= input_bfd
->filename
;
2165 newsym
->flags
= BSF_LOCAL
| BSF_FILE
;
2166 newsym
->section
= sec
;
2168 if (! generic_add_output_symbol (output_bfd
, psymalloc
,
2177 /* Adjust the values of the globally visible symbols, and write out
2179 sym_ptr
= _bfd_generic_link_get_symbols (input_bfd
);
2180 sym_end
= sym_ptr
+ _bfd_generic_link_get_symcount (input_bfd
);
2181 for (; sym_ptr
< sym_end
; sym_ptr
++)
2184 struct generic_link_hash_entry
*h
;
2189 if ((sym
->flags
& (BSF_INDIRECT
2194 || bfd_is_und_section (bfd_get_section (sym
))
2195 || bfd_is_com_section (bfd_get_section (sym
))
2196 || bfd_is_ind_section (bfd_get_section (sym
)))
2198 if (sym
->udata
.p
!= NULL
)
2199 h
= (struct generic_link_hash_entry
*) sym
->udata
.p
;
2200 else if ((sym
->flags
& BSF_CONSTRUCTOR
) != 0)
2202 /* This case normally means that the main linker code
2203 deliberately ignored this constructor symbol. We
2204 should just pass it through. This will screw up if
2205 the constructor symbol is from a different,
2206 non-generic, object file format, but the case will
2207 only arise when linking with -r, which will probably
2208 fail anyhow, since there will be no way to represent
2209 the relocs in the output format being used. */
2212 else if (bfd_is_und_section (bfd_get_section (sym
)))
2213 h
= ((struct generic_link_hash_entry
*)
2214 bfd_wrapped_link_hash_lookup (output_bfd
, info
,
2215 bfd_asymbol_name (sym
),
2216 FALSE
, FALSE
, TRUE
));
2218 h
= _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info
),
2219 bfd_asymbol_name (sym
),
2220 FALSE
, FALSE
, TRUE
);
2224 /* Force all references to this symbol to point to
2225 the same area in memory. It is possible that
2226 this routine will be called with a hash table
2227 other than a generic hash table, so we double
2229 if (info
->output_bfd
->xvec
== input_bfd
->xvec
)
2232 *sym_ptr
= sym
= h
->sym
;
2235 switch (h
->root
.type
)
2238 case bfd_link_hash_new
:
2240 case bfd_link_hash_undefined
:
2242 case bfd_link_hash_undefweak
:
2243 sym
->flags
|= BSF_WEAK
;
2245 case bfd_link_hash_indirect
:
2246 h
= (struct generic_link_hash_entry
*) h
->root
.u
.i
.link
;
2248 case bfd_link_hash_defined
:
2249 sym
->flags
|= BSF_GLOBAL
;
2250 sym
->flags
&=~ BSF_CONSTRUCTOR
;
2251 sym
->value
= h
->root
.u
.def
.value
;
2252 sym
->section
= h
->root
.u
.def
.section
;
2254 case bfd_link_hash_defweak
:
2255 sym
->flags
|= BSF_WEAK
;
2256 sym
->flags
&=~ BSF_CONSTRUCTOR
;
2257 sym
->value
= h
->root
.u
.def
.value
;
2258 sym
->section
= h
->root
.u
.def
.section
;
2260 case bfd_link_hash_common
:
2261 sym
->value
= h
->root
.u
.c
.size
;
2262 sym
->flags
|= BSF_GLOBAL
;
2263 if (! bfd_is_com_section (sym
->section
))
2265 BFD_ASSERT (bfd_is_und_section (sym
->section
));
2266 sym
->section
= bfd_com_section_ptr
;
2268 /* We do not set the section of the symbol to
2269 h->root.u.c.p->section. That value was saved so
2270 that we would know where to allocate the symbol
2271 if it was defined. In this case the type is
2272 still bfd_link_hash_common, so we did not define
2273 it, so we do not want to use that section. */
2279 /* This switch is straight from the old code in
2280 write_file_locals in ldsym.c. */
2281 if (info
->strip
== strip_all
2282 || (info
->strip
== strip_some
2283 && bfd_hash_lookup (info
->keep_hash
, bfd_asymbol_name (sym
),
2284 FALSE
, FALSE
) == NULL
))
2286 else if ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0)
2288 /* If this symbol is marked as occurring now, rather
2289 than at the end, output it now. This is used for
2290 COFF C_EXT FCN symbols. FIXME: There must be a
2292 if (bfd_asymbol_bfd (sym
) == input_bfd
2293 && (sym
->flags
& BSF_NOT_AT_END
) != 0)
2298 else if (bfd_is_ind_section (sym
->section
))
2300 else if ((sym
->flags
& BSF_DEBUGGING
) != 0)
2302 if (info
->strip
== strip_none
)
2307 else if (bfd_is_und_section (sym
->section
)
2308 || bfd_is_com_section (sym
->section
))
2310 else if ((sym
->flags
& BSF_LOCAL
) != 0)
2312 if ((sym
->flags
& BSF_WARNING
) != 0)
2316 switch (info
->discard
)
2322 case discard_sec_merge
:
2324 if (info
->relocatable
2325 || ! (sym
->section
->flags
& SEC_MERGE
))
2329 if (bfd_is_local_label (input_bfd
, sym
))
2340 else if ((sym
->flags
& BSF_CONSTRUCTOR
))
2342 if (info
->strip
!= strip_all
)
2350 /* If this symbol is in a section which is not being included
2351 in the output file, then we don't want to output the
2353 if (!bfd_is_abs_section (sym
->section
)
2354 && bfd_section_removed_from_list (output_bfd
,
2355 sym
->section
->output_section
))
2360 if (! generic_add_output_symbol (output_bfd
, psymalloc
, sym
))
2370 /* Set the section and value of a generic BFD symbol based on a linker
2371 hash table entry. */
2374 set_symbol_from_hash (asymbol
*sym
, struct bfd_link_hash_entry
*h
)
2381 case bfd_link_hash_new
:
2382 /* This can happen when a constructor symbol is seen but we are
2383 not building constructors. */
2384 if (sym
->section
!= NULL
)
2386 BFD_ASSERT ((sym
->flags
& BSF_CONSTRUCTOR
) != 0);
2390 sym
->flags
|= BSF_CONSTRUCTOR
;
2391 sym
->section
= bfd_abs_section_ptr
;
2395 case bfd_link_hash_undefined
:
2396 sym
->section
= bfd_und_section_ptr
;
2399 case bfd_link_hash_undefweak
:
2400 sym
->section
= bfd_und_section_ptr
;
2402 sym
->flags
|= BSF_WEAK
;
2404 case bfd_link_hash_defined
:
2405 sym
->section
= h
->u
.def
.section
;
2406 sym
->value
= h
->u
.def
.value
;
2408 case bfd_link_hash_defweak
:
2409 sym
->flags
|= BSF_WEAK
;
2410 sym
->section
= h
->u
.def
.section
;
2411 sym
->value
= h
->u
.def
.value
;
2413 case bfd_link_hash_common
:
2414 sym
->value
= h
->u
.c
.size
;
2415 if (sym
->section
== NULL
)
2416 sym
->section
= bfd_com_section_ptr
;
2417 else if (! bfd_is_com_section (sym
->section
))
2419 BFD_ASSERT (bfd_is_und_section (sym
->section
));
2420 sym
->section
= bfd_com_section_ptr
;
2422 /* Do not set the section; see _bfd_generic_link_output_symbols. */
2424 case bfd_link_hash_indirect
:
2425 case bfd_link_hash_warning
:
2426 /* FIXME: What should we do here? */
2431 /* Write out a global symbol, if it hasn't already been written out.
2432 This is called for each symbol in the hash table. */
2435 _bfd_generic_link_write_global_symbol (struct generic_link_hash_entry
*h
,
2438 struct generic_write_global_symbol_info
*wginfo
=
2439 (struct generic_write_global_symbol_info
*) data
;
2442 if (h
->root
.type
== bfd_link_hash_warning
)
2443 h
= (struct generic_link_hash_entry
*) h
->root
.u
.i
.link
;
2450 if (wginfo
->info
->strip
== strip_all
2451 || (wginfo
->info
->strip
== strip_some
2452 && bfd_hash_lookup (wginfo
->info
->keep_hash
, h
->root
.root
.string
,
2453 FALSE
, FALSE
) == NULL
))
2460 sym
= bfd_make_empty_symbol (wginfo
->output_bfd
);
2463 sym
->name
= h
->root
.root
.string
;
2467 set_symbol_from_hash (sym
, &h
->root
);
2469 sym
->flags
|= BSF_GLOBAL
;
2471 if (! generic_add_output_symbol (wginfo
->output_bfd
, wginfo
->psymalloc
,
2474 /* FIXME: No way to return failure. */
2481 /* Create a relocation. */
2484 _bfd_generic_reloc_link_order (bfd
*abfd
,
2485 struct bfd_link_info
*info
,
2487 struct bfd_link_order
*link_order
)
2491 if (! info
->relocatable
)
2493 if (sec
->orelocation
== NULL
)
2496 r
= (arelent
*) bfd_alloc (abfd
, sizeof (arelent
));
2500 r
->address
= link_order
->offset
;
2501 r
->howto
= bfd_reloc_type_lookup (abfd
, link_order
->u
.reloc
.p
->reloc
);
2504 bfd_set_error (bfd_error_bad_value
);
2508 /* Get the symbol to use for the relocation. */
2509 if (link_order
->type
== bfd_section_reloc_link_order
)
2510 r
->sym_ptr_ptr
= link_order
->u
.reloc
.p
->u
.section
->symbol_ptr_ptr
;
2513 struct generic_link_hash_entry
*h
;
2515 h
= ((struct generic_link_hash_entry
*)
2516 bfd_wrapped_link_hash_lookup (abfd
, info
,
2517 link_order
->u
.reloc
.p
->u
.name
,
2518 FALSE
, FALSE
, TRUE
));
2522 if (! ((*info
->callbacks
->unattached_reloc
)
2523 (info
, link_order
->u
.reloc
.p
->u
.name
, NULL
, NULL
, 0)))
2525 bfd_set_error (bfd_error_bad_value
);
2528 r
->sym_ptr_ptr
= &h
->sym
;
2531 /* If this is an inplace reloc, write the addend to the object file.
2532 Otherwise, store it in the reloc addend. */
2533 if (! r
->howto
->partial_inplace
)
2534 r
->addend
= link_order
->u
.reloc
.p
->addend
;
2538 bfd_reloc_status_type rstat
;
2543 size
= bfd_get_reloc_size (r
->howto
);
2544 buf
= (bfd_byte
*) bfd_zmalloc (size
);
2547 rstat
= _bfd_relocate_contents (r
->howto
, abfd
,
2548 (bfd_vma
) link_order
->u
.reloc
.p
->addend
,
2555 case bfd_reloc_outofrange
:
2557 case bfd_reloc_overflow
:
2558 if (! ((*info
->callbacks
->reloc_overflow
)
2560 (link_order
->type
== bfd_section_reloc_link_order
2561 ? bfd_section_name (abfd
, link_order
->u
.reloc
.p
->u
.section
)
2562 : link_order
->u
.reloc
.p
->u
.name
),
2563 r
->howto
->name
, link_order
->u
.reloc
.p
->addend
,
2571 loc
= link_order
->offset
* bfd_octets_per_byte (abfd
);
2572 ok
= bfd_set_section_contents (abfd
, sec
, buf
, loc
, size
);
2580 sec
->orelocation
[sec
->reloc_count
] = r
;
2586 /* Allocate a new link_order for a section. */
2588 struct bfd_link_order
*
2589 bfd_new_link_order (bfd
*abfd
, asection
*section
)
2591 bfd_size_type amt
= sizeof (struct bfd_link_order
);
2592 struct bfd_link_order
*new_lo
;
2594 new_lo
= (struct bfd_link_order
*) bfd_zalloc (abfd
, amt
);
2598 new_lo
->type
= bfd_undefined_link_order
;
2600 if (section
->map_tail
.link_order
!= NULL
)
2601 section
->map_tail
.link_order
->next
= new_lo
;
2603 section
->map_head
.link_order
= new_lo
;
2604 section
->map_tail
.link_order
= new_lo
;
2609 /* Default link order processing routine. Note that we can not handle
2610 the reloc_link_order types here, since they depend upon the details
2611 of how the particular backends generates relocs. */
2614 _bfd_default_link_order (bfd
*abfd
,
2615 struct bfd_link_info
*info
,
2617 struct bfd_link_order
*link_order
)
2619 switch (link_order
->type
)
2621 case bfd_undefined_link_order
:
2622 case bfd_section_reloc_link_order
:
2623 case bfd_symbol_reloc_link_order
:
2626 case bfd_indirect_link_order
:
2627 return default_indirect_link_order (abfd
, info
, sec
, link_order
,
2629 case bfd_data_link_order
:
2630 return default_data_link_order (abfd
, info
, sec
, link_order
);
2634 /* Default routine to handle a bfd_data_link_order. */
2637 default_data_link_order (bfd
*abfd
,
2638 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2640 struct bfd_link_order
*link_order
)
2648 BFD_ASSERT ((sec
->flags
& SEC_HAS_CONTENTS
) != 0);
2650 size
= link_order
->size
;
2654 fill
= link_order
->u
.data
.contents
;
2655 fill_size
= link_order
->u
.data
.size
;
2656 if (fill_size
!= 0 && fill_size
< size
)
2659 fill
= (bfd_byte
*) bfd_malloc (size
);
2664 memset (p
, (int) link_order
->u
.data
.contents
[0], (size_t) size
);
2669 memcpy (p
, link_order
->u
.data
.contents
, fill_size
);
2673 while (size
>= fill_size
);
2675 memcpy (p
, link_order
->u
.data
.contents
, (size_t) size
);
2676 size
= link_order
->size
;
2680 loc
= link_order
->offset
* bfd_octets_per_byte (abfd
);
2681 result
= bfd_set_section_contents (abfd
, sec
, fill
, loc
, size
);
2683 if (fill
!= link_order
->u
.data
.contents
)
2688 /* Default routine to handle a bfd_indirect_link_order. */
2691 default_indirect_link_order (bfd
*output_bfd
,
2692 struct bfd_link_info
*info
,
2693 asection
*output_section
,
2694 struct bfd_link_order
*link_order
,
2695 bfd_boolean generic_linker
)
2697 asection
*input_section
;
2699 bfd_byte
*contents
= NULL
;
2700 bfd_byte
*new_contents
;
2701 bfd_size_type sec_size
;
2704 BFD_ASSERT ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0);
2706 input_section
= link_order
->u
.indirect
.section
;
2707 input_bfd
= input_section
->owner
;
2708 if (input_section
->size
== 0)
2711 BFD_ASSERT (input_section
->output_section
== output_section
);
2712 BFD_ASSERT (input_section
->output_offset
== link_order
->offset
);
2713 BFD_ASSERT (input_section
->size
== link_order
->size
);
2715 if (info
->relocatable
2716 && input_section
->reloc_count
> 0
2717 && output_section
->orelocation
== NULL
)
2719 /* Space has not been allocated for the output relocations.
2720 This can happen when we are called by a specific backend
2721 because somebody is attempting to link together different
2722 types of object files. Handling this case correctly is
2723 difficult, and sometimes impossible. */
2724 (*_bfd_error_handler
)
2725 (_("Attempt to do relocatable link with %s input and %s output"),
2726 bfd_get_target (input_bfd
), bfd_get_target (output_bfd
));
2727 bfd_set_error (bfd_error_wrong_format
);
2731 if (! generic_linker
)
2736 /* Get the canonical symbols. The generic linker will always
2737 have retrieved them by this point, but we are being called by
2738 a specific linker, presumably because we are linking
2739 different types of object files together. */
2740 if (!bfd_generic_link_read_symbols (input_bfd
))
2743 /* Since we have been called by a specific linker, rather than
2744 the generic linker, the values of the symbols will not be
2745 right. They will be the values as seen in the input file,
2746 not the values of the final link. We need to fix them up
2747 before we can relocate the section. */
2748 sympp
= _bfd_generic_link_get_symbols (input_bfd
);
2749 symppend
= sympp
+ _bfd_generic_link_get_symcount (input_bfd
);
2750 for (; sympp
< symppend
; sympp
++)
2753 struct bfd_link_hash_entry
*h
;
2757 if ((sym
->flags
& (BSF_INDIRECT
2762 || bfd_is_und_section (bfd_get_section (sym
))
2763 || bfd_is_com_section (bfd_get_section (sym
))
2764 || bfd_is_ind_section (bfd_get_section (sym
)))
2766 /* sym->udata may have been set by
2767 generic_link_add_symbol_list. */
2768 if (sym
->udata
.p
!= NULL
)
2769 h
= (struct bfd_link_hash_entry
*) sym
->udata
.p
;
2770 else if (bfd_is_und_section (bfd_get_section (sym
)))
2771 h
= bfd_wrapped_link_hash_lookup (output_bfd
, info
,
2772 bfd_asymbol_name (sym
),
2773 FALSE
, FALSE
, TRUE
);
2775 h
= bfd_link_hash_lookup (info
->hash
,
2776 bfd_asymbol_name (sym
),
2777 FALSE
, FALSE
, TRUE
);
2779 set_symbol_from_hash (sym
, h
);
2784 if ((output_section
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) == SEC_GROUP
2785 && input_section
->size
!= 0)
2787 /* Group section contents are set by bfd_elf_set_group_contents. */
2788 if (!output_bfd
->output_has_begun
)
2790 /* FIXME: This hack ensures bfd_elf_set_group_contents is called. */
2791 if (!bfd_set_section_contents (output_bfd
, output_section
, "", 0, 1))
2794 new_contents
= output_section
->contents
;
2795 BFD_ASSERT (new_contents
!= NULL
);
2796 BFD_ASSERT (input_section
->output_offset
== 0);
2800 /* Get and relocate the section contents. */
2801 sec_size
= (input_section
->rawsize
> input_section
->size
2802 ? input_section
->rawsize
2803 : input_section
->size
);
2804 contents
= (bfd_byte
*) bfd_malloc (sec_size
);
2805 if (contents
== NULL
&& sec_size
!= 0)
2807 new_contents
= (bfd_get_relocated_section_contents
2808 (output_bfd
, info
, link_order
, contents
,
2810 _bfd_generic_link_get_symbols (input_bfd
)));
2815 /* Output the section contents. */
2816 loc
= input_section
->output_offset
* bfd_octets_per_byte (output_bfd
);
2817 if (! bfd_set_section_contents (output_bfd
, output_section
,
2818 new_contents
, loc
, input_section
->size
))
2821 if (contents
!= NULL
)
2826 if (contents
!= NULL
)
2831 /* A little routine to count the number of relocs in a link_order
2835 _bfd_count_link_order_relocs (struct bfd_link_order
*link_order
)
2837 register unsigned int c
;
2838 register struct bfd_link_order
*l
;
2841 for (l
= link_order
; l
!= NULL
; l
= l
->next
)
2843 if (l
->type
== bfd_section_reloc_link_order
2844 || l
->type
== bfd_symbol_reloc_link_order
)
2853 bfd_link_split_section
2856 bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);
2859 Return nonzero if @var{sec} should be split during a
2860 reloceatable or final link.
2862 .#define bfd_link_split_section(abfd, sec) \
2863 . BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
2869 _bfd_generic_link_split_section (bfd
*abfd ATTRIBUTE_UNUSED
,
2870 asection
*sec ATTRIBUTE_UNUSED
)
2877 bfd_section_already_linked
2880 void bfd_section_already_linked (bfd *abfd, asection *sec,
2881 struct bfd_link_info *info);
2884 Check if @var{sec} has been already linked during a reloceatable
2887 .#define bfd_section_already_linked(abfd, sec, info) \
2888 . BFD_SEND (abfd, _section_already_linked, (abfd, sec, info))
2893 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
2894 once into the output. This routine checks each section, and
2895 arrange to discard it if a section of the same name has already
2896 been linked. This code assumes that all relevant sections have the
2897 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
2898 section name. bfd_section_already_linked is called via
2899 bfd_map_over_sections. */
2901 /* The hash table. */
2903 static struct bfd_hash_table _bfd_section_already_linked_table
;
2905 /* Support routines for the hash table used by section_already_linked,
2906 initialize the table, traverse, lookup, fill in an entry and remove
2910 bfd_section_already_linked_table_traverse
2911 (bfd_boolean (*func
) (struct bfd_section_already_linked_hash_entry
*,
2912 void *), void *info
)
2914 bfd_hash_traverse (&_bfd_section_already_linked_table
,
2915 (bfd_boolean (*) (struct bfd_hash_entry
*,
2920 struct bfd_section_already_linked_hash_entry
*
2921 bfd_section_already_linked_table_lookup (const char *name
)
2923 return ((struct bfd_section_already_linked_hash_entry
*)
2924 bfd_hash_lookup (&_bfd_section_already_linked_table
, name
,
2929 bfd_section_already_linked_table_insert
2930 (struct bfd_section_already_linked_hash_entry
*already_linked_list
,
2933 struct bfd_section_already_linked
*l
;
2935 /* Allocate the memory from the same obstack as the hash table is
2937 l
= (struct bfd_section_already_linked
*)
2938 bfd_hash_allocate (&_bfd_section_already_linked_table
, sizeof *l
);
2942 l
->next
= already_linked_list
->entry
;
2943 already_linked_list
->entry
= l
;
2947 static struct bfd_hash_entry
*
2948 already_linked_newfunc (struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
,
2949 struct bfd_hash_table
*table
,
2950 const char *string ATTRIBUTE_UNUSED
)
2952 struct bfd_section_already_linked_hash_entry
*ret
=
2953 (struct bfd_section_already_linked_hash_entry
*)
2954 bfd_hash_allocate (table
, sizeof *ret
);
2965 bfd_section_already_linked_table_init (void)
2967 return bfd_hash_table_init_n (&_bfd_section_already_linked_table
,
2968 already_linked_newfunc
,
2969 sizeof (struct bfd_section_already_linked_hash_entry
),
2974 bfd_section_already_linked_table_free (void)
2976 bfd_hash_table_free (&_bfd_section_already_linked_table
);
2979 /* This is used on non-ELF inputs. */
2982 _bfd_generic_section_already_linked (bfd
*abfd
, asection
*sec
,
2983 struct bfd_link_info
*info
)
2987 struct bfd_section_already_linked
*l
;
2988 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2991 if ((flags
& SEC_LINK_ONCE
) == 0)
2994 /* FIXME: When doing a relocatable link, we may have trouble
2995 copying relocations in other sections that refer to local symbols
2996 in the section being discarded. Those relocations will have to
2997 be converted somehow; as of this writing I'm not sure that any of
2998 the backends handle that correctly.
3000 It is tempting to instead not discard link once sections when
3001 doing a relocatable link (technically, they should be discarded
3002 whenever we are building constructors). However, that fails,
3003 because the linker winds up combining all the link once sections
3004 into a single large link once section, which defeats the purpose
3005 of having link once sections in the first place. */
3007 name
= bfd_get_section_name (abfd
, sec
);
3009 already_linked_list
= bfd_section_already_linked_table_lookup (name
);
3011 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
3013 bfd_boolean skip
= FALSE
;
3014 struct coff_comdat_info
*s_comdat
3015 = bfd_coff_get_comdat_section (abfd
, sec
);
3016 struct coff_comdat_info
*l_comdat
3017 = bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
3019 /* We may have 3 different sections on the list: group section,
3020 comdat section and linkonce section. SEC may be a linkonce or
3021 comdat section. We always ignore group section. For non-COFF
3022 inputs, we also ignore comdat section.
3024 FIXME: Is that safe to match a linkonce section with a comdat
3025 section for COFF inputs? */
3026 if ((l
->sec
->flags
& SEC_GROUP
) != 0)
3028 else if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
3030 if (s_comdat
!= NULL
3032 && strcmp (s_comdat
->name
, l_comdat
->name
) != 0)
3035 else if (l_comdat
!= NULL
)
3040 /* The section has already been linked. See if we should
3042 switch (flags
& SEC_LINK_DUPLICATES
)
3047 case SEC_LINK_DUPLICATES_DISCARD
:
3050 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3051 (*_bfd_error_handler
)
3052 (_("%B: warning: ignoring duplicate section `%A'\n"),
3056 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3057 /* FIXME: We should really dig out the contents of both
3058 sections and memcmp them. The COFF/PE spec says that
3059 the Microsoft linker does not implement this
3060 correctly, so I'm not going to bother doing it
3063 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3064 if (sec
->size
!= l
->sec
->size
)
3065 (*_bfd_error_handler
)
3066 (_("%B: warning: duplicate section `%A' has different size\n"),
3071 /* Set the output_section field so that lang_add_section
3072 does not create a lang_input_section structure for this
3073 section. Since there might be a symbol in the section
3074 being discarded, we must retain a pointer to the section
3075 which we are really going to use. */
3076 sec
->output_section
= bfd_abs_section_ptr
;
3077 sec
->kept_section
= l
->sec
;
3083 /* This is the first section with this name. Record it. */
3084 if (! bfd_section_already_linked_table_insert (already_linked_list
, sec
))
3085 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
3088 /* Convert symbols in excluded output sections to use a kept section. */
3091 fix_syms (struct bfd_link_hash_entry
*h
, void *data
)
3093 bfd
*obfd
= (bfd
*) data
;
3095 if (h
->type
== bfd_link_hash_warning
)
3098 if (h
->type
== bfd_link_hash_defined
3099 || h
->type
== bfd_link_hash_defweak
)
3101 asection
*s
= h
->u
.def
.section
;
3103 && s
->output_section
!= NULL
3104 && (s
->output_section
->flags
& SEC_EXCLUDE
) != 0
3105 && bfd_section_removed_from_list (obfd
, s
->output_section
))
3109 h
->u
.def
.value
+= s
->output_offset
+ s
->output_section
->vma
;
3111 /* Find preceding kept section. */
3112 for (op1
= s
->output_section
->prev
; op1
!= NULL
; op1
= op1
->prev
)
3113 if ((op1
->flags
& SEC_EXCLUDE
) == 0
3114 && !bfd_section_removed_from_list (obfd
, op1
))
3117 /* Find following kept section. Start at prev->next because
3118 other sections may have been added after S was removed. */
3119 if (s
->output_section
->prev
!= NULL
)
3120 op
= s
->output_section
->prev
->next
;
3122 op
= s
->output_section
->owner
->sections
;
3123 for (; op
!= NULL
; op
= op
->next
)
3124 if ((op
->flags
& SEC_EXCLUDE
) == 0
3125 && !bfd_section_removed_from_list (obfd
, op
))
3128 /* Choose better of two sections, based on flags. The idea
3129 is to choose a section that will be in the same segment
3130 as S would have been if it was kept. */
3134 op
= bfd_abs_section_ptr
;
3136 else if (op
== NULL
)
3138 else if (((op1
->flags
^ op
->flags
)
3139 & (SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_LOAD
)) != 0)
3141 if (((op
->flags
^ s
->flags
)
3142 & (SEC_ALLOC
| SEC_THREAD_LOCAL
)) != 0
3143 /* We prefer to choose a loaded section. Section S
3144 doesn't have SEC_LOAD set (it being excluded, that
3145 part of the flag processing didn't happen) so we
3146 can't compare that flag to those of OP and OP1. */
3147 || ((op1
->flags
& SEC_LOAD
) != 0
3148 && (op
->flags
& SEC_LOAD
) == 0))
3151 else if (((op1
->flags
^ op
->flags
) & SEC_READONLY
) != 0)
3153 if (((op
->flags
^ s
->flags
) & SEC_READONLY
) != 0)
3156 else if (((op1
->flags
^ op
->flags
) & SEC_CODE
) != 0)
3158 if (((op
->flags
^ s
->flags
) & SEC_CODE
) != 0)
3163 /* Flags we care about are the same. Prefer the following
3164 section if that will result in a positive valued sym. */
3165 if (h
->u
.def
.value
< op
->vma
)
3169 h
->u
.def
.value
-= op
->vma
;
3170 h
->u
.def
.section
= op
;
3178 _bfd_fix_excluded_sec_syms (bfd
*obfd
, struct bfd_link_info
*info
)
3180 bfd_link_hash_traverse (info
->hash
, fix_syms
, obfd
);
3185 bfd_generic_define_common_symbol
3188 bfd_boolean bfd_generic_define_common_symbol
3189 (bfd *output_bfd, struct bfd_link_info *info,
3190 struct bfd_link_hash_entry *h);
3193 Convert common symbol @var{h} into a defined symbol.
3194 Return TRUE on success and FALSE on failure.
3196 .#define bfd_define_common_symbol(output_bfd, info, h) \
3197 . BFD_SEND (output_bfd, _bfd_define_common_symbol, (output_bfd, info, h))
3202 bfd_generic_define_common_symbol (bfd
*output_bfd
,
3203 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3204 struct bfd_link_hash_entry
*h
)
3206 unsigned int power_of_two
;
3207 bfd_vma alignment
, size
;
3210 BFD_ASSERT (h
!= NULL
&& h
->type
== bfd_link_hash_common
);
3213 power_of_two
= h
->u
.c
.p
->alignment_power
;
3214 section
= h
->u
.c
.p
->section
;
3216 /* Increase the size of the section to align the common symbol.
3217 The alignment must be a power of two. */
3218 alignment
= bfd_octets_per_byte (output_bfd
) << power_of_two
;
3219 BFD_ASSERT (alignment
!= 0 && (alignment
& -alignment
) == alignment
);
3220 section
->size
+= alignment
- 1;
3221 section
->size
&= -alignment
;
3223 /* Adjust the section's overall alignment if necessary. */
3224 if (power_of_two
> section
->alignment_power
)
3225 section
->alignment_power
= power_of_two
;
3227 /* Change the symbol from common to defined. */
3228 h
->type
= bfd_link_hash_defined
;
3229 h
->u
.def
.section
= section
;
3230 h
->u
.def
.value
= section
->size
;
3232 /* Increase the size of the section. */
3233 section
->size
+= size
;
3235 /* Make sure the section is allocated in memory, and make sure that
3236 it is no longer a common section. */
3237 section
->flags
|= SEC_ALLOC
;
3238 section
->flags
&= ~SEC_IS_COMMON
;
3244 bfd_find_version_for_sym
3247 struct bfd_elf_version_tree * bfd_find_version_for_sym
3248 (struct bfd_elf_version_tree *verdefs,
3249 const char *sym_name, bfd_boolean *hide);
3252 Search an elf version script tree for symbol versioning
3253 info and export / don't-export status for a given symbol.
3254 Return non-NULL on success and NULL on failure; also sets
3255 the output @samp{hide} boolean parameter.
3259 struct bfd_elf_version_tree
*
3260 bfd_find_version_for_sym (struct bfd_elf_version_tree
*verdefs
,
3261 const char *sym_name
,
3264 struct bfd_elf_version_tree
*t
;
3265 struct bfd_elf_version_tree
*local_ver
, *global_ver
, *exist_ver
;
3266 struct bfd_elf_version_tree
*star_local_ver
, *star_global_ver
;
3270 star_local_ver
= NULL
;
3271 star_global_ver
= NULL
;
3273 for (t
= verdefs
; t
!= NULL
; t
= t
->next
)
3275 if (t
->globals
.list
!= NULL
)
3277 struct bfd_elf_version_expr
*d
= NULL
;
3279 while ((d
= (*t
->match
) (&t
->globals
, d
, sym_name
)) != NULL
)
3281 if (d
->literal
|| strcmp (d
->pattern
, "*") != 0)
3284 star_global_ver
= t
;
3288 /* If the match is a wildcard pattern, keep looking for
3289 a more explicit, perhaps even local, match. */
3298 if (t
->locals
.list
!= NULL
)
3300 struct bfd_elf_version_expr
*d
= NULL
;
3302 while ((d
= (*t
->match
) (&t
->locals
, d
, sym_name
)) != NULL
)
3304 if (d
->literal
|| strcmp (d
->pattern
, "*") != 0)
3308 /* If the match is a wildcard pattern, keep looking for
3309 a more explicit, perhaps even global, match. */
3312 /* An exact match overrides a global wildcard. */
3314 star_global_ver
= NULL
;
3324 if (global_ver
== NULL
&& local_ver
== NULL
)
3325 global_ver
= star_global_ver
;
3327 if (global_ver
!= NULL
)
3329 /* If we already have a versioned symbol that matches the
3330 node for this symbol, then we don't want to create a
3331 duplicate from the unversioned symbol. Instead hide the
3332 unversioned symbol. */
3333 *hide
= exist_ver
== global_ver
;
3337 if (local_ver
== NULL
)
3338 local_ver
= star_local_ver
;
3340 if (local_ver
!= NULL
)