]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - ld/ldmain.c
Move struc-symbol.h to symbols.c
[thirdparty/binutils-gdb.git] / ld / ldmain.c
CommitLineData
252b5132 1/* Main program of GNU linker.
219d1afa 2 Copyright (C) 1991-2018 Free Software Foundation, Inc.
252b5132
RH
3 Written by Steve Chamberlain steve@cygnus.com
4
f96b4a7b 5 This file is part of the GNU Binutils.
252b5132 6
f96b4a7b 7 This program is free software; you can redistribute it and/or modify
2fa9fc65 8 it under the terms of the GNU General Public License as published by
f96b4a7b
NC
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
252b5132 11
f96b4a7b 12 This program is distributed in the hope that it will be useful,
2fa9fc65
NC
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.
252b5132 16
2fa9fc65 17 You should have received a copy of the GNU General Public License
f96b4a7b
NC
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. */
252b5132 21
252b5132 22#include "sysdep.h"
3db64b00 23#include "bfd.h"
3882b010 24#include "safe-ctype.h"
252b5132
RH
25#include "libiberty.h"
26#include "progress.h"
27#include "bfdlink.h"
5af11cab 28#include "filenames.h"
252b5132
RH
29
30#include "ld.h"
31#include "ldmain.h"
32#include "ldmisc.h"
33#include "ldwrite.h"
252b5132
RH
34#include "ldexp.h"
35#include "ldlang.h"
df2a7313 36#include <ldgram.h>
252b5132
RH
37#include "ldlex.h"
38#include "ldfile.h"
b71e2778 39#include "ldemul.h"
252b5132 40#include "ldctor.h"
5d3236ee
DK
41#ifdef ENABLE_PLUGINS
42#include "plugin.h"
43#include "plugin-api.h"
5d3236ee 44#endif /* ENABLE_PLUGINS */
252b5132 45
0125cdf2 46/* Somewhere above, sys/stat.h got included. */
252b5132
RH
47#if !defined(S_ISDIR) && defined(S_IFDIR)
48#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
49#endif
50
51#include <string.h>
52
9c8ebd6a
DJ
53#ifndef TARGET_SYSTEM_ROOT
54#define TARGET_SYSTEM_ROOT ""
55#endif
56
252b5132
RH
57/* EXPORTS */
58
53d25da6
AM
59FILE *saved_script_handle = NULL;
60FILE *previous_script_handle = NULL;
61bfd_boolean force_make_executable = FALSE;
62
252b5132
RH
63char *default_target;
64const char *output_filename = "a.out";
65
66/* Name this program was invoked by. */
67char *program_name;
68
9c8ebd6a 69/* The prefix for system library directories. */
e2243057 70const char *ld_sysroot;
9c8ebd6a 71
3fe38064 72/* The canonical representation of ld_sysroot. */
0aa7f586 73char *ld_canon_sysroot;
3fe38064
NC
74int ld_canon_sysroot_len;
75
e8044f35 76/* Set by -G argument, for targets like MIPS ELF. */
252b5132
RH
77int g_switch_value = 8;
78
79/* Nonzero means print names of input files as processed. */
b34976b6 80bfd_boolean trace_files;
252b5132 81
cd6f1cf3
NC
82/* Nonzero means report actions taken by the linker, and describe the linker script in use. */
83bfd_boolean verbose;
252b5132
RH
84
85/* Nonzero means version number was printed, so exit successfully
86 instead of complaining if no input files are given. */
b34976b6 87bfd_boolean version_printed;
252b5132 88
b34976b6
AM
89/* TRUE if we should demangle symbol names. */
90bfd_boolean demangling;
252b5132
RH
91
92args_type command_line;
93
94ld_config_type config;
95
bcaa7b3e
L
96sort_type sort_section;
97
e2243057
RS
98static const char *get_sysroot
99 (int, char **);
0125cdf2 100static char *get_emulation
1579bae1 101 (int, char **);
0125cdf2 102static bfd_boolean add_archive_element
5d3236ee 103 (struct bfd_link_info *, bfd *, const char *, bfd **);
1a72702b 104static void multiple_definition
24f58f47 105 (struct bfd_link_info *, struct bfd_link_hash_entry *,
1579bae1 106 bfd *, asection *, bfd_vma);
1a72702b 107static void multiple_common
24f58f47
AM
108 (struct bfd_link_info *, struct bfd_link_hash_entry *,
109 bfd *, enum bfd_link_hash_type, bfd_vma);
1a72702b 110static void add_to_set
1579bae1
AM
111 (struct bfd_link_info *, struct bfd_link_hash_entry *,
112 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
1a72702b 113static void constructor_callback
1579bae1
AM
114 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
115 asection *, bfd_vma);
1a72702b 116static void warning_callback
1579bae1
AM
117 (struct bfd_link_info *, const char *, const char *, bfd *,
118 asection *, bfd_vma);
0125cdf2 119static void warning_find_reloc
1579bae1 120 (bfd *, asection *, void *);
1a72702b 121static void undefined_symbol
1579bae1
AM
122 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
123 bfd_boolean);
1a72702b 124static void reloc_overflow
dfeffb9f
L
125 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
126 const char *, bfd_vma, bfd *, asection *, bfd_vma);
1a72702b 127static void reloc_dangerous
1579bae1 128 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
1a72702b 129static void unattached_reloc
1579bae1 130 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
0125cdf2 131static bfd_boolean notice
35ed3f94 132 (struct bfd_link_info *, struct bfd_link_hash_entry *,
46135103 133 struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
0125cdf2
NC
134
135static struct bfd_link_callbacks link_callbacks =
136{
252b5132
RH
137 add_archive_element,
138 multiple_definition,
139 multiple_common,
140 add_to_set,
141 constructor_callback,
142 warning_callback,
143 undefined_symbol,
144 reloc_overflow,
145 reloc_dangerous,
146 unattached_reloc,
e1fffbe6 147 notice,
2889e75b 148 einfo,
49fa1e15
AM
149 info_msg,
150 minfo,
2889e75b 151 ldlang_override_segment_assignment
252b5132
RH
152};
153
3b66a141 154static bfd_assert_handler_type default_bfd_assert_handler;
4519d071 155static bfd_error_handler_type default_bfd_error_handler;
3b66a141 156
252b5132
RH
157struct bfd_link_info link_info;
158\f
159static void
498cd2a0 160ld_cleanup (void)
252b5132 161{
498cd2a0
AM
162 bfd_cache_close_all ();
163#ifdef ENABLE_PLUGINS
164 plugin_call_cleanup ();
165#endif
166 if (output_filename && delete_output_file_on_failure)
167 unlink_if_ordinary (output_filename);
252b5132
RH
168}
169
4519d071 170/* Hook to notice BFD assertions. */
3b66a141
HPN
171
172static void
173ld_bfd_assert_handler (const char *fmt, const char *bfdver,
174 const char *file, int line)
175{
3b66a141 176 config.make_executable = FALSE;
4519d071
AM
177 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
178}
179
180/* Hook the bfd error/warning handler for --fatal-warnings. */
181
182static void
183ld_bfd_error_handler (const char *fmt, va_list ap)
184{
185 if (config.fatal_warnings)
186 config.make_executable = FALSE;
187 (*default_bfd_error_handler) (fmt, ap);
3b66a141
HPN
188}
189
252b5132 190int
1579bae1 191main (int argc, char **argv)
252b5132
RH
192{
193 char *emulation;
194 long start_time = get_run_time ();
195
196#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
197 setlocale (LC_MESSAGES, "");
3882b010
L
198#endif
199#if defined (HAVE_SETLOCALE)
200 setlocale (LC_CTYPE, "");
252b5132
RH
201#endif
202 bindtextdomain (PACKAGE, LOCALEDIR);
203 textdomain (PACKAGE);
204
205 program_name = argv[0];
206 xmalloc_set_program_name (program_name);
207
208 START_PROGRESS (program_name, 0);
209
869b9d07
MM
210 expandargv (&argc, &argv);
211
bf2dd8d7
AM
212 if (bfd_init () != BFD_INIT_MAGIC)
213 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
252b5132
RH
214
215 bfd_set_error_program_name (program_name);
216
3b66a141
HPN
217 /* We want to notice and fail on those nasty BFD assertions which are
218 likely to signal incorrect output being generated but otherwise may
219 leave no trace. */
220 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
221
4519d071
AM
222 /* Also hook the bfd error/warning handler for --fatal-warnings. */
223 default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);
224
498cd2a0 225 xatexit (ld_cleanup);
252b5132 226
e2243057
RS
227 /* Set up the sysroot directory. */
228 ld_sysroot = get_sysroot (argc, argv);
229 if (*ld_sysroot)
3074964f 230 ld_canon_sysroot = lrealpath (ld_sysroot);
3fe38064 231 if (ld_canon_sysroot)
889be5db
DR
232 {
233 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
234
235 /* is_sysrooted_pathname() relies on no trailing dirsep. */
236 if (ld_canon_sysroot_len > 0
237 && IS_DIR_SEPARATOR (ld_canon_sysroot [ld_canon_sysroot_len - 1]))
238 ld_canon_sysroot [--ld_canon_sysroot_len] = '\0';
239 }
3fe38064
NC
240 else
241 ld_canon_sysroot_len = -1;
242
252b5132
RH
243 /* Set the default BFD target based on the configured target. Doing
244 this permits the linker to be configured for a particular target,
245 and linked against a shared BFD library which was configured for
246 a different target. The macro TARGET is defined by Makefile. */
0aa7f586 247 if (!bfd_set_default_target (TARGET))
252b5132
RH
248 {
249 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
250 xexit (1);
251 }
252
b47c4208
AM
253#if YYDEBUG
254 {
255 extern int yydebug;
256 yydebug = 1;
257 }
258#endif
259
b34976b6 260 config.build_constructors = TRUE;
c76308d2 261 config.rpath_separator = ':';
a854a4a7
AM
262 config.split_by_reloc = (unsigned) -1;
263 config.split_by_file = (bfd_size_type) -1;
3b95049e
AM
264 config.make_executable = TRUE;
265 config.magic_demand_paged = TRUE;
266 config.text_read_only = TRUE;
4f9d22a0 267 link_info.disable_target_specific_optimizations = -1;
3b95049e 268
b34976b6 269 command_line.warn_mismatch = TRUE;
fe7929ce 270 command_line.warn_search_mismatch = TRUE;
02b0b1aa 271 command_line.check_section_addresses = -1;
bcaa7b3e 272
252b5132
RH
273 /* We initialize DEMANGLING based on the environment variable
274 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
275 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
276 environment. Acting the same way here lets us provide the same
277 interface by default. */
278 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
279
b34976b6 280 link_info.allow_undefined_version = TRUE;
b5067602 281 link_info.keep_memory = TRUE;
b5067602 282 link_info.combreloc = TRUE;
d5cd3933 283 link_info.strip_discarded = TRUE;
3f0a5f17 284 link_info.prohibit_multiple_definition_absolute = FALSE;
2760f24c
RG
285 link_info.emit_hash = DEFAULT_EMIT_SYSV_HASH;
286 link_info.emit_gnu_hash = DEFAULT_EMIT_GNU_HASH;
a9a4c53e
AM
287 link_info.callbacks = &link_callbacks;
288 link_info.input_bfds_tail = &link_info.input_bfds;
3dbf70a2
MM
289 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
290 and _fini symbols. We are compatible. */
291 link_info.init_function = "_init";
292 link_info.fini_function = "_fini";
a9a4c53e 293 link_info.relax_pass = 1;
889c2a67 294 link_info.extern_protected_data = -1;
aec6b87e 295 link_info.dynamic_undefined_weak = -1;
e0076ab3 296 link_info.pei386_auto_import = -1;
db6751f2 297 link_info.spare_dynamic_tags = 5;
967928e9 298 link_info.path_separator = ':';
6c3bc0f8
NC
299#ifdef DEFAULT_FLAG_COMPRESS_DEBUG
300 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
301#endif
6734f10a 302#ifdef DEFAULT_NEW_DTAGS
91001320 303 link_info.new_dtags = DEFAULT_NEW_DTAGS;
6734f10a 304#endif
24718e3b 305
252b5132 306 ldfile_add_arch ("");
252b5132
RH
307 emulation = get_emulation (argc, argv);
308 ldemul_choose_mode (emulation);
742aeb63 309 default_target = ldemul_choose_target (argc, argv);
252b5132 310 lang_init ();
18d6a79d 311 ldexp_init ();
252b5132 312 ldemul_before_parse ();
b34976b6 313 lang_has_input_file = FALSE;
252b5132
RH
314 parse_args (argc, argv);
315
2d643429
NC
316 if (config.hash_table_size != 0)
317 bfd_hash_set_default_size (config.hash_table_size);
318
9bbc1a67
AM
319#ifdef ENABLE_PLUGINS
320 /* Now all the plugin arguments have been gathered, we can load them. */
d82184d7 321 plugin_load_plugins ();
9bbc1a67 322#endif /* ENABLE_PLUGINS */
36af4a4e 323
9bbc1a67 324 ldemul_set_symbols ();
252b5132 325
14be8564
L
326 /* If we have not already opened and parsed a linker script,
327 try the default script from command line first. */
328 if (saved_script_handle == NULL
329 && command_line.default_script != NULL)
330 {
331 ldfile_open_command_file (command_line.default_script);
332 parser_input = input_script;
333 yyparse ();
334 }
335
b9a8de1e
NC
336 /* If we have not already opened and parsed a linker script
337 read the emulation's appropriate default script. */
b90e1c6f 338 if (saved_script_handle == NULL)
252b5132 339 {
252b5132 340 int isfile;
b7a26f91 341 char *s = ldemul_get_script (&isfile);
252b5132
RH
342
343 if (isfile)
7d24f02c 344 ldfile_open_default_command_file (s);
252b5132 345 else
b7a26f91 346 {
252b5132 347 lex_string = s;
dab69f68 348 lex_redirect (s, _("built in linker script"), 1);
252b5132
RH
349 }
350 parser_input = input_script;
351 yyparse ();
352 lex_string = NULL;
353 }
354
cd6f1cf3 355 if (verbose)
b9a8de1e 356 {
9cb61eab
AM
357 if (saved_script_handle)
358 info_msg (_("using external linker script:"));
359 else
360 info_msg (_("using internal linker script:"));
361 info_msg ("\n==================================================\n");
b9a8de1e
NC
362
363 if (saved_script_handle)
364 {
74699268 365 static const int ld_bufsz = 8193;
b9a8de1e 366 size_t n;
1e9cc1c2 367 char *buf = (char *) xmalloc (ld_bufsz);
b9a8de1e
NC
368
369 rewind (saved_script_handle);
74699268 370 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
b9a8de1e 371 {
b7a26f91 372 buf[n] = 0;
f5ac6ab3 373 info_msg ("%s", buf);
b9a8de1e
NC
374 }
375 rewind (saved_script_handle);
376 free (buf);
377 }
378 else
379 {
380 int isfile;
381
b7a26f91 382 info_msg (ldemul_get_script (&isfile));
b9a8de1e 383 }
b7a26f91 384
b9a8de1e
NC
385 info_msg ("\n==================================================\n");
386 }
387
7bdf4127
AB
388 if (command_line.force_group_allocation
389 || !bfd_link_relocatable (&link_info))
390 link_info.resolve_section_groups = TRUE;
391 else
392 link_info.resolve_section_groups = FALSE;
393
30824704
RM
394 if (command_line.print_output_format)
395 info_msg ("%s\n", lang_get_output_target ());
396
252b5132
RH
397 lang_final ();
398
61e2488c
JT
399 /* If the only command line argument has been -v or --version or --verbose
400 then ignore any input files provided by linker scripts and exit now.
401 We do not want to create an output file when the linker is just invoked
402 to provide version information. */
403 if (argc == 2 && version_printed)
404 xexit (0);
405
a4819f54 406 if (link_info.inhibit_common_definition && !bfd_link_dll (&link_info))
df5f2391 407 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
a4819f54 408
b34976b6 409 if (!lang_has_input_file)
252b5132 410 {
30824704 411 if (version_printed || command_line.print_output_format)
252b5132 412 xexit (0);
df5f2391 413 einfo (_("%F%P: no input files\n"));
252b5132
RH
414 }
415
416 if (trace_files)
0125cdf2 417 info_msg (_("%P: mode %s\n"), emulation);
252b5132
RH
418
419 ldemul_after_parse ();
420
252b5132
RH
421 if (config.map_filename)
422 {
423 if (strcmp (config.map_filename, "-") == 0)
424 {
425 config.map_file = stdout;
426 }
427 else
428 {
429 config.map_file = fopen (config.map_filename, FOPEN_WT);
430 if (config.map_file == (FILE *) NULL)
431 {
432 bfd_set_error (bfd_error_system_call);
df5f2391 433 einfo (_("%F%P: cannot open map file %s: %E\n"),
252b5132
RH
434 config.map_filename);
435 }
436 }
437 }
438
252b5132
RH
439 lang_process ();
440
441 /* Print error messages for any missing symbols, for any warning
6d5e62f8 442 symbols, and possibly multiple definitions. */
0e1862bb 443 if (bfd_link_relocatable (&link_info))
f13a99db 444 link_info.output_bfd->flags &= ~EXEC_P;
252b5132 445 else
f13a99db 446 link_info.output_bfd->flags |= EXEC_P;
252b5132 447
0ce398f1
L
448 if ((link_info.compress_debug & COMPRESS_DEBUG))
449 {
450 link_info.output_bfd->flags |= BFD_COMPRESS;
451 if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
452 link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
453 }
454
252b5132
RH
455 ldwrite ();
456
457 if (config.map_file != NULL)
458 lang_map ();
459 if (command_line.cref)
460 output_cref (config.map_file != NULL ? config.map_file : stdout);
461 if (nocrossref_list != NULL)
462 check_nocrossrefs ();
3604cb1f
TG
463 if (command_line.print_memory_usage)
464 lang_print_memory_usage ();
edf84efc
NC
465#if 0
466 {
0aa7f586 467 struct bfd_link_hash_entry *h;
252b5132 468
edf84efc
NC
469 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
470 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
471 }
472#endif
18d6a79d 473 ldexp_finish ();
750877ba
L
474 lang_finish ();
475
1049f94e 476 /* Even if we're producing relocatable output, some non-fatal errors should
252b5132 477 be reported in the exit status. (What non-fatal errors, if any, do we
1049f94e 478 want to ignore for relocatable output?) */
b34976b6 479 if (!config.make_executable && !force_make_executable)
252b5132 480 {
b34976b6 481 if (trace_files)
0125cdf2
NC
482 einfo (_("%P: link errors found, deleting executable `%s'\n"),
483 output_filename);
252b5132 484
4309cbf2 485 /* The file will be removed by ld_cleanup. */
252b5132
RH
486 xexit (1);
487 }
488 else
489 {
0aa7f586 490 if (!bfd_close (link_info.output_bfd))
df5f2391 491 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info.output_bfd);
252b5132
RH
492
493 /* If the --force-exe-suffix is enabled, and we're making an
6d5e62f8
KH
494 executable file and it doesn't end in .exe, copy it to one
495 which does. */
0e1862bb
L
496 if (!bfd_link_relocatable (&link_info)
497 && command_line.force_exe_suffix)
252b5132
RH
498 {
499 int len = strlen (output_filename);
0125cdf2 500
6d5e62f8 501 if (len < 4
252b5132
RH
502 || (strcasecmp (output_filename + len - 4, ".exe") != 0
503 && strcasecmp (output_filename + len - 4, ".dll") != 0))
504 {
505 FILE *src;
506 FILE *dst;
507 const int bsize = 4096;
1e9cc1c2 508 char *buf = (char *) xmalloc (bsize);
252b5132 509 int l;
1e9cc1c2 510 char *dst_name = (char *) xmalloc (len + 5);
0125cdf2 511
252b5132
RH
512 strcpy (dst_name, output_filename);
513 strcat (dst_name, ".exe");
514 src = fopen (output_filename, FOPEN_RB);
515 dst = fopen (dst_name, FOPEN_WB);
516
517 if (!src)
df5f2391 518 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
1579bae1 519 output_filename);
252b5132 520 if (!dst)
df5f2391 521 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
1579bae1 522 dst_name);
252b5132
RH
523 while ((l = fread (buf, 1, bsize, src)) > 0)
524 {
525 int done = fwrite (buf, 1, l, dst);
0125cdf2 526
252b5132 527 if (done != l)
df5f2391 528 einfo (_("%P: error writing file `%s'\n"), dst_name);
252b5132 529 }
0125cdf2 530
252b5132
RH
531 fclose (src);
532 if (fclose (dst) == EOF)
df5f2391 533 einfo (_("%P: error closing file `%s'\n"), dst_name);
252b5132
RH
534 free (dst_name);
535 free (buf);
536 }
537 }
538 }
539
540 END_PROGRESS (program_name);
541
542 if (config.stats)
543 {
252b5132
RH
544 long run_time = get_run_time () - start_time;
545
e922bcab 546 fflush (stdout);
252b5132
RH
547 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
548 program_name, run_time / 1000000, run_time % 1000000);
e922bcab 549 fflush (stderr);
252b5132
RH
550 }
551
4309cbf2 552 /* Prevent ld_cleanup from doing anything, after a successful link. */
252b5132
RH
553 output_filename = NULL;
554
555 xexit (0);
556 return 0;
557}
558
e2243057
RS
559/* If the configured sysroot is relocatable, try relocating it based on
560 default prefix FROM. Return the relocated directory if it exists,
561 otherwise return null. */
562
563static char *
564get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
565{
566#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
567 char *path;
568 struct stat s;
569
570 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
571 if (path)
572 {
573 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
574 return path;
575 free (path);
576 }
577#endif
578 return 0;
579}
580
581/* Return the sysroot directory. Return "" if no sysroot is being used. */
582
583static const char *
584get_sysroot (int argc, char **argv)
585{
586 int i;
587 const char *path;
588
589 for (i = 1; i < argc; i++)
0112cd26 590 if (CONST_STRNEQ (argv[i], "--sysroot="))
e2243057
RS
591 return argv[i] + strlen ("--sysroot=");
592
593 path = get_relative_sysroot (BINDIR);
594 if (path)
595 return path;
596
597 path = get_relative_sysroot (TOOLBINDIR);
598 if (path)
599 return path;
600
601 return TARGET_SYSTEM_ROOT;
602}
603
252b5132
RH
604/* We need to find any explicitly given emulation in order to initialize the
605 state that's needed by the lex&yacc argument parser (parse_args). */
606
607static char *
1579bae1 608get_emulation (int argc, char **argv)
252b5132
RH
609{
610 char *emulation;
611 int i;
612
613 emulation = getenv (EMULATION_ENVIRON);
614 if (emulation == NULL)
615 emulation = DEFAULT_EMULATION;
616
617 for (i = 1; i < argc; i++)
618 {
0112cd26 619 if (CONST_STRNEQ (argv[i], "-m"))
252b5132
RH
620 {
621 if (argv[i][2] == '\0')
622 {
623 /* -m EMUL */
624 if (i < argc - 1)
625 {
626 emulation = argv[i + 1];
627 i++;
628 }
629 else
df5f2391 630 einfo (_("%F%P: missing argument to -m\n"));
252b5132
RH
631 }
632 else if (strcmp (argv[i], "-mips1") == 0
633 || strcmp (argv[i], "-mips2") == 0
634 || strcmp (argv[i], "-mips3") == 0
d1cf510e 635 || strcmp (argv[i], "-mips4") == 0
6f33421c
CD
636 || strcmp (argv[i], "-mips5") == 0
637 || strcmp (argv[i], "-mips32") == 0
638 || strcmp (argv[i], "-mips32r2") == 0
7361da2c 639 || strcmp (argv[i], "-mips32r6") == 0
5f74bc13 640 || strcmp (argv[i], "-mips64") == 0
7361da2c
AB
641 || strcmp (argv[i], "-mips64r2") == 0
642 || strcmp (argv[i], "-mips64r6") == 0)
252b5132 643 {
31d677f9 644 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
252b5132
RH
645 passed to the linker by some MIPS compilers. They
646 generally tell the linker to use a slightly different
647 library path. Perhaps someday these should be
648 implemented as emulations; until then, we just ignore
649 the arguments and hope that nobody ever creates
650 emulations named ips1, ips2 or ips3. */
651 }
652 else if (strcmp (argv[i], "-m486") == 0)
653 {
654 /* FIXME: The argument -m486 is passed to the linker on
655 some Linux systems. Hope that nobody creates an
656 emulation named 486. */
657 }
658 else
659 {
660 /* -mEMUL */
661 emulation = &argv[i][2];
662 }
663 }
664 }
665
666 return emulation;
667}
668
252b5132 669void
1579bae1 670add_ysym (const char *name)
252b5132 671{
1579bae1 672 if (link_info.notice_hash == NULL)
252b5132 673 {
0aa7f586
AM
674 link_info.notice_hash
675 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
66eb6687
AM
676 if (!bfd_hash_table_init_n (link_info.notice_hash,
677 bfd_hash_newfunc,
678 sizeof (struct bfd_hash_entry),
679 61))
df5f2391 680 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
6d5e62f8 681 }
252b5132 682
1579bae1 683 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
df5f2391 684 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
252b5132
RH
685}
686
0e86e20e
AM
687void
688add_ignoresym (struct bfd_link_info *info, const char *name)
689{
690 if (info->ignore_hash == NULL)
691 {
692 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
0aa7f586
AM
693 if (!bfd_hash_table_init_n (info->ignore_hash,
694 bfd_hash_newfunc,
695 sizeof (struct bfd_hash_entry),
696 61))
df5f2391 697 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
0e86e20e
AM
698 }
699
700 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
df5f2391 701 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
0e86e20e
AM
702}
703
252b5132
RH
704/* Record a symbol to be wrapped, from the --wrap option. */
705
706void
1579bae1 707add_wrap (const char *name)
252b5132
RH
708{
709 if (link_info.wrap_hash == NULL)
710 {
0aa7f586
AM
711 link_info.wrap_hash
712 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
66eb6687
AM
713 if (!bfd_hash_table_init_n (link_info.wrap_hash,
714 bfd_hash_newfunc,
715 sizeof (struct bfd_hash_entry),
716 61))
df5f2391 717 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
252b5132 718 }
0125cdf2 719
b34976b6 720 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
df5f2391 721 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
252b5132
RH
722}
723
724/* Handle the -retain-symbols-file option. */
725
726void
1579bae1 727add_keepsyms_file (const char *filename)
252b5132
RH
728{
729 FILE *file;
730 char *buf;
731 size_t bufsize;
732 int c;
733
734 if (link_info.strip == strip_some)
735 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
736
737 file = fopen (filename, "r");
1579bae1 738 if (file == NULL)
252b5132
RH
739 {
740 bfd_set_error (bfd_error_system_call);
741 einfo ("%X%P: %s: %E\n", filename);
742 return;
743 }
744
1e9cc1c2
NC
745 link_info.keep_hash = (struct bfd_hash_table *)
746 xmalloc (sizeof (struct bfd_hash_table));
66eb6687
AM
747 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
748 sizeof (struct bfd_hash_entry)))
df5f2391 749 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
252b5132
RH
750
751 bufsize = 100;
1e9cc1c2 752 buf = (char *) xmalloc (bufsize);
252b5132
RH
753
754 c = getc (file);
755 while (c != EOF)
756 {
3882b010 757 while (ISSPACE (c))
252b5132
RH
758 c = getc (file);
759
760 if (c != EOF)
761 {
762 size_t len = 0;
763
0aa7f586 764 while (!ISSPACE (c) && c != EOF)
252b5132
RH
765 {
766 buf[len] = c;
767 ++len;
768 if (len >= bufsize)
769 {
770 bufsize *= 2;
1e9cc1c2 771 buf = (char *) xrealloc (buf, bufsize);
252b5132
RH
772 }
773 c = getc (file);
774 }
775
776 buf[len] = '\0';
777
1579bae1 778 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
df5f2391 779 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
252b5132
RH
780 }
781 }
782
783 if (link_info.strip != strip_none)
784 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
785
5ed6aba4 786 free (buf);
252b5132 787 link_info.strip = strip_some;
d9313f4f 788 fclose (file);
252b5132
RH
789}
790\f
791/* Callbacks from the BFD linker routines. */
792
793/* This is called when BFD has decided to include an archive member in
794 a link. */
795
b34976b6 796static bfd_boolean
e1fffbe6 797add_archive_element (struct bfd_link_info *info,
1579bae1 798 bfd *abfd,
5d3236ee
DK
799 const char *name,
800 bfd **subsbfd ATTRIBUTE_UNUSED)
252b5132
RH
801{
802 lang_input_statement_type *input;
1fa4ec6a 803 lang_input_statement_type *parent;
5d3236ee 804 lang_input_statement_type orig_input;
252b5132 805
1e9cc1c2
NC
806 input = (lang_input_statement_type *)
807 xcalloc (1, sizeof (lang_input_statement_type));
fb47deda 808 input->header.type = lang_input_statement_enum;
252b5132
RH
809 input->filename = abfd->filename;
810 input->local_sym_name = abfd->filename;
811 input->the_bfd = abfd;
252b5132 812
1fa4ec6a
AM
813 parent = abfd->my_archive->usrdata;
814 if (parent != NULL && !parent->flags.reload)
815 parent->next = (lang_statement_union_type *) input;
816
5d3236ee
DK
817 /* Save the original data for trace files/tries below, as plugins
818 (if enabled) may possibly alter it to point to a replacement
819 BFD, but we still want to output the original BFD filename. */
820 orig_input = *input;
821#ifdef ENABLE_PLUGINS
b95a0a31 822 if (link_info.lto_plugin_active)
5d3236ee
DK
823 {
824 /* We must offer this archive member to the plugins to claim. */
35a1e5f3
L
825 plugin_maybe_claim (input);
826 if (input->flags.claimed)
5d3236ee 827 {
b95a0a31
L
828 if (no_more_claiming)
829 {
830 /* Don't claim new IR symbols after all IR symbols have
831 been claimed. */
832 if (trace_files || verbose)
c1c8c1ef 833 info_msg ("%pI: no new IR symbols to claimi\n",
b95a0a31
L
834 &orig_input);
835 input->flags.claimed = 0;
836 return FALSE;
837 }
35a1e5f3
L
838 input->flags.claim_archive = TRUE;
839 *subsbfd = input->the_bfd;
5d3236ee
DK
840 }
841 }
842#endif /* ENABLE_PLUGINS */
843
252b5132
RH
844 ldlang_add_file (input);
845
1579bae1 846 if (config.map_file != NULL)
252b5132 847 {
b34976b6 848 static bfd_boolean header_printed;
252b5132
RH
849 struct bfd_link_hash_entry *h;
850 bfd *from;
851 int len;
852
e1fffbe6 853 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
aa654ee8
AM
854 if (h == NULL
855 && info->pei386_auto_import
856 && CONST_STRNEQ (name, "__imp_"))
857 h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
252b5132
RH
858
859 if (h == NULL)
860 from = NULL;
861 else
862 {
863 switch (h->type)
864 {
865 default:
866 from = NULL;
867 break;
868
869 case bfd_link_hash_defined:
870 case bfd_link_hash_defweak:
871 from = h->u.def.section->owner;
872 break;
873
874 case bfd_link_hash_undefined:
875 case bfd_link_hash_undefweak:
876 from = h->u.undef.abfd;
877 break;
878
879 case bfd_link_hash_common:
880 from = h->u.c.p->section->owner;
881 break;
882 }
883 }
884
0aa7f586 885 if (!header_printed)
252b5132 886 {
1273da04 887 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
b34976b6 888 header_printed = TRUE;
252b5132
RH
889 }
890
3860d2b4
AM
891 if (abfd->my_archive == NULL
892 || bfd_is_thin_archive (abfd->my_archive))
252b5132
RH
893 {
894 minfo ("%s", bfd_get_filename (abfd));
895 len = strlen (bfd_get_filename (abfd));
896 }
897 else
898 {
3860d2b4 899 minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
252b5132 900 bfd_get_filename (abfd));
3860d2b4 901 len = (strlen (bfd_get_filename (abfd->my_archive))
252b5132
RH
902 + strlen (bfd_get_filename (abfd))
903 + 2);
904 }
905
906 if (len >= 29)
907 {
908 print_nl ();
909 len = 0;
910 }
911 while (len < 30)
912 {
913 print_space ();
914 ++len;
915 }
916
917 if (from != NULL)
871b3ab2 918 minfo ("%pB ", from);
252b5132 919 if (h != NULL)
c1c8c1ef 920 minfo ("(%pT)\n", h->root.string);
252b5132
RH
921 else
922 minfo ("(%s)\n", name);
923 }
924
cd6f1cf3 925 if (trace_files || verbose)
c1c8c1ef 926 info_msg ("%pI\n", &orig_input);
b34976b6 927 return TRUE;
252b5132
RH
928}
929
930/* This is called when BFD has discovered a symbol which is defined
931 multiple times. */
932
1a72702b 933static void
24f58f47
AM
934multiple_definition (struct bfd_link_info *info,
935 struct bfd_link_hash_entry *h,
1579bae1
AM
936 bfd *nbfd,
937 asection *nsec,
938 bfd_vma nval)
252b5132 939{
24f58f47
AM
940 const char *name;
941 bfd *obfd;
942 asection *osec;
943 bfd_vma oval;
944
945 if (info->allow_multiple_definition)
1a72702b 946 return;
24f58f47
AM
947
948 switch (h->type)
949 {
950 case bfd_link_hash_defined:
951 osec = h->u.def.section;
952 oval = h->u.def.value;
953 obfd = h->u.def.section->owner;
954 break;
955 case bfd_link_hash_indirect:
956 osec = bfd_ind_section_ptr;
957 oval = 0;
958 obfd = NULL;
959 break;
960 default:
961 abort ();
962 }
963
964 /* Ignore a redefinition of an absolute symbol to the
965 same value; it's harmless. */
966 if (h->type == bfd_link_hash_defined
967 && bfd_is_abs_section (osec)
968 && bfd_is_abs_section (nsec)
969 && nval == oval)
1a72702b 970 return;
24f58f47 971
252b5132
RH
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.
9e2278f5
AM
975 FIXME: It would be cleaner to somehow ignore symbols defined in
976 sections which are being discarded. */
3f0a5f17
ME
977 if (!info->prohibit_multiple_definition_absolute
978 && ((osec->output_section != NULL
979 && ! bfd_is_abs_section (osec)
980 && bfd_is_abs_section (osec->output_section))
981 || (nsec->output_section != NULL
982 && !bfd_is_abs_section (nsec)
983 && bfd_is_abs_section (nsec->output_section))))
1a72702b 984 return;
252b5132 985
24f58f47
AM
986 name = h->root.string;
987 if (nbfd == NULL)
988 {
989 nbfd = obfd;
990 nsec = osec;
991 nval = oval;
992 obfd = NULL;
993 }
df5f2391 994 einfo (_("%X%P: %C: multiple definition of `%pT'"),
252b5132 995 nbfd, nsec, nval, name);
1579bae1 996 if (obfd != NULL)
df5f2391
AM
997 einfo (_("; %D: first defined here"), obfd, osec, oval);
998 einfo ("\n");
9b14b192 999
13761a11 1000 if (RELAXATION_ENABLED_BY_USER)
9b14b192 1001 {
df5f2391 1002 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
13761a11 1003 DISABLE_RELAXATION;
9b14b192 1004 }
252b5132
RH
1005}
1006
1007/* This is called when there is a definition of a common symbol, or
1008 when a common symbol is found for a symbol that is already defined,
1009 or when two common symbols are found. We only do something if
1010 -warn-common was used. */
1011
1a72702b 1012static void
1579bae1 1013multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
24f58f47 1014 struct bfd_link_hash_entry *h,
1579bae1
AM
1015 bfd *nbfd,
1016 enum bfd_link_hash_type ntype,
1017 bfd_vma nsize)
252b5132 1018{
24f58f47
AM
1019 const char *name;
1020 bfd *obfd;
1021 enum bfd_link_hash_type otype;
1022 bfd_vma osize;
1023
1024 if (!config.warn_common)
1a72702b 1025 return;
252b5132 1026
24f58f47
AM
1027 name = h->root.string;
1028 otype = h->type;
1029 if (otype == bfd_link_hash_common)
1030 {
1031 obfd = h->u.c.p->section->owner;
1032 osize = h->u.c.size;
1033 }
1034 else if (otype == bfd_link_hash_defined
1035 || otype == bfd_link_hash_defweak)
1036 {
1037 obfd = h->u.def.section->owner;
1038 osize = 0;
1039 }
1040 else
1041 {
1042 /* FIXME: It would nice if we could report the BFD which defined
1043 an indirect symbol, but we don't have anywhere to store the
1044 information. */
1045 obfd = NULL;
1046 osize = 0;
1047 }
1048
252b5132
RH
1049 if (ntype == bfd_link_hash_defined
1050 || ntype == bfd_link_hash_defweak
1051 || ntype == bfd_link_hash_indirect)
1052 {
1053 ASSERT (otype == bfd_link_hash_common);
252b5132 1054 if (obfd != NULL)
df5f2391
AM
1055 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1056 " from %pB\n"),
1057 nbfd, name, obfd);
1058 else
1059 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1060 nbfd, name);
252b5132
RH
1061 }
1062 else if (otype == bfd_link_hash_defined
1063 || otype == bfd_link_hash_defweak
1064 || otype == bfd_link_hash_indirect)
1065 {
1066 ASSERT (ntype == bfd_link_hash_common);
252b5132 1067 if (obfd != NULL)
df5f2391
AM
1068 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1069 " from %pB\n"),
1070 nbfd, name, obfd);
1071 else
1072 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1073 nbfd, name);
252b5132
RH
1074 }
1075 else
1076 {
1077 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1078 if (osize > nsize)
1079 {
252b5132 1080 if (obfd != NULL)
df5f2391
AM
1081 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1082 " by larger common from %pB\n"),
1083 nbfd, name, obfd);
1084 else
1085 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1086 " by larger common\n"),
1087 nbfd, name);
252b5132
RH
1088 }
1089 else if (nsize > osize)
1090 {
252b5132 1091 if (obfd != NULL)
df5f2391
AM
1092 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1093 " smaller common from %pB\n"),
1094 nbfd, name, obfd);
1095 else
1096 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1097 " smaller common\n"),
1098 nbfd, name);
252b5132
RH
1099 }
1100 else
1101 {
252b5132 1102 if (obfd != NULL)
df5f2391
AM
1103 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1104 nbfd, obfd, name);
1105 else
1106 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1107 nbfd, name);
252b5132
RH
1108 }
1109 }
252b5132
RH
1110}
1111
1112/* This is called when BFD has discovered a set element. H is the
1113 entry in the linker hash table for the set. SECTION and VALUE
1114 represent a value which should be added to the set. */
1115
1a72702b 1116static void
1579bae1
AM
1117add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1118 struct bfd_link_hash_entry *h,
1119 bfd_reloc_code_real_type reloc,
1120 bfd *abfd,
1121 asection *section,
1122 bfd_vma value)
252b5132
RH
1123{
1124 if (config.warn_constructors)
1125 einfo (_("%P: warning: global constructor %s used\n"),
1126 h->root.string);
1127
0aa7f586 1128 if (!config.build_constructors)
1a72702b 1129 return;
252b5132 1130
1579bae1 1131 ldctor_add_set_entry (h, reloc, NULL, section, value);
252b5132
RH
1132
1133 if (h->type == bfd_link_hash_new)
1134 {
1135 h->type = bfd_link_hash_undefined;
1136 h->u.undef.abfd = abfd;
1137 /* We don't call bfd_link_add_undef to add this to the list of
1138 undefined symbols because we are going to define it
1139 ourselves. */
1140 }
252b5132
RH
1141}
1142
1143/* This is called when BFD has discovered a constructor. This is only
1144 called for some object file formats--those which do not handle
1145 constructors in some more clever fashion. This is similar to
1146 adding an element to a set, but less general. */
1147
1a72702b 1148static void
1579bae1
AM
1149constructor_callback (struct bfd_link_info *info,
1150 bfd_boolean constructor,
1151 const char *name,
1152 bfd *abfd,
1153 asection *section,
1154 bfd_vma value)
252b5132
RH
1155{
1156 char *s;
1157 struct bfd_link_hash_entry *h;
1158 char set_name[1 + sizeof "__CTOR_LIST__"];
1159
1160 if (config.warn_constructors)
1161 einfo (_("%P: warning: global constructor %s used\n"), name);
1162
0aa7f586 1163 if (!config.build_constructors)
1a72702b 1164 return;
252b5132
RH
1165
1166 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1167 useful error message. */
0e86e20e 1168 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
0e1862bb 1169 && (bfd_link_relocatable (info)
252b5132 1170 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
df5f2391 1171 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
252b5132
RH
1172
1173 s = set_name;
1174 if (bfd_get_symbol_leading_char (abfd) != '\0')
1175 *s++ = bfd_get_symbol_leading_char (abfd);
1176 if (constructor)
1177 strcpy (s, "__CTOR_LIST__");
1178 else
1179 strcpy (s, "__DTOR_LIST__");
1180
b34976b6 1181 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
252b5132 1182 if (h == (struct bfd_link_hash_entry *) NULL)
df5f2391 1183 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
252b5132
RH
1184 if (h->type == bfd_link_hash_new)
1185 {
1186 h->type = bfd_link_hash_undefined;
1187 h->u.undef.abfd = abfd;
1188 /* We don't call bfd_link_add_undef to add this to the list of
1189 undefined symbols because we are going to define it
1190 ourselves. */
1191 }
1192
1193 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
252b5132
RH
1194}
1195
1196/* A structure used by warning_callback to pass information through
1197 bfd_map_over_sections. */
1198
0125cdf2
NC
1199struct warning_callback_info
1200{
b34976b6 1201 bfd_boolean found;
252b5132
RH
1202 const char *warning;
1203 const char *symbol;
1204 asymbol **asymbols;
1205};
1206
4c6d802e
L
1207/* Look through the relocs to see if we can find a plausible address
1208 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1209
1210static bfd_boolean
1211symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1212{
1213 struct warning_callback_info cinfo;
1214
1215 if (!bfd_generic_link_read_symbols (abfd))
df5f2391 1216 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
4c6d802e
L
1217
1218 cinfo.found = FALSE;
1219 cinfo.warning = warning;
1220 cinfo.symbol = symbol;
1221 cinfo.asymbols = bfd_get_outsymbols (abfd);
1222 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1223 return cinfo.found;
1224}
1225
252b5132
RH
1226/* This is called when there is a reference to a warning symbol. */
1227
1a72702b 1228static void
1579bae1
AM
1229warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1230 const char *warning,
1231 const char *symbol,
1232 bfd *abfd,
1233 asection *section,
1234 bfd_vma address)
252b5132
RH
1235{
1236 /* This is a hack to support warn_multiple_gp. FIXME: This should
1237 have a cleaner interface, but what? */
0aa7f586 1238 if (!config.warn_multiple_gp
252b5132 1239 && strcmp (warning, "using multiple gp values") == 0)
1a72702b 1240 return;
252b5132
RH
1241
1242 if (section != NULL)
df5f2391 1243 einfo ("%P: %C: %s%s\n", abfd, section, address, _("warning: "), warning);
252b5132 1244 else if (abfd == NULL)
300475fe 1245 einfo ("%P: %s%s\n", _("warning: "), warning);
252b5132 1246 else if (symbol == NULL)
df5f2391 1247 einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
0aa7f586 1248 else if (!symbol_warning (warning, symbol, abfd))
252b5132 1249 {
4c6d802e
L
1250 bfd *b;
1251 /* Search all input files for a reference to SYMBOL. */
c72f2fb2 1252 for (b = info->input_bfds; b; b = b->link.next)
4c6d802e 1253 if (b != abfd && symbol_warning (warning, symbol, b))
1a72702b 1254 return;
df5f2391 1255 einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
252b5132 1256 }
252b5132
RH
1257}
1258
1259/* This is called by warning_callback for each section. It checks the
1260 relocs of the section to see if it can find a reference to the
1261 symbol which triggered the warning. If it can, it uses the reloc
1262 to give an error message with a file and line number. */
1263
1264static void
1579bae1 1265warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
252b5132 1266{
1e9cc1c2 1267 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
252b5132
RH
1268 long relsize;
1269 arelent **relpp;
1270 long relcount;
1271 arelent **p, **pend;
1272
1273 if (info->found)
1274 return;
1275
1276 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1277 if (relsize < 0)
df5f2391 1278 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
252b5132
RH
1279 if (relsize == 0)
1280 return;
1281
1e9cc1c2 1282 relpp = (arelent **) xmalloc (relsize);
252b5132
RH
1283 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1284 if (relcount < 0)
df5f2391 1285 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
252b5132
RH
1286
1287 p = relpp;
1288 pend = p + relcount;
1289 for (; p < pend && *p != NULL; p++)
1290 {
1291 arelent *q = *p;
1292
1293 if (q->sym_ptr_ptr != NULL
1294 && *q->sym_ptr_ptr != NULL
1295 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1296 {
1297 /* We found a reloc for the symbol we are looking for. */
df5f2391 1298 einfo ("%P: %C: %s%s\n", abfd, sec, q->address, _("warning: "),
300475fe 1299 info->warning);
b34976b6 1300 info->found = TRUE;
252b5132
RH
1301 break;
1302 }
1303 }
1304
1305 free (relpp);
1306}
1307
1308/* This is called when an undefined symbol is found. */
1309
1a72702b 1310static void
0e86e20e 1311undefined_symbol (struct bfd_link_info *info,
1579bae1
AM
1312 const char *name,
1313 bfd *abfd,
1314 asection *section,
1315 bfd_vma address,
0b28295d 1316 bfd_boolean error)
252b5132
RH
1317{
1318 static char *error_name;
1319 static unsigned int error_count;
1320
1321#define MAX_ERRORS_IN_A_ROW 5
1322
0e86e20e
AM
1323 if (info->ignore_hash != NULL
1324 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1a72702b 1325 return;
0e86e20e 1326
252b5132
RH
1327 if (config.warn_once)
1328 {
252b5132 1329 /* Only warn once about a particular undefined symbol. */
0e86e20e 1330 add_ignoresym (info, name);
252b5132
RH
1331 }
1332
1333 /* We never print more than a reasonable number of errors in a row
1334 for a single symbol. */
1579bae1 1335 if (error_name != NULL
252b5132
RH
1336 && strcmp (name, error_name) == 0)
1337 ++error_count;
1338 else
1339 {
1340 error_count = 0;
1579bae1 1341 if (error_name != NULL)
252b5132 1342 free (error_name);
d1b2b2dc 1343 error_name = xstrdup (name);
252b5132
RH
1344 }
1345
1346 if (section != NULL)
1347 {
1348 if (error_count < MAX_ERRORS_IN_A_ROW)
b6f29aaa 1349 {
0b28295d 1350 if (error)
df5f2391 1351 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
0b28295d
ILT
1352 abfd, section, address, name);
1353 else
df5f2391 1354 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
0b28295d 1355 abfd, section, address, name);
b6f29aaa 1356 }
252b5132 1357 else if (error_count == MAX_ERRORS_IN_A_ROW)
0b28295d
ILT
1358 {
1359 if (error)
df5f2391 1360 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
0b28295d
ILT
1361 abfd, section, address, name);
1362 else
df5f2391 1363 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
0b28295d
ILT
1364 abfd, section, address, name);
1365 }
1366 else if (error)
1367 einfo ("%X");
252b5132
RH
1368 }
1369 else
1370 {
1371 if (error_count < MAX_ERRORS_IN_A_ROW)
b6f29aaa 1372 {
0b28295d 1373 if (error)
df5f2391 1374 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
0b28295d
ILT
1375 abfd, name);
1376 else
df5f2391 1377 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
0b28295d 1378 abfd, name);
b6f29aaa 1379 }
252b5132 1380 else if (error_count == MAX_ERRORS_IN_A_ROW)
0b28295d
ILT
1381 {
1382 if (error)
df5f2391 1383 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
0b28295d
ILT
1384 abfd, name);
1385 else
df5f2391 1386 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
0b28295d
ILT
1387 abfd, name);
1388 }
1389 else if (error)
1390 einfo ("%X");
252b5132 1391 }
252b5132
RH
1392}
1393
8aae64e6
AO
1394/* Counter to limit the number of relocation overflow error messages
1395 to print. Errors are printed as it is decremented. When it's
1396 called and the counter is zero, a final message is printed
1397 indicating more relocations were omitted. When it gets to -1, no
1398 such errors are printed. If it's initially set to a value less
1399 than -1, all such errors will be printed (--verbose does this). */
1400
1401int overflow_cutoff_limit = 10;
1402
252b5132
RH
1403/* This is called when a reloc overflows. */
1404
1a72702b 1405static void
0e86e20e 1406reloc_overflow (struct bfd_link_info *info,
dfeffb9f 1407 struct bfd_link_hash_entry *entry,
1579bae1
AM
1408 const char *name,
1409 const char *reloc_name,
1410 bfd_vma addend,
1411 bfd *abfd,
1412 asection *section,
1413 bfd_vma address)
252b5132 1414{
8aae64e6 1415 if (overflow_cutoff_limit == -1)
1a72702b 1416 return;
8aae64e6 1417
df5f2391 1418 einfo ("%X%P: %H:", abfd, section, address);
8aae64e6
AO
1419
1420 if (overflow_cutoff_limit >= 0
1421 && overflow_cutoff_limit-- == 0)
1422 {
1423 einfo (_(" additional relocation overflows omitted from the output\n"));
1a72702b 1424 return;
8aae64e6
AO
1425 }
1426
dfeffb9f
L
1427 if (entry)
1428 {
1429 while (entry->type == bfd_link_hash_indirect
1430 || entry->type == bfd_link_hash_warning)
1431 entry = entry->u.i.link;
1432 switch (entry->type)
1433 {
1434 case bfd_link_hash_undefined:
1435 case bfd_link_hash_undefweak:
0aa7f586 1436 einfo (_(" relocation truncated to fit: "
c1c8c1ef 1437 "%s against undefined symbol `%pT'"),
dfeffb9f
L
1438 reloc_name, entry->root.string);
1439 break;
1440 case bfd_link_hash_defined:
1441 case bfd_link_hash_defweak:
0aa7f586 1442 einfo (_(" relocation truncated to fit: "
c1c8c1ef 1443 "%s against symbol `%pT' defined in %pA section in %pB"),
dfeffb9f 1444 reloc_name, entry->root.string,
a6e1b90f
L
1445 entry->u.def.section,
1446 entry->u.def.section == bfd_abs_section_ptr
0e86e20e 1447 ? info->output_bfd : entry->u.def.section->owner);
dfeffb9f
L
1448 break;
1449 default:
1450 abort ();
1451 break;
1452 }
1453 }
1454 else
c1c8c1ef 1455 einfo (_(" relocation truncated to fit: %s against `%pT'"),
dfeffb9f 1456 reloc_name, name);
252b5132
RH
1457 if (addend != 0)
1458 einfo ("+%v", addend);
1459 einfo ("\n");
252b5132
RH
1460}
1461
1462/* This is called when a dangerous relocation is made. */
1463
1a72702b 1464static void
1579bae1
AM
1465reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1466 const char *message,
1467 bfd *abfd,
1468 asection *section,
1469 bfd_vma address)
252b5132 1470{
df5f2391 1471 einfo (_("%X%P: %H: dangerous relocation: %s\n"),
e1fffbe6 1472 abfd, section, address, message);
252b5132
RH
1473}
1474
1475/* This is called when a reloc is being generated attached to a symbol
1476 that is not being output. */
1477
1a72702b 1478static void
1579bae1
AM
1479unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1480 const char *name,
1481 bfd *abfd,
1482 asection *section,
1483 bfd_vma address)
252b5132 1484{
df5f2391 1485 einfo (_("%X%P: %H: reloc refers to symbol `%pT' which is not being output\n"),
e1fffbe6 1486 abfd, section, address, name);
252b5132
RH
1487}
1488
1489/* This is called if link_info.notice_all is set, or when a symbol in
1490 link_info.notice_hash is found. Symbols are put in notice_hash
5d3236ee
DK
1491 using the -y option, while notice_all is set if the --cref option
1492 has been supplied, or if there are any NOCROSSREFS sections in the
1493 linker script; and if plugins are active, since they need to monitor
1494 all references from non-IR files. */
252b5132 1495
b34976b6 1496static bfd_boolean
1579bae1 1497notice (struct bfd_link_info *info,
35ed3f94 1498 struct bfd_link_hash_entry *h,
46135103 1499 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1579bae1
AM
1500 bfd *abfd,
1501 asection *section,
16d96b5b 1502 bfd_vma value,
46135103 1503 flagword flags ATTRIBUTE_UNUSED)
252b5132 1504{
35ed3f94
AM
1505 const char *name;
1506
1507 if (h == NULL)
5061a885
AM
1508 {
1509 if (command_line.cref || nocrossref_list != NULL)
1e9cc1c2 1510 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
5061a885
AM
1511 return TRUE;
1512 }
1513
35ed3f94 1514 name = h->root.string;
5d3236ee 1515 if (info->notice_hash != NULL
9e2278f5 1516 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
252b5132
RH
1517 {
1518 if (bfd_is_und_section (section))
df5f2391 1519 einfo (_("%P: %pB: reference to %s\n"), abfd, name);
252b5132 1520 else
df5f2391 1521 einfo (_("%P: %pB: definition of %s\n"), abfd, name);
252b5132
RH
1522 }
1523
1524 if (command_line.cref || nocrossref_list != NULL)
1525 add_cref (name, abfd, section, value);
1526
b34976b6 1527 return TRUE;
252b5132 1528}