bfd/
[deliverable/binutils-gdb.git] / ld / ldmain.c
1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain steve@cygnus.com
6
7 This file is part of GLD, the Gnu Linker.
8
9 GLD is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
13
14 GLD is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GLD; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 02111-1307, USA. */
23
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include <stdio.h>
27 #include "safe-ctype.h"
28 #include "libiberty.h"
29 #include "progress.h"
30 #include "bfdlink.h"
31 #include "filenames.h"
32
33 #include "ld.h"
34 #include "ldmain.h"
35 #include "ldmisc.h"
36 #include "ldwrite.h"
37 #include "ldexp.h"
38 #include "ldlang.h"
39 #include <ldgram.h>
40 #include "ldlex.h"
41 #include "ldfile.h"
42 #include "ldemul.h"
43 #include "ldctor.h"
44
45 /* Somewhere above, sys/stat.h got included. */
46 #if !defined(S_ISDIR) && defined(S_IFDIR)
47 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
48 #endif
49
50 #include <string.h>
51
52 #ifdef HAVE_SBRK
53 #ifdef NEED_DECLARATION_SBRK
54 extern PTR sbrk ();
55 #endif
56 #endif
57
58 #ifndef TARGET_SYSTEM_ROOT
59 #define TARGET_SYSTEM_ROOT ""
60 #endif
61
62 int main PARAMS ((int, char **));
63
64 /* EXPORTS */
65
66 char *default_target;
67 const char *output_filename = "a.out";
68
69 /* Name this program was invoked by. */
70 char *program_name;
71
72 /* The prefix for system library directories. */
73 char *ld_sysroot;
74
75 /* The canonical representation of ld_sysroot. */
76 char * ld_canon_sysroot;
77 int ld_canon_sysroot_len;
78
79 /* The file that we're creating. */
80 bfd *output_bfd = 0;
81
82 /* Set by -G argument, for MIPS ECOFF target. */
83 int g_switch_value = 8;
84
85 /* Nonzero means print names of input files as processed. */
86 bfd_boolean trace_files;
87
88 /* Nonzero means same, but note open failures, too. */
89 bfd_boolean trace_file_tries;
90
91 /* Nonzero means version number was printed, so exit successfully
92 instead of complaining if no input files are given. */
93 bfd_boolean version_printed;
94
95 /* Nonzero means link in every member of an archive. */
96 bfd_boolean whole_archive;
97
98 /* TRUE if we should demangle symbol names. */
99 bfd_boolean demangling;
100
101 args_type command_line;
102
103 ld_config_type config;
104
105 static char *get_emulation
106 PARAMS ((int, char **));
107 static void set_scripts_dir
108 PARAMS ((void));
109 static void remove_output
110 PARAMS ((void));
111 static bfd_boolean check_for_scripts_dir
112 PARAMS ((char *));
113 static bfd_boolean add_archive_element
114 PARAMS ((struct bfd_link_info *, bfd *, const char *));
115 static bfd_boolean multiple_definition
116 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
117 bfd *, asection *, bfd_vma));
118 static bfd_boolean multiple_common
119 PARAMS ((struct bfd_link_info *, const char *, bfd *,
120 enum bfd_link_hash_type, bfd_vma, bfd *, enum bfd_link_hash_type,
121 bfd_vma));
122 static bfd_boolean add_to_set
123 PARAMS ((struct bfd_link_info *, struct bfd_link_hash_entry *,
124 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma));
125 static bfd_boolean constructor_callback
126 PARAMS ((struct bfd_link_info *, bfd_boolean, const char *, bfd *,
127 asection *, bfd_vma));
128 static bfd_boolean warning_callback
129 PARAMS ((struct bfd_link_info *, const char *, const char *, bfd *,
130 asection *, bfd_vma));
131 static void warning_find_reloc
132 PARAMS ((bfd *, asection *, PTR));
133 static bfd_boolean undefined_symbol
134 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
135 bfd_boolean));
136 static bfd_boolean reloc_overflow
137 PARAMS ((struct bfd_link_info *, const char *, const char *, bfd_vma,
138 bfd *, asection *, bfd_vma));
139 static bfd_boolean reloc_dangerous
140 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma));
141 static bfd_boolean unattached_reloc
142 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma));
143 static bfd_boolean notice
144 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma));
145
146 static struct bfd_link_callbacks link_callbacks =
147 {
148 add_archive_element,
149 multiple_definition,
150 multiple_common,
151 add_to_set,
152 constructor_callback,
153 warning_callback,
154 undefined_symbol,
155 reloc_overflow,
156 reloc_dangerous,
157 unattached_reloc,
158 notice,
159 error_handler
160 };
161
162 struct bfd_link_info link_info;
163 \f
164 static void
165 remove_output ()
166 {
167 if (output_filename)
168 {
169 if (output_bfd && output_bfd->iostream)
170 fclose ((FILE *) (output_bfd->iostream));
171 if (delete_output_file_on_failure)
172 unlink (output_filename);
173 }
174 }
175
176 int
177 main (argc, argv)
178 int argc;
179 char **argv;
180 {
181 char *emulation;
182 long start_time = get_run_time ();
183
184 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
185 setlocale (LC_MESSAGES, "");
186 #endif
187 #if defined (HAVE_SETLOCALE)
188 setlocale (LC_CTYPE, "");
189 #endif
190 bindtextdomain (PACKAGE, LOCALEDIR);
191 textdomain (PACKAGE);
192
193 program_name = argv[0];
194 xmalloc_set_program_name (program_name);
195
196 START_PROGRESS (program_name, 0);
197
198 bfd_init ();
199
200 bfd_set_error_program_name (program_name);
201
202 xatexit (remove_output);
203
204 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
205 ld_sysroot = make_relative_prefix (program_name, BINDIR,
206 TARGET_SYSTEM_ROOT);
207
208 if (ld_sysroot)
209 {
210 struct stat s;
211 int res = stat (ld_sysroot, &s) == 0 && S_ISDIR (s.st_mode);
212
213 if (!res)
214 {
215 free (ld_sysroot);
216 ld_sysroot = NULL;
217 }
218 }
219
220 if (! ld_sysroot)
221 {
222 ld_sysroot = make_relative_prefix (program_name, TOOLBINDIR,
223 TARGET_SYSTEM_ROOT);
224
225 if (ld_sysroot)
226 {
227 struct stat s;
228 int res = stat (ld_sysroot, &s) == 0 && S_ISDIR (s.st_mode);
229
230 if (!res)
231 {
232 free (ld_sysroot);
233 ld_sysroot = NULL;
234 }
235 }
236 }
237
238 if (! ld_sysroot)
239 #endif
240 ld_sysroot = TARGET_SYSTEM_ROOT;
241
242 if (ld_sysroot && *ld_sysroot)
243 ld_canon_sysroot = lrealpath (ld_sysroot);
244
245 if (ld_canon_sysroot)
246 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
247 else
248 ld_canon_sysroot_len = -1;
249
250 /* Set the default BFD target based on the configured target. Doing
251 this permits the linker to be configured for a particular target,
252 and linked against a shared BFD library which was configured for
253 a different target. The macro TARGET is defined by Makefile. */
254 if (! bfd_set_default_target (TARGET))
255 {
256 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
257 xexit (1);
258 }
259
260 #if YYDEBUG
261 {
262 extern int yydebug;
263 yydebug = 1;
264 }
265 #endif
266
267 /* Initialize the data about options. */
268 trace_files = trace_file_tries = version_printed = FALSE;
269 whole_archive = FALSE;
270 config.build_constructors = TRUE;
271 config.dynamic_link = FALSE;
272 config.has_shared = FALSE;
273 config.split_by_reloc = (unsigned) -1;
274 config.split_by_file = (bfd_size_type) -1;
275 command_line.force_common_definition = FALSE;
276 command_line.inhibit_common_definition = FALSE;
277 command_line.interpreter = NULL;
278 command_line.rpath = NULL;
279 command_line.warn_mismatch = TRUE;
280 command_line.check_section_addresses = TRUE;
281 command_line.accept_unknown_input_arch = FALSE;
282
283 /* We initialize DEMANGLING based on the environment variable
284 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
285 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
286 environment. Acting the same way here lets us provide the same
287 interface by default. */
288 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
289
290 link_info.relocateable = FALSE;
291 link_info.emitrelocations = FALSE;
292 link_info.task_link = FALSE;
293 link_info.shared = FALSE;
294 link_info.symbolic = FALSE;
295 link_info.export_dynamic = FALSE;
296 link_info.static_link = FALSE;
297 link_info.traditional_format = FALSE;
298 link_info.optimize = FALSE;
299 link_info.no_undefined = FALSE;
300 link_info.allow_shlib_undefined = TRUE;
301 link_info.allow_multiple_definition = FALSE;
302 link_info.allow_undefined_version = TRUE;
303 link_info.keep_memory = TRUE;
304 link_info.notice_all = FALSE;
305 link_info.nocopyreloc = FALSE;
306 link_info.new_dtags = FALSE;
307 link_info.combreloc = TRUE;
308 link_info.eh_frame_hdr = FALSE;
309 link_info.strip_discarded = TRUE;
310 link_info.strip = strip_none;
311 link_info.discard = discard_sec_merge;
312 link_info.common_skip_ar_aymbols = bfd_link_common_skip_none;
313 link_info.callbacks = &link_callbacks;
314 link_info.hash = NULL;
315 link_info.keep_hash = NULL;
316 link_info.notice_hash = NULL;
317 link_info.wrap_hash = NULL;
318 link_info.input_bfds = NULL;
319 link_info.create_object_symbols_section = NULL;
320 link_info.gc_sym_list = NULL;
321 link_info.base_file = NULL;
322 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
323 and _fini symbols. We are compatible. */
324 link_info.init_function = "_init";
325 link_info.fini_function = "_fini";
326 link_info.mpc860c0 = 0;
327 link_info.pei386_auto_import = -1;
328 link_info.pei386_runtime_pseudo_reloc = FALSE;
329 link_info.spare_dynamic_tags = 5;
330 link_info.flags = (bfd_vma) 0;
331 link_info.flags_1 = (bfd_vma) 0;
332 link_info.relax_finalizing = FALSE;
333
334 ldfile_add_arch ("");
335
336 config.make_executable = TRUE;
337 force_make_executable = FALSE;
338 config.magic_demand_paged = TRUE;
339 config.text_read_only = TRUE;
340
341 emulation = get_emulation (argc, argv);
342 ldemul_choose_mode (emulation);
343 default_target = ldemul_choose_target (argc, argv);
344 lang_init ();
345 ldemul_before_parse ();
346 lang_has_input_file = FALSE;
347 parse_args (argc, argv);
348
349 ldemul_set_symbols ();
350
351 if (link_info.relocateable)
352 {
353 if (command_line.gc_sections)
354 einfo ("%P%F: --gc-sections and -r may not be used together\n");
355 if (link_info.mpc860c0)
356 einfo (_("%P%F: -r and --mpc860c0 may not be used together\n"));
357 else if (command_line.relax)
358 einfo (_("%P%F: --relax and -r may not be used together\n"));
359 if (link_info.shared)
360 einfo (_("%P%F: -r and -shared may not be used together\n"));
361 }
362
363 if (! link_info.shared)
364 {
365 if (command_line.filter_shlib)
366 einfo (_("%P%F: -F may not be used without -shared\n"));
367 if (command_line.auxiliary_filters)
368 einfo (_("%P%F: -f may not be used without -shared\n"));
369 }
370
371 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
372 don't see how else this can be handled, since in this case we
373 must preserve all externally visible symbols. */
374 if (link_info.relocateable && link_info.strip == strip_all)
375 {
376 link_info.strip = strip_debugger;
377 if (link_info.discard == discard_sec_merge)
378 link_info.discard = discard_all;
379 }
380
381 /* This essentially adds another -L directory so this must be done after
382 the -L's in argv have been processed. */
383 set_scripts_dir ();
384
385 /* If we have not already opened and parsed a linker script
386 read the emulation's appropriate default script. */
387 if (saved_script_handle == NULL)
388 {
389 int isfile;
390 char *s = ldemul_get_script (&isfile);
391
392 if (isfile)
393 ldfile_open_command_file (s);
394 else
395 {
396 lex_string = s;
397 lex_redirect (s);
398 }
399 parser_input = input_script;
400 yyparse ();
401 lex_string = NULL;
402 }
403
404 if (trace_file_tries)
405 {
406 if (saved_script_handle)
407 info_msg (_("using external linker script:"));
408 else
409 info_msg (_("using internal linker script:"));
410 info_msg ("\n==================================================\n");
411
412 if (saved_script_handle)
413 {
414 static const int ld_bufsz = 8193;
415 size_t n;
416 char *buf = xmalloc (ld_bufsz);
417
418 rewind (saved_script_handle);
419 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
420 {
421 buf[n] = 0;
422 info_msg (buf);
423 }
424 rewind (saved_script_handle);
425 free (buf);
426 }
427 else
428 {
429 int isfile;
430
431 info_msg (ldemul_get_script (&isfile));
432 }
433
434 info_msg ("\n==================================================\n");
435 }
436
437 lang_final ();
438
439 if (!lang_has_input_file)
440 {
441 if (version_printed)
442 xexit (0);
443 einfo (_("%P%F: no input files\n"));
444 }
445
446 if (trace_files)
447 info_msg (_("%P: mode %s\n"), emulation);
448
449 ldemul_after_parse ();
450
451 if (config.map_filename)
452 {
453 if (strcmp (config.map_filename, "-") == 0)
454 {
455 config.map_file = stdout;
456 }
457 else
458 {
459 config.map_file = fopen (config.map_filename, FOPEN_WT);
460 if (config.map_file == (FILE *) NULL)
461 {
462 bfd_set_error (bfd_error_system_call);
463 einfo (_("%P%F: cannot open map file %s: %E\n"),
464 config.map_filename);
465 }
466 }
467 }
468
469 lang_process ();
470
471 /* Print error messages for any missing symbols, for any warning
472 symbols, and possibly multiple definitions. */
473 if (link_info.relocateable)
474 output_bfd->flags &= ~EXEC_P;
475 else
476 output_bfd->flags |= EXEC_P;
477
478 ldwrite ();
479
480 if (config.map_file != NULL)
481 lang_map ();
482 if (command_line.cref)
483 output_cref (config.map_file != NULL ? config.map_file : stdout);
484 if (nocrossref_list != NULL)
485 check_nocrossrefs ();
486
487 /* Even if we're producing relocateable output, some non-fatal errors should
488 be reported in the exit status. (What non-fatal errors, if any, do we
489 want to ignore for relocateable output?) */
490 if (!config.make_executable && !force_make_executable)
491 {
492 if (trace_files)
493 einfo (_("%P: link errors found, deleting executable `%s'\n"),
494 output_filename);
495
496 /* The file will be removed by remove_output. */
497 xexit (1);
498 }
499 else
500 {
501 if (! bfd_close (output_bfd))
502 einfo (_("%F%B: final close failed: %E\n"), output_bfd);
503
504 /* If the --force-exe-suffix is enabled, and we're making an
505 executable file and it doesn't end in .exe, copy it to one
506 which does. */
507 if (! link_info.relocateable && command_line.force_exe_suffix)
508 {
509 int len = strlen (output_filename);
510
511 if (len < 4
512 || (strcasecmp (output_filename + len - 4, ".exe") != 0
513 && strcasecmp (output_filename + len - 4, ".dll") != 0))
514 {
515 FILE *src;
516 FILE *dst;
517 const int bsize = 4096;
518 char *buf = xmalloc (bsize);
519 int l;
520 char *dst_name = xmalloc (len + 5);
521
522 strcpy (dst_name, output_filename);
523 strcat (dst_name, ".exe");
524 src = fopen (output_filename, FOPEN_RB);
525 dst = fopen (dst_name, FOPEN_WB);
526
527 if (!src)
528 einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename);
529 if (!dst)
530 einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name);
531 while ((l = fread (buf, 1, bsize, src)) > 0)
532 {
533 int done = fwrite (buf, 1, l, dst);
534
535 if (done != l)
536 einfo (_("%P: Error writing file `%s'\n"), dst_name);
537 }
538
539 fclose (src);
540 if (fclose (dst) == EOF)
541 einfo (_("%P: Error closing file `%s'\n"), dst_name);
542 free (dst_name);
543 free (buf);
544 }
545 }
546 }
547
548 END_PROGRESS (program_name);
549
550 if (config.stats)
551 {
552 #ifdef HAVE_SBRK
553 char *lim = (char *) sbrk (0);
554 #endif
555 long run_time = get_run_time () - start_time;
556
557 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
558 program_name, run_time / 1000000, run_time % 1000000);
559 #ifdef HAVE_SBRK
560 fprintf (stderr, _("%s: data size %ld\n"), program_name,
561 (long) (lim - (char *) &environ));
562 #endif
563 }
564
565 /* Prevent remove_output from doing anything, after a successful link. */
566 output_filename = NULL;
567
568 xexit (0);
569 return 0;
570 }
571
572 /* We need to find any explicitly given emulation in order to initialize the
573 state that's needed by the lex&yacc argument parser (parse_args). */
574
575 static char *
576 get_emulation (argc, argv)
577 int argc;
578 char **argv;
579 {
580 char *emulation;
581 int i;
582
583 emulation = getenv (EMULATION_ENVIRON);
584 if (emulation == NULL)
585 emulation = DEFAULT_EMULATION;
586
587 for (i = 1; i < argc; i++)
588 {
589 if (!strncmp (argv[i], "-m", 2))
590 {
591 if (argv[i][2] == '\0')
592 {
593 /* -m EMUL */
594 if (i < argc - 1)
595 {
596 emulation = argv[i + 1];
597 i++;
598 }
599 else
600 einfo (_("%P%F: missing argument to -m\n"));
601 }
602 else if (strcmp (argv[i], "-mips1") == 0
603 || strcmp (argv[i], "-mips2") == 0
604 || strcmp (argv[i], "-mips3") == 0
605 || strcmp (argv[i], "-mips4") == 0
606 || strcmp (argv[i], "-mips5") == 0
607 || strcmp (argv[i], "-mips32") == 0
608 || strcmp (argv[i], "-mips32r2") == 0
609 || strcmp (argv[i], "-mips64") == 0)
610 {
611 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
612 passed to the linker by some MIPS compilers. They
613 generally tell the linker to use a slightly different
614 library path. Perhaps someday these should be
615 implemented as emulations; until then, we just ignore
616 the arguments and hope that nobody ever creates
617 emulations named ips1, ips2 or ips3. */
618 }
619 else if (strcmp (argv[i], "-m486") == 0)
620 {
621 /* FIXME: The argument -m486 is passed to the linker on
622 some Linux systems. Hope that nobody creates an
623 emulation named 486. */
624 }
625 else
626 {
627 /* -mEMUL */
628 emulation = &argv[i][2];
629 }
630 }
631 }
632
633 return emulation;
634 }
635
636 /* If directory DIR contains an "ldscripts" subdirectory,
637 add DIR to the library search path and return TRUE,
638 else return FALSE. */
639
640 static bfd_boolean
641 check_for_scripts_dir (dir)
642 char *dir;
643 {
644 size_t dirlen;
645 char *buf;
646 struct stat s;
647 bfd_boolean res;
648
649 dirlen = strlen (dir);
650 /* sizeof counts the terminating NUL. */
651 buf = (char *) xmalloc (dirlen + sizeof ("/ldscripts"));
652 sprintf (buf, "%s/ldscripts", dir);
653
654 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
655 free (buf);
656 if (res)
657 ldfile_add_library_path (dir, FALSE);
658 return res;
659 }
660
661 /* Set the default directory for finding script files.
662 Libraries will be searched for here too, but that's ok.
663 We look for the "ldscripts" directory in:
664
665 SCRIPTDIR (passed from Makefile)
666 (adjusted according to the current location of the binary)
667 SCRIPTDIR (passed from Makefile)
668 the dir where this program is (for using it from the build tree)
669 the dir where this program is/../lib
670 (for installing the tool suite elsewhere). */
671
672 static void
673 set_scripts_dir ()
674 {
675 char *end, *dir;
676 size_t dirlen;
677 bfd_boolean found;
678
679 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
680 if (dir)
681 {
682 found = check_for_scripts_dir (dir);
683 free (dir);
684 if (found)
685 return;
686 }
687
688 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
689 if (dir)
690 {
691 found = check_for_scripts_dir (dir);
692 free (dir);
693 if (found)
694 return;
695 }
696
697 if (check_for_scripts_dir (SCRIPTDIR))
698 /* We've been installed normally. */
699 return;
700
701 /* Look for "ldscripts" in the dir where our binary is. */
702 end = strrchr (program_name, '/');
703 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
704 {
705 /* We could have \foo\bar, or /foo\bar. */
706 char *bslash = strrchr (program_name, '\\');
707
708 if (end == NULL || (bslash != NULL && bslash > end))
709 end = bslash;
710 }
711 #endif
712
713 if (end == NULL)
714 /* Don't look for ldscripts in the current directory. There is
715 too much potential for confusion. */
716 return;
717
718 dirlen = end - program_name;
719 /* Make a copy of program_name in dir.
720 Leave room for later "/../lib". */
721 dir = (char *) xmalloc (dirlen + 8);
722 strncpy (dir, program_name, dirlen);
723 dir[dirlen] = '\0';
724
725 if (check_for_scripts_dir (dir))
726 {
727 free (dir);
728 return;
729 }
730
731 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
732 strcpy (dir + dirlen, "/../lib");
733 check_for_scripts_dir (dir);
734 free (dir);
735 }
736
737 void
738 add_ysym (name)
739 const char *name;
740 {
741 if (link_info.notice_hash == (struct bfd_hash_table *) NULL)
742 {
743 link_info.notice_hash = ((struct bfd_hash_table *)
744 xmalloc (sizeof (struct bfd_hash_table)));
745 if (! bfd_hash_table_init_n (link_info.notice_hash,
746 bfd_hash_newfunc,
747 61))
748 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
749 }
750
751 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE)
752 == (struct bfd_hash_entry *) NULL)
753 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
754 }
755
756 /* Record a symbol to be wrapped, from the --wrap option. */
757
758 void
759 add_wrap (name)
760 const char *name;
761 {
762 if (link_info.wrap_hash == NULL)
763 {
764 link_info.wrap_hash = ((struct bfd_hash_table *)
765 xmalloc (sizeof (struct bfd_hash_table)));
766 if (! bfd_hash_table_init_n (link_info.wrap_hash,
767 bfd_hash_newfunc,
768 61))
769 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
770 }
771
772 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
773 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
774 }
775
776 /* Handle the -retain-symbols-file option. */
777
778 void
779 add_keepsyms_file (filename)
780 const char *filename;
781 {
782 FILE *file;
783 char *buf;
784 size_t bufsize;
785 int c;
786
787 if (link_info.strip == strip_some)
788 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
789
790 file = fopen (filename, "r");
791 if (file == (FILE *) NULL)
792 {
793 bfd_set_error (bfd_error_system_call);
794 einfo ("%X%P: %s: %E\n", filename);
795 return;
796 }
797
798 link_info.keep_hash = ((struct bfd_hash_table *)
799 xmalloc (sizeof (struct bfd_hash_table)));
800 if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc))
801 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
802
803 bufsize = 100;
804 buf = (char *) xmalloc (bufsize);
805
806 c = getc (file);
807 while (c != EOF)
808 {
809 while (ISSPACE (c))
810 c = getc (file);
811
812 if (c != EOF)
813 {
814 size_t len = 0;
815
816 while (! ISSPACE (c) && c != EOF)
817 {
818 buf[len] = c;
819 ++len;
820 if (len >= bufsize)
821 {
822 bufsize *= 2;
823 buf = xrealloc (buf, bufsize);
824 }
825 c = getc (file);
826 }
827
828 buf[len] = '\0';
829
830 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE)
831 == (struct bfd_hash_entry *) NULL)
832 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
833 }
834 }
835
836 if (link_info.strip != strip_none)
837 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
838
839 free (buf);
840 link_info.strip = strip_some;
841 }
842 \f
843 /* Callbacks from the BFD linker routines. */
844
845 /* This is called when BFD has decided to include an archive member in
846 a link. */
847
848 static bfd_boolean
849 add_archive_element (info, abfd, name)
850 struct bfd_link_info *info ATTRIBUTE_UNUSED;
851 bfd *abfd;
852 const char *name;
853 {
854 lang_input_statement_type *input;
855
856 input = ((lang_input_statement_type *)
857 xmalloc (sizeof (lang_input_statement_type)));
858 input->filename = abfd->filename;
859 input->local_sym_name = abfd->filename;
860 input->the_bfd = abfd;
861 input->asymbols = NULL;
862 input->next = NULL;
863 input->just_syms_flag = FALSE;
864 input->loaded = FALSE;
865 input->search_dirs_flag = FALSE;
866
867 /* FIXME: The following fields are not set: header.next,
868 header.type, closed, passive_position, symbol_count,
869 next_real_file, is_archive, target, real. This bit of code is
870 from the old decode_library_subfile function. I don't know
871 whether any of those fields matters. */
872
873 ldlang_add_file (input);
874
875 if (config.map_file != (FILE *) NULL)
876 {
877 static bfd_boolean header_printed;
878 struct bfd_link_hash_entry *h;
879 bfd *from;
880 int len;
881
882 h = bfd_link_hash_lookup (link_info.hash, name, FALSE, FALSE, TRUE);
883
884 if (h == NULL)
885 from = NULL;
886 else
887 {
888 switch (h->type)
889 {
890 default:
891 from = NULL;
892 break;
893
894 case bfd_link_hash_defined:
895 case bfd_link_hash_defweak:
896 from = h->u.def.section->owner;
897 break;
898
899 case bfd_link_hash_undefined:
900 case bfd_link_hash_undefweak:
901 from = h->u.undef.abfd;
902 break;
903
904 case bfd_link_hash_common:
905 from = h->u.c.p->section->owner;
906 break;
907 }
908 }
909
910 if (! header_printed)
911 {
912 char buf[100];
913
914 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
915 minfo ("%s", buf);
916 header_printed = TRUE;
917 }
918
919 if (bfd_my_archive (abfd) == NULL)
920 {
921 minfo ("%s", bfd_get_filename (abfd));
922 len = strlen (bfd_get_filename (abfd));
923 }
924 else
925 {
926 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
927 bfd_get_filename (abfd));
928 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
929 + strlen (bfd_get_filename (abfd))
930 + 2);
931 }
932
933 if (len >= 29)
934 {
935 print_nl ();
936 len = 0;
937 }
938 while (len < 30)
939 {
940 print_space ();
941 ++len;
942 }
943
944 if (from != NULL)
945 minfo ("%B ", from);
946 if (h != NULL)
947 minfo ("(%T)\n", h->root.string);
948 else
949 minfo ("(%s)\n", name);
950 }
951
952 if (trace_files || trace_file_tries)
953 info_msg ("%I\n", input);
954
955 return TRUE;
956 }
957
958 /* This is called when BFD has discovered a symbol which is defined
959 multiple times. */
960
961 static bfd_boolean
962 multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
963 struct bfd_link_info *info ATTRIBUTE_UNUSED;
964 const char *name;
965 bfd *obfd;
966 asection *osec;
967 bfd_vma oval;
968 bfd *nbfd;
969 asection *nsec;
970 bfd_vma nval;
971 {
972 /* If either section has the output_section field set to
973 bfd_abs_section_ptr, it means that the section is being
974 discarded, and this is not really a multiple definition at all.
975 FIXME: It would be cleaner to somehow ignore symbols defined in
976 sections which are being discarded. */
977 if ((osec->output_section != NULL
978 && ! bfd_is_abs_section (osec)
979 && bfd_is_abs_section (osec->output_section))
980 || (nsec->output_section != NULL
981 && ! bfd_is_abs_section (nsec)
982 && bfd_is_abs_section (nsec->output_section)))
983 return TRUE;
984
985 einfo (_("%X%C: multiple definition of `%T'\n"),
986 nbfd, nsec, nval, name);
987 if (obfd != (bfd *) NULL)
988 einfo (_("%D: first defined here\n"), obfd, osec, oval);
989
990 if (command_line.relax)
991 {
992 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
993 command_line.relax = 0;
994 }
995
996 return TRUE;
997 }
998
999 /* This is called when there is a definition of a common symbol, or
1000 when a common symbol is found for a symbol that is already defined,
1001 or when two common symbols are found. We only do something if
1002 -warn-common was used. */
1003
1004 static bfd_boolean
1005 multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize)
1006 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1007 const char *name;
1008 bfd *obfd;
1009 enum bfd_link_hash_type otype;
1010 bfd_vma osize;
1011 bfd *nbfd;
1012 enum bfd_link_hash_type ntype;
1013 bfd_vma nsize;
1014 {
1015 if (! config.warn_common)
1016 return TRUE;
1017
1018 if (ntype == bfd_link_hash_defined
1019 || ntype == bfd_link_hash_defweak
1020 || ntype == bfd_link_hash_indirect)
1021 {
1022 ASSERT (otype == bfd_link_hash_common);
1023 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1024 nbfd, name);
1025 if (obfd != NULL)
1026 einfo (_("%B: warning: common is here\n"), obfd);
1027 }
1028 else if (otype == bfd_link_hash_defined
1029 || otype == bfd_link_hash_defweak
1030 || otype == bfd_link_hash_indirect)
1031 {
1032 ASSERT (ntype == bfd_link_hash_common);
1033 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1034 nbfd, name);
1035 if (obfd != NULL)
1036 einfo (_("%B: warning: defined here\n"), obfd);
1037 }
1038 else
1039 {
1040 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1041 if (osize > nsize)
1042 {
1043 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1044 nbfd, name);
1045 if (obfd != NULL)
1046 einfo (_("%B: warning: larger common is here\n"), obfd);
1047 }
1048 else if (nsize > osize)
1049 {
1050 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1051 nbfd, name);
1052 if (obfd != NULL)
1053 einfo (_("%B: warning: smaller common is here\n"), obfd);
1054 }
1055 else
1056 {
1057 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1058 if (obfd != NULL)
1059 einfo (_("%B: warning: previous common is here\n"), obfd);
1060 }
1061 }
1062
1063 return TRUE;
1064 }
1065
1066 /* This is called when BFD has discovered a set element. H is the
1067 entry in the linker hash table for the set. SECTION and VALUE
1068 represent a value which should be added to the set. */
1069
1070 static bfd_boolean
1071 add_to_set (info, h, reloc, abfd, section, value)
1072 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1073 struct bfd_link_hash_entry *h;
1074 bfd_reloc_code_real_type reloc;
1075 bfd *abfd;
1076 asection *section;
1077 bfd_vma value;
1078 {
1079 if (config.warn_constructors)
1080 einfo (_("%P: warning: global constructor %s used\n"),
1081 h->root.string);
1082
1083 if (! config.build_constructors)
1084 return TRUE;
1085
1086 ldctor_add_set_entry (h, reloc, (const char *) NULL, section, value);
1087
1088 if (h->type == bfd_link_hash_new)
1089 {
1090 h->type = bfd_link_hash_undefined;
1091 h->u.undef.abfd = abfd;
1092 /* We don't call bfd_link_add_undef to add this to the list of
1093 undefined symbols because we are going to define it
1094 ourselves. */
1095 }
1096
1097 return TRUE;
1098 }
1099
1100 /* This is called when BFD has discovered a constructor. This is only
1101 called for some object file formats--those which do not handle
1102 constructors in some more clever fashion. This is similar to
1103 adding an element to a set, but less general. */
1104
1105 static bfd_boolean
1106 constructor_callback (info, constructor, name, abfd, section, value)
1107 struct bfd_link_info *info;
1108 bfd_boolean constructor;
1109 const char *name;
1110 bfd *abfd;
1111 asection *section;
1112 bfd_vma value;
1113 {
1114 char *s;
1115 struct bfd_link_hash_entry *h;
1116 char set_name[1 + sizeof "__CTOR_LIST__"];
1117
1118 if (config.warn_constructors)
1119 einfo (_("%P: warning: global constructor %s used\n"), name);
1120
1121 if (! config.build_constructors)
1122 return TRUE;
1123
1124 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1125 useful error message. */
1126 if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL
1127 && (link_info.relocateable
1128 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1129 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1130
1131 s = set_name;
1132 if (bfd_get_symbol_leading_char (abfd) != '\0')
1133 *s++ = bfd_get_symbol_leading_char (abfd);
1134 if (constructor)
1135 strcpy (s, "__CTOR_LIST__");
1136 else
1137 strcpy (s, "__DTOR_LIST__");
1138
1139 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1140 if (h == (struct bfd_link_hash_entry *) NULL)
1141 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1142 if (h->type == bfd_link_hash_new)
1143 {
1144 h->type = bfd_link_hash_undefined;
1145 h->u.undef.abfd = abfd;
1146 /* We don't call bfd_link_add_undef to add this to the list of
1147 undefined symbols because we are going to define it
1148 ourselves. */
1149 }
1150
1151 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1152 return TRUE;
1153 }
1154
1155 /* A structure used by warning_callback to pass information through
1156 bfd_map_over_sections. */
1157
1158 struct warning_callback_info
1159 {
1160 bfd_boolean found;
1161 const char *warning;
1162 const char *symbol;
1163 asymbol **asymbols;
1164 };
1165
1166 /* This is called when there is a reference to a warning symbol. */
1167
1168 static bfd_boolean
1169 warning_callback (info, warning, symbol, abfd, section, address)
1170 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1171 const char *warning;
1172 const char *symbol;
1173 bfd *abfd;
1174 asection *section;
1175 bfd_vma address;
1176 {
1177 /* This is a hack to support warn_multiple_gp. FIXME: This should
1178 have a cleaner interface, but what? */
1179 if (! config.warn_multiple_gp
1180 && strcmp (warning, "using multiple gp values") == 0)
1181 return TRUE;
1182
1183 if (section != NULL)
1184 einfo ("%C: %s\n", abfd, section, address, warning);
1185 else if (abfd == NULL)
1186 einfo ("%P: %s\n", warning);
1187 else if (symbol == NULL)
1188 einfo ("%B: %s\n", abfd, warning);
1189 else
1190 {
1191 lang_input_statement_type *entry;
1192 asymbol **asymbols;
1193 struct warning_callback_info info;
1194
1195 /* Look through the relocs to see if we can find a plausible
1196 address. */
1197 entry = (lang_input_statement_type *) abfd->usrdata;
1198 if (entry != NULL && entry->asymbols != NULL)
1199 asymbols = entry->asymbols;
1200 else
1201 {
1202 long symsize;
1203 long symbol_count;
1204
1205 symsize = bfd_get_symtab_upper_bound (abfd);
1206 if (symsize < 0)
1207 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1208 asymbols = (asymbol **) xmalloc (symsize);
1209 symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
1210 if (symbol_count < 0)
1211 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1212 if (entry != NULL)
1213 {
1214 entry->asymbols = asymbols;
1215 entry->symbol_count = symbol_count;
1216 }
1217 }
1218
1219 info.found = FALSE;
1220 info.warning = warning;
1221 info.symbol = symbol;
1222 info.asymbols = asymbols;
1223 bfd_map_over_sections (abfd, warning_find_reloc, (PTR) &info);
1224
1225 if (! info.found)
1226 einfo ("%B: %s\n", abfd, warning);
1227
1228 if (entry == NULL)
1229 free (asymbols);
1230 }
1231
1232 return TRUE;
1233 }
1234
1235 /* This is called by warning_callback for each section. It checks the
1236 relocs of the section to see if it can find a reference to the
1237 symbol which triggered the warning. If it can, it uses the reloc
1238 to give an error message with a file and line number. */
1239
1240 static void
1241 warning_find_reloc (abfd, sec, iarg)
1242 bfd *abfd;
1243 asection *sec;
1244 PTR iarg;
1245 {
1246 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1247 long relsize;
1248 arelent **relpp;
1249 long relcount;
1250 arelent **p, **pend;
1251
1252 if (info->found)
1253 return;
1254
1255 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1256 if (relsize < 0)
1257 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1258 if (relsize == 0)
1259 return;
1260
1261 relpp = (arelent **) xmalloc (relsize);
1262 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1263 if (relcount < 0)
1264 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1265
1266 p = relpp;
1267 pend = p + relcount;
1268 for (; p < pend && *p != NULL; p++)
1269 {
1270 arelent *q = *p;
1271
1272 if (q->sym_ptr_ptr != NULL
1273 && *q->sym_ptr_ptr != NULL
1274 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1275 {
1276 /* We found a reloc for the symbol we are looking for. */
1277 einfo ("%C: %s\n", abfd, sec, q->address, info->warning);
1278 info->found = TRUE;
1279 break;
1280 }
1281 }
1282
1283 free (relpp);
1284 }
1285
1286 /* This is called when an undefined symbol is found. */
1287
1288 static bfd_boolean
1289 undefined_symbol (info, name, abfd, section, address, fatal)
1290 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1291 const char *name;
1292 bfd *abfd;
1293 asection *section;
1294 bfd_vma address;
1295 bfd_boolean fatal ATTRIBUTE_UNUSED;
1296 {
1297 static char *error_name;
1298 static unsigned int error_count;
1299
1300 #define MAX_ERRORS_IN_A_ROW 5
1301
1302 if (config.warn_once)
1303 {
1304 static struct bfd_hash_table *hash;
1305
1306 /* Only warn once about a particular undefined symbol. */
1307 if (hash == NULL)
1308 {
1309 hash = ((struct bfd_hash_table *)
1310 xmalloc (sizeof (struct bfd_hash_table)));
1311 if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
1312 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1313 }
1314
1315 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1316 return TRUE;
1317
1318 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1319 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1320 }
1321
1322 /* We never print more than a reasonable number of errors in a row
1323 for a single symbol. */
1324 if (error_name != (char *) NULL
1325 && strcmp (name, error_name) == 0)
1326 ++error_count;
1327 else
1328 {
1329 error_count = 0;
1330 if (error_name != (char *) NULL)
1331 free (error_name);
1332 error_name = xstrdup (name);
1333 }
1334
1335 if (section != NULL)
1336 {
1337 if (error_count < MAX_ERRORS_IN_A_ROW)
1338 {
1339 einfo (_("%C: undefined reference to `%T'\n"),
1340 abfd, section, address, name);
1341 if (fatal)
1342 einfo ("%X");
1343 }
1344 else if (error_count == MAX_ERRORS_IN_A_ROW)
1345 einfo (_("%D: more undefined references to `%T' follow\n"),
1346 abfd, section, address, name);
1347 }
1348 else
1349 {
1350 if (error_count < MAX_ERRORS_IN_A_ROW)
1351 {
1352 einfo (_("%B: undefined reference to `%T'\n"),
1353 abfd, name);
1354 if (fatal)
1355 einfo ("%X");
1356 }
1357 else if (error_count == MAX_ERRORS_IN_A_ROW)
1358 einfo (_("%B: more undefined references to `%T' follow\n"),
1359 abfd, name);
1360 }
1361
1362 return TRUE;
1363 }
1364
1365 /* This is called when a reloc overflows. */
1366
1367 static bfd_boolean
1368 reloc_overflow (info, name, reloc_name, addend, abfd, section, address)
1369 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1370 const char *name;
1371 const char *reloc_name;
1372 bfd_vma addend;
1373 bfd *abfd;
1374 asection *section;
1375 bfd_vma address;
1376 {
1377 if (abfd == (bfd *) NULL)
1378 einfo (_("%P%X: generated"));
1379 else
1380 einfo ("%X%C:", abfd, section, address);
1381 einfo (_(" relocation truncated to fit: %s %T"), reloc_name, name);
1382 if (addend != 0)
1383 einfo ("+%v", addend);
1384 einfo ("\n");
1385 return TRUE;
1386 }
1387
1388 /* This is called when a dangerous relocation is made. */
1389
1390 static bfd_boolean
1391 reloc_dangerous (info, message, abfd, section, address)
1392 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1393 const char *message;
1394 bfd *abfd;
1395 asection *section;
1396 bfd_vma address;
1397 {
1398 if (abfd == (bfd *) NULL)
1399 einfo (_("%P%X: generated"));
1400 else
1401 einfo ("%X%C:", abfd, section, address);
1402 einfo (_("dangerous relocation: %s\n"), message);
1403 return TRUE;
1404 }
1405
1406 /* This is called when a reloc is being generated attached to a symbol
1407 that is not being output. */
1408
1409 static bfd_boolean
1410 unattached_reloc (info, name, abfd, section, address)
1411 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1412 const char *name;
1413 bfd *abfd;
1414 asection *section;
1415 bfd_vma address;
1416 {
1417 if (abfd == (bfd *) NULL)
1418 einfo (_("%P%X: generated"));
1419 else
1420 einfo ("%X%C:", abfd, section, address);
1421 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name);
1422 return TRUE;
1423 }
1424
1425 /* This is called if link_info.notice_all is set, or when a symbol in
1426 link_info.notice_hash is found. Symbols are put in notice_hash
1427 using the -y option. */
1428
1429 static bfd_boolean
1430 notice (info, name, abfd, section, value)
1431 struct bfd_link_info *info;
1432 const char *name;
1433 bfd *abfd;
1434 asection *section;
1435 bfd_vma value;
1436 {
1437 if (! info->notice_all
1438 || (info->notice_hash != NULL
1439 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1440 {
1441 if (bfd_is_und_section (section))
1442 einfo ("%B: reference to %s\n", abfd, name);
1443 else
1444 einfo ("%B: definition of %s\n", abfd, name);
1445 }
1446
1447 if (command_line.cref || nocrossref_list != NULL)
1448 add_cref (name, abfd, section, value);
1449
1450 return TRUE;
1451 }
This page took 0.073215 seconds and 5 git commands to generate.