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