1 /* Copyright (C) 1991 Free Software Foundation, Inc.
2 Written by Steve Chamberlain steve@cygnus.com
4 This file is part of GLD, the Gnu Linker.
6 GLD is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GLD is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GLD; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
44 extern boolean lang_has_input_file
;
45 extern boolean trace_files
;
49 char *output_filename
= "a.out";
50 /* Name this program was invoked by. */
53 /* The file that we're creating */
56 extern boolean option_v
;
58 /* The local symbol prefix */
61 /* Count the number of global symbols multiply defined. */
62 int multiple_def_count
;
65 /* Count the number of symbols defined through common declarations.
66 This count is referenced in symdef_library, linear_library, and
67 modified by enter_global_ref.
69 It is incremented when a symbol is created as a common, and
70 decremented when the common declaration is overridden
72 Another way of thinking of it is that this is a count of
73 all ldsym_types with a ->scoms field */
75 unsigned int commons_pending
;
77 /* Count the number of global symbols referenced and not defined.
78 common symbols are not included in this count. */
80 unsigned int undefined_global_sym_count
;
84 /* Count the number of warning symbols encountered. */
87 /* have we had a load script ? */
88 extern boolean had_script
;
90 /* Nonzero means print names of input files as processed. */
95 /* 1 => write load map. */
101 /* Indicates whether output file will be b.out (default) or coff */
102 enum target_flavour output_flavor
= BFD_BOUT_FORMAT
;
105 /* Force the make_executable to be output, even if there are non-fatal
107 boolean force_make_executable
;
109 /* A count of the total number of local symbols ever seen - by adding
110 the symbol_count field of each newly read afile.*/
112 unsigned int total_symbols_seen
;
114 /* A count of the number of read files - the same as the number of elements
117 unsigned int total_files_seen
;
121 args_type command_line
;
122 ld_config_type config
;
129 program_name
= argv
[0];
130 output_filename
= "a.out";
138 check_v960( argc
, argv
);
139 emulation
= "gld960";
140 for ( i
= 1; i
< argc
; i
++ ){
141 if ( !strcmp(argv
[i
],"-Fcoff") ){
142 emulation
= "lnk960";
143 output_flavor
= BFD_COFF_FORMAT
;
149 emulation
= (char *) getenv(EMULATION_ENVIRON
);
152 /* Initialize the data about options. */
157 config
.relocateable_output
= false;
159 command_line
.force_common_definition
= false;
161 init_bfd_error_vector();
165 config
.make_executable
= true;
166 force_make_executable
= false;
169 /* Initialize the cumulative counts of symbols. */
170 undefined_global_sym_count
= 0;
172 multiple_def_count
= 0;
175 config
.magic_demand_paged
= true;
176 config
.text_read_only
= true;
177 config
.make_executable
= true;
178 if (emulation
== (char *)NULL
) {
179 emulation
= DEFAULT_EMULATION
;
182 ldemul_choose_mode(emulation
);
183 default_target
= ldemul_choose_target();
185 ldemul_before_parse();
186 lang_has_input_file
= false;
187 parse_args(argc
, argv
);
192 info("%P: mode %s\n", emulation
);
195 if (lang_has_input_file
== false) {
196 einfo("%P%F: No input files\n");
199 ldemul_after_parse();
202 if (config
.map_filename
)
204 if (strcmp(config
.map_filename
, "-") == 0)
206 config
.map_file
= stdout
;
209 config
.map_file
= fopen(config
.map_filename
, FOPEN_WT
);
210 if (config
.map_file
== (FILE *)NULL
)
212 einfo("%P%F: can't open map file %s\n",
213 config
.map_filename
);
221 /* Print error messages for any missing symbols, for any warning
222 symbols, and possibly multiple definitions */
225 if (config
.text_read_only
)
227 /* Look for a text section and mark the readonly attribute in it */
228 asection
*found
= bfd_get_section_by_name(output_bfd
, ".text");
229 if (found
!= (asection
*)NULL
) {
230 found
->flags
|= SEC_READONLY
;
234 if (config
.relocateable_output
) {
235 output_bfd
->flags
&= ~EXEC_P
;
238 bfd_close(output_bfd
);
244 output_bfd
->flags
|= EXEC_P
;
249 if (config
.make_executable
== false && force_make_executable
==false)
251 printf("Link errors found, deleting executable %s\n",
253 if (output_bfd
->iostream
)
254 fclose(output_bfd
->iostream
);
256 unlink(output_filename
);
260 bfd_close(output_bfd
);
271 Q_read_entry_symbols (desc
, entry
)
273 struct lang_input_statement_struct
*entry
;
275 if (entry
->asymbols
== (asymbol
**)NULL
) {
276 bfd_size_type table_size
= get_symtab_upper_bound(desc
);
277 entry
->asymbols
= (asymbol
**)ldmalloc(table_size
);
278 entry
->symbol_count
= bfd_canonicalize_symtab(desc
, entry
->asymbols
) ;
284 * turn this item into a reference
291 asymbol
*sym
= *nlist_p
;
294 sym
->section
= &bfd_und_section
;
295 sym
->udata
=(PTR
)( sp
->srefs_chain
);
296 sp
->srefs_chain
= nlist_p
;
299 This function is called for each name which is seen which has a global
300 scope. It enters the name into the global symbol table in the correct
301 symbol on the correct chain. Remember that each ldsym_type has three
302 chains attatched, one of all definitions of a symbol, one of all
303 references of a symbol and one of all common definitions of a symbol.
305 When the function is over, the supplied is left connected to the bfd
306 to which is was born, with its udata field pointing to the next member
307 on the chain in which it has been inserted.
309 A certain amount of jigery pokery is necessary since commons come
310 along and upset things, we only keep one item in the common chain; the
311 one with the biggest size seen sofar. When another common comes along
312 it either bumps the previous definition into the ref chain, since it
313 is bigger, or gets turned into a ref on the spot since the one on the
314 common chain is already bigger. If a real definition comes along then
315 the common gets bumped off anyway.
317 Whilst all this is going on we keep a count of the number of multiple
318 definitions seen, undefined global symbols and pending commons.
321 extern boolean relaxing
;
324 Q_enter_global_ref (nlist_p
)
328 asymbol
*sym
= *nlist_p
;
329 CONST
char *name
= sym
->name
;
330 ldsym_type
*sp
= ldsym_get (name
);
332 flagword this_symbol_flags
= sym
->flags
;
335 ASSERT(sym
->udata
== 0);
338 if (flag_is_constructor(this_symbol_flags
)) {
339 /* Add this constructor to the list we keep */
340 ldlang_add_constructor(sp
);
341 /* Turn any commons into refs */
342 if (sp
->scoms_chain
!= (asymbol
**)NULL
) {
343 refize(sp
, sp
->scoms_chain
);
350 if (sym
->section
== &bfd_com_section
) {
351 /* If we have a definition of this symbol already then
352 this common turns into a reference. Also we only
353 ever point to the largest common, so if we
354 have a common, but it's bigger that the new symbol
355 the turn this into a reference too. */
358 /* This is a common symbol, but we already have a definition
359 for it, so just link it into the ref chain as if
360 it were a reference */
363 else if (sp
->scoms_chain
) {
364 /* If we have a previous common, keep only the biggest */
365 if ( (*(sp
->scoms_chain
))->value
> sym
->value
) {
366 /* other common is bigger, throw this one away */
369 else if (sp
->scoms_chain
!= nlist_p
) {
370 /* other common is smaller, throw that away */
371 refize(sp
, sp
->scoms_chain
);
372 sp
->scoms_chain
= nlist_p
;
376 /* This is the first time we've seen a common, so remember it
377 - if it was undefined before, we know it's defined now. If
378 the symbol has been marked as really being a constructor,
379 then treat this as a ref
381 if (sp
->flags
& SYM_CONSTRUCTOR
) {
382 /* Turn this into a ref */
386 /* treat like a common */
388 undefined_global_sym_count
--;
391 sp
->scoms_chain
= nlist_p
;
396 else if (sym
->section
!= &bfd_und_section
) {
397 /* This is the definition of a symbol, add to def chain */
398 if (sp
->sdefs_chain
&& (*(sp
->sdefs_chain
))->section
!= sym
->section
) {
399 /* Multiple definition */
400 asymbol
*sy
= *(sp
->sdefs_chain
);
401 lang_input_statement_type
*stat
= (lang_input_statement_type
*) sy
->the_bfd
->usrdata
;
402 lang_input_statement_type
*stat1
= (lang_input_statement_type
*) sym
->the_bfd
->usrdata
;
403 asymbol
** stat1_symbols
= stat1
? stat1
->asymbols
: 0;
404 asymbol
** stat_symbols
= stat
? stat
->asymbols
:0;
406 multiple_def_count
++;
407 einfo("%X%C: multiple definition of `%T'\n",
408 sym
->the_bfd
, sym
->section
, stat1_symbols
, sym
->value
, sym
);
410 einfo("%X%C: first seen here\n",
411 sy
->the_bfd
, sy
->section
, stat_symbols
, sy
->value
);
414 sym
->udata
=(PTR
)( sp
->sdefs_chain
);
415 sp
->sdefs_chain
= nlist_p
;
417 /* A definition overrides a common symbol */
418 if (sp
->scoms_chain
) {
419 refize(sp
, sp
->scoms_chain
);
423 else if (sp
->srefs_chain
&& relaxing
== false) {
424 /* If previously was undefined, then remember as defined */
425 undefined_global_sym_count
--;
429 if (sp
->scoms_chain
== (asymbol
**)NULL
430 && sp
->srefs_chain
== (asymbol
**)NULL
431 && sp
->sdefs_chain
== (asymbol
**)NULL
) {
432 /* And it's the first time we've seen it */
433 undefined_global_sym_count
++;
441 ASSERT(sp
->sdefs_chain
== 0 || sp
->scoms_chain
== 0);
442 ASSERT(sp
->scoms_chain
==0 || (*(sp
->scoms_chain
))->udata
== 0);
448 Q_enter_file_symbols (entry
)
449 lang_input_statement_type
*entry
;
453 entry
->common_section
=
454 bfd_make_section_old_way(entry
->the_bfd
, "COMMON");
456 ldlang_add_file(entry
);
459 if (trace_files
|| option_v
) {
463 total_symbols_seen
+= entry
->symbol_count
;
465 for (q
= entry
->asymbols
; *q
; q
++)
469 if (p
->flags
& BSF_INDIRECT
)
473 else if (p
->flags
& BSF_WARNING
)
478 else if (p
->section
== &bfd_und_section
479 || (p
->flags
& BSF_GLOBAL
)
480 || p
->section
== &bfd_com_section
481 || (p
->flags
& BSF_CONSTRUCTOR
))
483 Q_enter_global_ref(q
);
492 /* Searching libraries */
494 struct lang_input_statement_struct
*decode_library_subfile ();
495 void linear_library (), symdef_library ();
497 /* Search the library ENTRY, already open on descriptor DESC.
498 This means deciding which library members to load,
499 making a chain of `struct lang_input_statement_struct' for those members,
500 and entering their global symbols in the hash table. */
503 search_library (entry
)
504 struct lang_input_statement_struct
*entry
;
507 /* No need to load a library if no undefined symbols */
508 if (!undefined_global_sym_count
) return;
510 if (bfd_has_map(entry
->the_bfd
))
511 symdef_library (entry
);
513 linear_library (entry
);
521 gnu960_check_format (abfd
, format
)
527 if ((bfd_check_format(abfd
,format
) == true)
528 && (abfd
->xvec
->flavour
== output_flavor
) ){
538 ldmain_open_file_read_symbol (entry
)
539 struct lang_input_statement_struct
*entry
;
541 if (entry
->asymbols
== (asymbol
**)NULL
542 &&entry
->real
== true
543 && entry
->filename
!= (char *)NULL
)
545 ldfile_open_file (entry
);
549 if (gnu960_check_format(entry
->the_bfd
, bfd_object
))
551 if (bfd_check_format(entry
->the_bfd
, bfd_object
))
554 entry
->the_bfd
->usrdata
= (PTR
)entry
;
557 Q_read_entry_symbols (entry
->the_bfd
, entry
);
559 /* look through the sections in the file and see if any of them
561 ldlang_check_for_constructors (entry
);
563 Q_enter_file_symbols (entry
);
566 else if (gnu960_check_format(entry
->the_bfd
, bfd_archive
))
568 else if (bfd_check_format(entry
->the_bfd
, bfd_archive
))
571 entry
->the_bfd
->usrdata
= (PTR
)entry
;
573 entry
->subfiles
= (lang_input_statement_type
*)NULL
;
574 search_library (entry
);
578 einfo("%F%B: malformed input file (not rel or archive) \n",
586 /* Construct and return a lang_input_statement_struct for a library member.
587 The library's lang_input_statement_struct is library_entry,
588 and the library is open on DESC.
589 SUBFILE_OFFSET is the byte index in the library of this member's header.
590 We store the length of the member into *LENGTH_LOC. */
592 lang_input_statement_type
*
593 decode_library_subfile (library_entry
, subfile_offset
)
594 struct lang_input_statement_struct
*library_entry
;
597 register struct lang_input_statement_struct
*subentry
;
598 subentry
= (struct lang_input_statement_struct
*) ldmalloc ((bfd_size_type
)(sizeof (struct lang_input_statement_struct
)));
599 subentry
->filename
= subfile_offset
-> filename
;
600 subentry
->local_sym_name
= subfile_offset
->filename
;
601 subentry
->asymbols
= 0;
602 subentry
->the_bfd
= subfile_offset
;
603 subentry
->subfiles
= 0;
605 subentry
->superfile
= library_entry
;
606 subentry
->is_archive
= false;
608 subentry
->just_syms_flag
= false;
609 subentry
->loaded
= false;
615 boolean
subfile_wanted_p ();
617 clear_syms(entry
, offset
)
618 struct lang_input_statement_struct
*entry
;
622 unsigned long indx
= bfd_get_next_mapent(entry
->the_bfd
,
625 while (indx
!= BFD_NO_MORE_SYMBOLS
) {
626 if (car
->file_offset
== offset
) {
629 indx
= bfd_get_next_mapent(entry
->the_bfd
, indx
, &car
);
634 /* Search a library that has a map
637 symdef_library (entry
)
638 struct lang_input_statement_struct
*entry
;
641 register struct lang_input_statement_struct
*prev
= 0;
643 boolean not_finished
= true;
646 while (not_finished
== true)
648 carsym
*exported_library_name
;
649 bfd
*prev_archive_member_bfd
= 0;
651 int idx
= bfd_get_next_mapent(entry
->the_bfd
,
653 &exported_library_name
);
655 not_finished
= false;
657 while (idx
!= BFD_NO_MORE_SYMBOLS
&& undefined_global_sym_count
)
660 if (exported_library_name
->name
)
663 ldsym_type
*sp
= ldsym_get_soft (exported_library_name
->name
);
665 /* If we find a symbol that appears to be needed, think carefully
666 about the archive member that the symbol is in. */
667 /* So - if it exists, and is referenced somewhere and is
669 if (sp
&& sp
->srefs_chain
&& !sp
->sdefs_chain
)
671 bfd
*archive_member_bfd
= bfd_get_elt_at_index(entry
->the_bfd
, idx
);
672 struct lang_input_statement_struct
*archive_member_lang_input_statement_struct
;
675 if (archive_member_bfd
&& gnu960_check_format(archive_member_bfd
, bfd_object
))
677 if (archive_member_bfd
&& bfd_check_format(archive_member_bfd
, bfd_object
))
681 /* Don't think carefully about any archive member
682 more than once in a given pass. */
683 if (prev_archive_member_bfd
!= archive_member_bfd
)
686 prev_archive_member_bfd
= archive_member_bfd
;
688 /* Read the symbol table of the archive member. */
690 if (archive_member_bfd
->usrdata
!= (PTR
)NULL
) {
692 archive_member_lang_input_statement_struct
=(lang_input_statement_type
*) archive_member_bfd
->usrdata
;
696 archive_member_lang_input_statement_struct
=
697 decode_library_subfile (entry
, archive_member_bfd
);
698 archive_member_bfd
->usrdata
= (PTR
) archive_member_lang_input_statement_struct
;
702 if (archive_member_lang_input_statement_struct
== 0) {
703 einfo ("%F%I contains invalid archive member %s\n",
707 if (archive_member_lang_input_statement_struct
->loaded
== false)
710 Q_read_entry_symbols (archive_member_bfd
, archive_member_lang_input_statement_struct
);
711 /* Now scan the symbol table and decide whether to load. */
714 if (subfile_wanted_p (archive_member_lang_input_statement_struct
) == true)
717 /* This member is needed; load it.
718 Since we are loading something on this pass,
719 we must make another pass through the symdef data. */
723 Q_enter_file_symbols (archive_member_lang_input_statement_struct
);
726 prev
->chain
= archive_member_lang_input_statement_struct
;
728 entry
->subfiles
= archive_member_lang_input_statement_struct
;
731 prev
= archive_member_lang_input_statement_struct
;
734 /* Clear out this member's symbols from the symdef data
735 so that following passes won't waste time on them. */
736 clear_syms(entry
, exported_library_name
->file_offset
);
737 archive_member_lang_input_statement_struct
->loaded
= true;
744 idx
= bfd_get_next_mapent(entry
->the_bfd
, idx
, &exported_library_name
);
750 linear_library (entry
)
751 struct lang_input_statement_struct
*entry
;
753 boolean more_to_do
= true;
754 register struct lang_input_statement_struct
*prev
= 0;
758 bfd
* archive
= bfd_openr_next_archived_file(entry
->the_bfd
,0);
763 if (gnu960_check_format(archive
, bfd_object
))
765 if (bfd_check_format(archive
, bfd_object
))
768 register struct lang_input_statement_struct
*subentry
;
770 subentry
= decode_library_subfile (entry
,
773 archive
->usrdata
= (PTR
) subentry
;
774 if (!subentry
) return;
775 if (subentry
->loaded
== false) {
776 Q_read_entry_symbols (archive
, subentry
);
778 if (subfile_wanted_p (subentry
) == true)
780 Q_enter_file_symbols (subentry
);
783 prev
->chain
= subentry
;
785 entry
->subfiles
= subentry
;
789 subentry
->loaded
= true;
793 archive
= bfd_openr_next_archived_file(entry
->the_bfd
,archive
);
800 /* ENTRY is an entry for a library member.
801 Its symbols have been read into core, but not entered.
802 Return nonzero if we ought to load this member. */
805 subfile_wanted_p (entry
)
806 struct lang_input_statement_struct
*entry
;
810 for (q
= entry
->asymbols
; *q
; q
++)
814 /* If the symbol has an interesting definition, we could
815 potentially want it. */
817 if (p
->flags
& BSF_INDIRECT
) {
818 /* Grab out the name we've indirected to, and keep the insides
823 if (p
->section
== &bfd_com_section
824 || (p
->flags
& BSF_GLOBAL
)
825 || (p
->flags
& BSF_INDIRECT
))
827 register ldsym_type
*sp
= ldsym_get_soft (p
->name
);
830 /* If this symbol has not been hashed,
831 we can't be looking for it. */
832 if (sp
!= (ldsym_type
*)NULL
833 && sp
->sdefs_chain
== (asymbol
**)NULL
) {
834 if (sp
->srefs_chain
!= (asymbol
**)NULL
835 || sp
->scoms_chain
!= (asymbol
**)NULL
)
837 /* This is a symbol we are looking for. It is either
838 not yet defined or common. */
840 if (p
->section
== &bfd_com_section
)
843 /* If the symbol in the table is a constructor, we won't to
844 anything fancy with it */
845 if ((sp
->flags
& SYM_CONSTRUCTOR
) == 0) {
846 /* This libary member has something to
847 say about this element. We should
848 remember if its a new size */
849 /* Move something from the ref list to the com list */
850 if(sp
->scoms_chain
) {
851 /* Already a common symbol, maybe update it */
852 if (p
->value
> (*(sp
->scoms_chain
))->value
) {
853 (*(sp
->scoms_chain
))->value
= p
->value
;
857 /* Take a value from the ref chain
858 Here we are moving a symbol from the owning bfd
859 to another bfd. We must set up the
860 common_section portion of the bfd thing */
864 sp
->scoms_chain
= sp
->srefs_chain
;
866 (asymbol
**)((*(sp
->srefs_chain
))->udata
);
867 (*(sp
->scoms_chain
))->udata
= (PTR
)NULL
;
869 (*( sp
->scoms_chain
))->section
=
871 (*( sp
->scoms_chain
))->flags
= 0;
872 /* Remember the size of this item */
873 sp
->scoms_chain
[0]->value
= p
->value
;
875 undefined_global_sym_count
--;
877 asymbol
*com
= *(sp
->scoms_chain
);
878 if (((lang_input_statement_type
*)
879 (com
->the_bfd
->usrdata
))->common_section
==
881 ((lang_input_statement_type
*)
882 (com
->the_bfd
->usrdata
))->common_section
=
883 bfd_make_section_old_way(com
->the_bfd
, "COMMON");
887 ASSERT(p
->udata
== 0);
893 info("%I needed due to %s\n",entry
, sp
->name
);