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