X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=ld%2Fldmain.c;h=1784b16c16acb87825b96c336a0a8169e12b7246;hb=c0f0068602c40067eee019e0d3d152c5c1868f18;hp=84baa4ddf0aff3aa43bc4cae472e569e48864a45;hpb=2ee563b53258d390d7446e90a67f465d504ae44c;p=deliverable%2Fbinutils-gdb.git diff --git a/ld/ldmain.c b/ld/ldmain.c index 84baa4ddf0..1784b16c16 100644 --- a/ld/ldmain.c +++ b/ld/ldmain.c @@ -1,25 +1,25 @@ /* Main program of GNU linker. Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, - 2002 + 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. Written by Steve Chamberlain steve@cygnus.com -This file is part of GLD, the Gnu Linker. + This file is part of GLD, the Gnu Linker. -GLD is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. + GLD is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. -GLD is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + GLD is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with GLD; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with GLD; see the file COPYING. If not, write to the Free + Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ #include "bfd.h" #include "sysdep.h" @@ -36,13 +36,13 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "ldwrite.h" #include "ldexp.h" #include "ldlang.h" -#include "ldgram.h" +#include #include "ldlex.h" #include "ldfile.h" #include "ldemul.h" #include "ldctor.h" -/* Somewhere above, sys/stat.h got included . . . . */ +/* Somewhere above, sys/stat.h got included. */ #if !defined(S_ISDIR) && defined(S_IFDIR) #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) #endif @@ -50,15 +50,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include #ifdef HAVE_SBRK -#ifdef NEED_DECLARATION_SBRK -extern PTR sbrk (); +#if !HAVE_DECL_SBRK +extern void *sbrk (); #endif #endif -int main PARAMS ((int, char **)); - -static char *get_emulation PARAMS ((int, char **)); -static void set_scripts_dir PARAMS ((void)); +#ifndef TARGET_SYSTEM_ROOT +#define TARGET_SYSTEM_ROOT "" +#endif /* EXPORTS */ @@ -68,6 +67,13 @@ const char *output_filename = "a.out"; /* Name this program was invoked by. */ char *program_name; +/* The prefix for system library directories. */ +const char *ld_sysroot; + +/* The canonical representation of ld_sysroot. */ +char * ld_canon_sysroot; +int ld_canon_sysroot_len; + /* The file that we're creating. */ bfd *output_bfd = 0; @@ -75,65 +81,75 @@ bfd *output_bfd = 0; int g_switch_value = 8; /* Nonzero means print names of input files as processed. */ -boolean trace_files; +bfd_boolean trace_files; /* Nonzero means same, but note open failures, too. */ -boolean trace_file_tries; +bfd_boolean trace_file_tries; /* Nonzero means version number was printed, so exit successfully instead of complaining if no input files are given. */ -boolean version_printed; +bfd_boolean version_printed; /* Nonzero means link in every member of an archive. */ -boolean whole_archive; +bfd_boolean whole_archive; -/* True if we should demangle symbol names. */ -boolean demangling; +/* Nonzero means create DT_NEEDED entries only if a dynamic library + actually satisfies some reference in a regular object. */ +bfd_boolean as_needed; + +/* Nonzero means never create DT_NEEDED entries for dynamic libraries + in DT_NEEDED tags. */ +bfd_boolean add_needed = TRUE; + +/* TRUE if we should demangle symbol names. */ +bfd_boolean demangling; args_type command_line; ld_config_type config; -static void remove_output PARAMS ((void)); -static boolean check_for_scripts_dir PARAMS ((char *dir)); -static boolean add_archive_element PARAMS ((struct bfd_link_info *, bfd *, - const char *)); -static boolean multiple_definition PARAMS ((struct bfd_link_info *, - const char *, - bfd *, asection *, bfd_vma, - bfd *, asection *, bfd_vma)); -static boolean multiple_common PARAMS ((struct bfd_link_info *, - const char *, bfd *, - enum bfd_link_hash_type, bfd_vma, - bfd *, enum bfd_link_hash_type, - bfd_vma)); -static boolean add_to_set PARAMS ((struct bfd_link_info *, - struct bfd_link_hash_entry *, - bfd_reloc_code_real_type, - bfd *, asection *, bfd_vma)); -static boolean constructor_callback PARAMS ((struct bfd_link_info *, - boolean constructor, - const char *name, - bfd *, asection *, bfd_vma)); -static boolean warning_callback PARAMS ((struct bfd_link_info *, - const char *, const char *, bfd *, - asection *, bfd_vma)); -static void warning_find_reloc PARAMS ((bfd *, asection *, PTR)); -static boolean undefined_symbol PARAMS ((struct bfd_link_info *, - const char *, bfd *, - asection *, bfd_vma, boolean)); -static boolean reloc_overflow PARAMS ((struct bfd_link_info *, const char *, - const char *, bfd_vma, - bfd *, asection *, bfd_vma)); -static boolean reloc_dangerous PARAMS ((struct bfd_link_info *, const char *, - bfd *, asection *, bfd_vma)); -static boolean unattached_reloc PARAMS ((struct bfd_link_info *, - const char *, bfd *, asection *, - bfd_vma)); -static boolean notice PARAMS ((struct bfd_link_info *, const char *, - bfd *, asection *, bfd_vma)); - -static struct bfd_link_callbacks link_callbacks = { +sort_type sort_section; + +static const char *get_sysroot + (int, char **); +static char *get_emulation + (int, char **); +static void set_scripts_dir + (void); +static bfd_boolean add_archive_element + (struct bfd_link_info *, bfd *, const char *); +static bfd_boolean multiple_definition + (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma, + bfd *, asection *, bfd_vma); +static bfd_boolean multiple_common + (struct bfd_link_info *, const char *, bfd *, enum bfd_link_hash_type, + bfd_vma, bfd *, enum bfd_link_hash_type, bfd_vma); +static bfd_boolean add_to_set + (struct bfd_link_info *, struct bfd_link_hash_entry *, + bfd_reloc_code_real_type, bfd *, asection *, bfd_vma); +static bfd_boolean constructor_callback + (struct bfd_link_info *, bfd_boolean, const char *, bfd *, + asection *, bfd_vma); +static bfd_boolean warning_callback + (struct bfd_link_info *, const char *, const char *, bfd *, + asection *, bfd_vma); +static void warning_find_reloc + (bfd *, asection *, void *); +static bfd_boolean undefined_symbol + (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma, + bfd_boolean); +static bfd_boolean reloc_overflow + (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, + const char *, bfd_vma, bfd *, asection *, bfd_vma); +static bfd_boolean reloc_dangerous + (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma); +static bfd_boolean unattached_reloc + (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma); +static bfd_boolean notice + (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma); + +static struct bfd_link_callbacks link_callbacks = +{ add_archive_element, multiple_definition, multiple_common, @@ -144,27 +160,26 @@ static struct bfd_link_callbacks link_callbacks = { reloc_overflow, reloc_dangerous, unattached_reloc, - notice + notice, + einfo }; struct bfd_link_info link_info; static void -remove_output () +remove_output (void) { if (output_filename) { - if (output_bfd && output_bfd->iostream) - fclose ((FILE *) (output_bfd->iostream)); + if (output_bfd) + bfd_cache_close (output_bfd); if (delete_output_file_on_failure) - unlink (output_filename); + unlink_if_ordinary (output_filename); } } int -main (argc, argv) - int argc; - char **argv; +main (int argc, char **argv) { char *emulation; long start_time = get_run_time (); @@ -183,12 +198,31 @@ main (argc, argv) START_PROGRESS (program_name, 0); + expandargv (&argc, &argv); + bfd_init (); bfd_set_error_program_name (program_name); xatexit (remove_output); + /* Set up the sysroot directory. */ + ld_sysroot = get_sysroot (argc, argv); + if (*ld_sysroot) + { + if (*TARGET_SYSTEM_ROOT == 0) + { + einfo ("%P%F: this linker was not configured to use sysroots\n"); + ld_sysroot = ""; + } + else + ld_canon_sysroot = lrealpath (ld_sysroot); + } + if (ld_canon_sysroot) + ld_canon_sysroot_len = strlen (ld_canon_sysroot); + else + ld_canon_sysroot_len = -1; + /* Set the default BFD target based on the configured target. Doing this permits the linker to be configured for a particular target, and linked against a shared BFD library which was configured for @@ -207,19 +241,23 @@ main (argc, argv) #endif /* Initialize the data about options. */ - trace_files = trace_file_tries = version_printed = false; - whole_archive = false; - config.build_constructors = true; - config.dynamic_link = false; - config.has_shared = false; + trace_files = trace_file_tries = version_printed = FALSE; + whole_archive = FALSE; + config.build_constructors = TRUE; + config.dynamic_link = FALSE; + config.has_shared = FALSE; config.split_by_reloc = (unsigned) -1; config.split_by_file = (bfd_size_type) -1; - command_line.force_common_definition = false; - command_line.inhibit_common_definition = false; + config.hash_table_size = 0; + command_line.force_common_definition = FALSE; + command_line.inhibit_common_definition = FALSE; command_line.interpreter = NULL; command_line.rpath = NULL; - command_line.warn_mismatch = true; - command_line.check_section_addresses = true; + command_line.warn_mismatch = TRUE; + command_line.check_section_addresses = TRUE; + command_line.accept_unknown_input_arch = FALSE; + + sort_section = none; /* We initialize DEMANGLING based on the environment variable COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the @@ -228,68 +266,95 @@ main (argc, argv) interface by default. */ demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL; - link_info.callbacks = &link_callbacks; - link_info.relocateable = false; - link_info.emitrelocations = false; - link_info.shared = false; - link_info.symbolic = false; - link_info.export_dynamic = false; - link_info.static_link = false; - link_info.traditional_format = false; - link_info.optimize = false; - link_info.no_undefined = false; - link_info.allow_shlib_undefined = false; - link_info.allow_multiple_definition = false; - link_info.allow_undefined_version = true; + link_info.relocatable = FALSE; + link_info.emitrelocations = FALSE; + link_info.task_link = FALSE; + link_info.shared = FALSE; + link_info.pie = FALSE; + link_info.executable = FALSE; + link_info.symbolic = FALSE; + link_info.export_dynamic = FALSE; + link_info.static_link = FALSE; + link_info.traditional_format = FALSE; + link_info.optimize = FALSE; + link_info.unresolved_syms_in_objects = RM_NOT_YET_SET; + link_info.unresolved_syms_in_shared_libs = RM_NOT_YET_SET; + link_info.allow_multiple_definition = FALSE; + link_info.allow_undefined_version = TRUE; + link_info.create_default_symver = FALSE; + link_info.default_imported_symver = FALSE; + link_info.keep_memory = TRUE; + link_info.notice_all = FALSE; + link_info.nocopyreloc = FALSE; + link_info.new_dtags = FALSE; + link_info.combreloc = TRUE; + link_info.eh_frame_hdr = FALSE; + link_info.relro = FALSE; + link_info.strip_discarded = TRUE; link_info.strip = strip_none; link_info.discard = discard_sec_merge; - link_info.keep_memory = true; - link_info.input_bfds = NULL; - link_info.create_object_symbols_section = NULL; - link_info.gc_sym_list = NULL; + link_info.common_skip_ar_aymbols = bfd_link_common_skip_none; + link_info.callbacks = &link_callbacks; link_info.hash = NULL; link_info.keep_hash = NULL; - link_info.notice_all = false; link_info.notice_hash = NULL; link_info.wrap_hash = NULL; - link_info.mpc860c0 = 0; + link_info.input_bfds = NULL; + link_info.create_object_symbols_section = NULL; + link_info.gc_sym_list = NULL; + link_info.base_file = NULL; + link_info.emit_hash = TRUE; + link_info.emit_gnu_hash = FALSE; /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init and _fini symbols. We are compatible. */ link_info.init_function = "_init"; link_info.fini_function = "_fini"; - link_info.new_dtags = false; - link_info.eh_frame_hdr = false; - link_info.flags = (bfd_vma) 0; - link_info.flags_1 = (bfd_vma) 0; - link_info.pei386_auto_import = false; link_info.pei386_auto_import = -1; - link_info.combreloc = true; + link_info.pei386_runtime_pseudo_reloc = FALSE; link_info.spare_dynamic_tags = 5; - link_info.common_skip_ar_aymbols = bfd_link_common_skip_none; + link_info.flags = 0; + link_info.flags_1 = 0; + link_info.relax_pass = 1; + link_info.warn_shared_textrel = FALSE; + link_info.gc_sections = FALSE; + link_info.print_gc_sections = FALSE; + link_info.dynamic = NULL; + link_info.reduce_memory_overheads = FALSE; + + config.maxpagesize = 0; + config.commonpagesize = 0; ldfile_add_arch (""); - config.make_executable = true; - force_make_executable = false; - config.magic_demand_paged = true; - config.text_read_only = true; + config.make_executable = TRUE; + force_make_executable = FALSE; + config.magic_demand_paged = TRUE; + config.text_read_only = TRUE; emulation = get_emulation (argc, argv); ldemul_choose_mode (emulation); default_target = ldemul_choose_target (argc, argv); lang_init (); ldemul_before_parse (); - lang_has_input_file = false; + lang_has_input_file = FALSE; parse_args (argc, argv); + if (config.hash_table_size != 0) + bfd_hash_set_default_size (config.hash_table_size); + + if (config.maxpagesize != 0) + bfd_emul_set_maxpagesize (default_target, config.maxpagesize); + + if (config.commonpagesize != 0) + bfd_emul_set_commonpagesize (default_target, + config.commonpagesize); + ldemul_set_symbols (); - if (link_info.relocateable) + if (link_info.relocatable) { - if (command_line.gc_sections) + if (link_info.gc_sections) einfo ("%P%F: --gc-sections and -r may not be used together\n"); - if (link_info.mpc860c0) - einfo (_("%P%F: -r and --mpc860c0 may not be used together\n")); else if (command_line.relax) einfo (_("%P%F: --relax and -r may not be used together\n")); if (link_info.shared) @@ -304,10 +369,13 @@ main (argc, argv) einfo (_("%P%F: -f may not be used without -shared\n")); } + if (! link_info.shared || link_info.pie) + link_info.executable = TRUE; + /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I don't see how else this can be handled, since in this case we must preserve all externally visible symbols. */ - if (link_info.relocateable && link_info.strip == strip_all) + if (link_info.relocatable && link_info.strip == strip_all) { link_info.strip = strip_debugger; if (link_info.discard == discard_sec_merge) @@ -372,7 +440,7 @@ main (argc, argv) lang_final (); - if (lang_has_input_file == false) + if (!lang_has_input_file) { if (version_printed) xexit (0); @@ -380,9 +448,7 @@ main (argc, argv) } if (trace_files) - { - info_msg (_("%P: mode %s\n"), emulation); - } + info_msg (_("%P: mode %s\n"), emulation); ldemul_after_parse (); @@ -408,8 +474,7 @@ main (argc, argv) /* Print error messages for any missing symbols, for any warning symbols, and possibly multiple definitions. */ - - if (link_info.relocateable) + if (link_info.relocatable) output_bfd->flags &= ~EXEC_P; else output_bfd->flags |= EXEC_P; @@ -423,20 +488,18 @@ main (argc, argv) if (nocrossref_list != NULL) check_nocrossrefs (); - /* Even if we're producing relocateable output, some non-fatal errors should - be reported in the exit status. (What non-fatal errors, if any, do we - want to ignore for relocateable output?) */ + lang_finish (); - if (config.make_executable == false && force_make_executable == false) + /* Even if we're producing relocatable output, some non-fatal errors should + be reported in the exit status. (What non-fatal errors, if any, do we + want to ignore for relocatable output?) */ + if (!config.make_executable && !force_make_executable) { - if (trace_files == true) - { - einfo (_("%P: link errors found, deleting executable `%s'\n"), - output_filename); - } + if (trace_files) + einfo (_("%P: link errors found, deleting executable `%s'\n"), + output_filename); /* The file will be removed by remove_output. */ - xexit (1); } else @@ -447,9 +510,10 @@ main (argc, argv) /* If the --force-exe-suffix is enabled, and we're making an executable file and it doesn't end in .exe, copy it to one which does. */ - if (! link_info.relocateable && command_line.force_exe_suffix) + if (! link_info.relocatable && command_line.force_exe_suffix) { int len = strlen (output_filename); + if (len < 4 || (strcasecmp (output_filename + len - 4, ".exe") != 0 && strcasecmp (output_filename + len - 4, ".dll") != 0)) @@ -460,28 +524,29 @@ main (argc, argv) char *buf = xmalloc (bsize); int l; char *dst_name = xmalloc (len + 5); + strcpy (dst_name, output_filename); strcat (dst_name, ".exe"); src = fopen (output_filename, FOPEN_RB); dst = fopen (dst_name, FOPEN_WB); if (!src) - einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename); + einfo (_("%X%P: unable to open for source of copy `%s'\n"), + output_filename); if (!dst) - einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name); + einfo (_("%X%P: unable to open for destination of copy `%s'\n"), + dst_name); while ((l = fread (buf, 1, bsize, src)) > 0) { int done = fwrite (buf, 1, l, dst); + if (done != l) - { - einfo (_("%P: Error writing file `%s'\n"), dst_name); - } + einfo (_("%P: Error writing file `%s'\n"), dst_name); } + fclose (src); if (fclose (dst) == EOF) - { - einfo (_("%P: Error closing file `%s'\n"), dst_name); - } + einfo (_("%P: Error closing file `%s'\n"), dst_name); free (dst_name); free (buf); } @@ -493,7 +558,7 @@ main (argc, argv) if (config.stats) { #ifdef HAVE_SBRK - char *lim = (char *) sbrk (0); + char *lim = sbrk (0); #endif long run_time = get_run_time () - start_time; @@ -512,13 +577,56 @@ main (argc, argv) return 0; } +/* If the configured sysroot is relocatable, try relocating it based on + default prefix FROM. Return the relocated directory if it exists, + otherwise return null. */ + +static char * +get_relative_sysroot (const char *from ATTRIBUTE_UNUSED) +{ +#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE + char *path; + struct stat s; + + path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT); + if (path) + { + if (stat (path, &s) == 0 && S_ISDIR (s.st_mode)) + return path; + free (path); + } +#endif + return 0; +} + +/* Return the sysroot directory. Return "" if no sysroot is being used. */ + +static const char * +get_sysroot (int argc, char **argv) +{ + int i; + const char *path; + + for (i = 1; i < argc; i++) + if (CONST_STRNEQ (argv[i], "--sysroot=")) + return argv[i] + strlen ("--sysroot="); + + path = get_relative_sysroot (BINDIR); + if (path) + return path; + + path = get_relative_sysroot (TOOLBINDIR); + if (path) + return path; + + return TARGET_SYSTEM_ROOT; +} + /* We need to find any explicitly given emulation in order to initialize the state that's needed by the lex&yacc argument parser (parse_args). */ static char * -get_emulation (argc, argv) - int argc; - char **argv; +get_emulation (int argc, char **argv) { char *emulation; int i; @@ -529,7 +637,7 @@ get_emulation (argc, argv) for (i = 1; i < argc; i++) { - if (!strncmp (argv[i], "-m", 2)) + if (CONST_STRNEQ (argv[i], "-m")) { if (argv[i][2] == '\0') { @@ -540,17 +648,17 @@ get_emulation (argc, argv) i++; } else - { - einfo (_("%P%F: missing argument to -m\n")); - } + einfo (_("%P%F: missing argument to -m\n")); } else if (strcmp (argv[i], "-mips1") == 0 || strcmp (argv[i], "-mips2") == 0 || strcmp (argv[i], "-mips3") == 0 + || strcmp (argv[i], "-mips4") == 0 + || strcmp (argv[i], "-mips5") == 0 || strcmp (argv[i], "-mips32") == 0 + || strcmp (argv[i], "-mips32r2") == 0 || strcmp (argv[i], "-mips64") == 0 - || strcmp (argv[i], "-mips4") == 0 - || strcmp (argv[i], "-mips5") == 0) + || strcmp (argv[i], "-mips64r2") == 0) { /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are passed to the linker by some MIPS compilers. They @@ -578,27 +686,26 @@ get_emulation (argc, argv) } /* If directory DIR contains an "ldscripts" subdirectory, - add DIR to the library search path and return true, - else return false. */ + add DIR to the library search path and return TRUE, + else return FALSE. */ -static boolean -check_for_scripts_dir (dir) - char *dir; +static bfd_boolean +check_for_scripts_dir (char *dir) { size_t dirlen; char *buf; struct stat s; - boolean res; + bfd_boolean res; dirlen = strlen (dir); /* sizeof counts the terminating NUL. */ - buf = (char *) xmalloc (dirlen + sizeof ("/ldscripts")); + buf = xmalloc (dirlen + sizeof ("/ldscripts")); sprintf (buf, "%s/ldscripts", dir); res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode); free (buf); if (res) - ldfile_add_library_path (dir, false); + ldfile_add_library_path (dir, FALSE); return res; } @@ -606,15 +713,37 @@ check_for_scripts_dir (dir) Libraries will be searched for here too, but that's ok. We look for the "ldscripts" directory in: + SCRIPTDIR (passed from Makefile) + (adjusted according to the current location of the binary) SCRIPTDIR (passed from Makefile) the dir where this program is (for using it from the build tree) - the dir where this program is/../lib (for installing the tool suite elsewhere) */ + the dir where this program is/../lib + (for installing the tool suite elsewhere). */ static void -set_scripts_dir () +set_scripts_dir (void) { char *end, *dir; size_t dirlen; + bfd_boolean found; + + dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR); + if (dir) + { + found = check_for_scripts_dir (dir); + free (dir); + if (found) + return; + } + + dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR); + if (dir) + { + found = check_for_scripts_dir (dir); + free (dir); + if (found) + return; + } if (check_for_scripts_dir (SCRIPTDIR)) /* We've been installed normally. */ @@ -626,81 +755,76 @@ set_scripts_dir () { /* We could have \foo\bar, or /foo\bar. */ char *bslash = strrchr (program_name, '\\'); + if (end == NULL || (bslash != NULL && bslash > end)) end = bslash; } #endif if (end == NULL) - { - /* Don't look for ldscripts in the current directory. There is - too much potential for confusion. */ - return; - } + /* Don't look for ldscripts in the current directory. There is + too much potential for confusion. */ + return; dirlen = end - program_name; /* Make a copy of program_name in dir. Leave room for later "/../lib". */ - dir = (char *) xmalloc (dirlen + 8); + dir = xmalloc (dirlen + 8); strncpy (dir, program_name, dirlen); dir[dirlen] = '\0'; if (check_for_scripts_dir (dir)) - /* Don't free dir. */ - return; + { + free (dir); + return; + } /* Look for "ldscripts" in /../lib. */ strcpy (dir + dirlen, "/../lib"); - if (check_for_scripts_dir (dir)) - return; - - /* Well, we tried. */ + check_for_scripts_dir (dir); free (dir); } void -add_ysym (name) - const char *name; +add_ysym (const char *name) { - if (link_info.notice_hash == (struct bfd_hash_table *) NULL) + if (link_info.notice_hash == NULL) { - link_info.notice_hash = ((struct bfd_hash_table *) - xmalloc (sizeof (struct bfd_hash_table))); - if (! bfd_hash_table_init_n (link_info.notice_hash, - bfd_hash_newfunc, - 61)) + link_info.notice_hash = xmalloc (sizeof (struct bfd_hash_table)); + if (!bfd_hash_table_init_n (link_info.notice_hash, + bfd_hash_newfunc, + sizeof (struct bfd_hash_entry), + 61)) einfo (_("%P%F: bfd_hash_table_init failed: %E\n")); } - if (bfd_hash_lookup (link_info.notice_hash, name, true, true) - == (struct bfd_hash_entry *) NULL) + if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL) einfo (_("%P%F: bfd_hash_lookup failed: %E\n")); } /* Record a symbol to be wrapped, from the --wrap option. */ void -add_wrap (name) - const char *name; +add_wrap (const char *name) { if (link_info.wrap_hash == NULL) { - link_info.wrap_hash = ((struct bfd_hash_table *) - xmalloc (sizeof (struct bfd_hash_table))); - if (! bfd_hash_table_init_n (link_info.wrap_hash, - bfd_hash_newfunc, - 61)) + link_info.wrap_hash = xmalloc (sizeof (struct bfd_hash_table)); + if (!bfd_hash_table_init_n (link_info.wrap_hash, + bfd_hash_newfunc, + sizeof (struct bfd_hash_entry), + 61)) einfo (_("%P%F: bfd_hash_table_init failed: %E\n")); } - if (bfd_hash_lookup (link_info.wrap_hash, name, true, true) == NULL) + + if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL) einfo (_("%P%F: bfd_hash_lookup failed: %E\n")); } /* Handle the -retain-symbols-file option. */ void -add_keepsyms_file (filename) - const char *filename; +add_keepsyms_file (const char *filename) { FILE *file; char *buf; @@ -711,20 +835,20 @@ add_keepsyms_file (filename) einfo (_("%X%P: error: duplicate retain-symbols-file\n")); file = fopen (filename, "r"); - if (file == (FILE *) NULL) + if (file == NULL) { bfd_set_error (bfd_error_system_call); einfo ("%X%P: %s: %E\n", filename); return; } - link_info.keep_hash = ((struct bfd_hash_table *) - xmalloc (sizeof (struct bfd_hash_table))); - if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc)) + link_info.keep_hash = xmalloc (sizeof (struct bfd_hash_table)); + if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc, + sizeof (struct bfd_hash_entry))) einfo (_("%P%F: bfd_hash_table_init failed: %E\n")); bufsize = 100; - buf = (char *) xmalloc (bufsize); + buf = xmalloc (bufsize); c = getc (file); while (c != EOF) @@ -750,8 +874,7 @@ add_keepsyms_file (filename) buf[len] = '\0'; - if (bfd_hash_lookup (link_info.keep_hash, buf, true, true) - == (struct bfd_hash_entry *) NULL) + if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL) einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n")); } } @@ -759,6 +882,7 @@ add_keepsyms_file (filename) if (link_info.strip != strip_none) einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n")); + free (buf); link_info.strip = strip_some; } @@ -767,24 +891,22 @@ add_keepsyms_file (filename) /* This is called when BFD has decided to include an archive member in a link. */ -static boolean -add_archive_element (info, abfd, name) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - bfd *abfd; - const char *name; +static bfd_boolean +add_archive_element (struct bfd_link_info *info, + bfd *abfd, + const char *name) { lang_input_statement_type *input; - input = ((lang_input_statement_type *) - xmalloc (sizeof (lang_input_statement_type))); + input = xmalloc (sizeof (lang_input_statement_type)); input->filename = abfd->filename; input->local_sym_name = abfd->filename; input->the_bfd = abfd; input->asymbols = NULL; input->next = NULL; - input->just_syms_flag = false; - input->loaded = false; - input->search_dirs_flag = false; + input->just_syms_flag = FALSE; + input->loaded = FALSE; + input->search_dirs_flag = FALSE; /* FIXME: The following fields are not set: header.next, header.type, closed, passive_position, symbol_count, @@ -794,14 +916,14 @@ add_archive_element (info, abfd, name) ldlang_add_file (input); - if (config.map_file != (FILE *) NULL) + if (config.map_file != NULL) { - static boolean header_printed; + static bfd_boolean header_printed; struct bfd_link_hash_entry *h; bfd *from; int len; - h = bfd_link_hash_lookup (link_info.hash, name, false, false, true); + h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); if (h == NULL) from = NULL; @@ -835,7 +957,7 @@ add_archive_element (info, abfd, name) sprintf (buf, _("Archive member included because of file (symbol)\n\n")); minfo ("%s", buf); - header_printed = true; + header_printed = TRUE; } if (bfd_my_archive (abfd) == NULL) @@ -874,22 +996,21 @@ add_archive_element (info, abfd, name) if (trace_files || trace_file_tries) info_msg ("%I\n", input); - return true; + return TRUE; } /* This is called when BFD has discovered a symbol which is defined multiple times. */ -static boolean -multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - const char *name; - bfd *obfd; - asection *osec; - bfd_vma oval; - bfd *nbfd; - asection *nsec; - bfd_vma nval; +static bfd_boolean +multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED, + const char *name, + bfd *obfd, + asection *osec, + bfd_vma oval, + bfd *nbfd, + asection *nsec, + bfd_vma nval) { /* If either section has the output_section field set to bfd_abs_section_ptr, it means that the section is being @@ -902,11 +1023,11 @@ multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval) || (nsec->output_section != NULL && ! bfd_is_abs_section (nsec) && bfd_is_abs_section (nsec->output_section))) - return true; + return TRUE; einfo (_("%X%C: multiple definition of `%T'\n"), nbfd, nsec, nval, name); - if (obfd != (bfd *) NULL) + if (obfd != NULL) einfo (_("%D: first defined here\n"), obfd, osec, oval); if (command_line.relax) @@ -915,7 +1036,7 @@ multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval) command_line.relax = 0; } - return true; + return TRUE; } /* This is called when there is a definition of a common symbol, or @@ -923,19 +1044,18 @@ multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval) or when two common symbols are found. We only do something if -warn-common was used. */ -static boolean -multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - const char *name; - bfd *obfd; - enum bfd_link_hash_type otype; - bfd_vma osize; - bfd *nbfd; - enum bfd_link_hash_type ntype; - bfd_vma nsize; +static bfd_boolean +multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED, + const char *name, + bfd *obfd, + enum bfd_link_hash_type otype, + bfd_vma osize, + bfd *nbfd, + enum bfd_link_hash_type ntype, + bfd_vma nsize) { if (! config.warn_common) - return true; + return TRUE; if (ntype == bfd_link_hash_defined || ntype == bfd_link_hash_defweak @@ -982,30 +1102,29 @@ multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize) } } - return true; + return TRUE; } /* This is called when BFD has discovered a set element. H is the entry in the linker hash table for the set. SECTION and VALUE represent a value which should be added to the set. */ -static boolean -add_to_set (info, h, reloc, abfd, section, value) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - struct bfd_link_hash_entry *h; - bfd_reloc_code_real_type reloc; - bfd *abfd; - asection *section; - bfd_vma value; +static bfd_boolean +add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED, + struct bfd_link_hash_entry *h, + bfd_reloc_code_real_type reloc, + bfd *abfd, + asection *section, + bfd_vma value) { if (config.warn_constructors) einfo (_("%P: warning: global constructor %s used\n"), h->root.string); if (! config.build_constructors) - return true; + return TRUE; - ldctor_add_set_entry (h, reloc, (const char *) NULL, section, value); + ldctor_add_set_entry (h, reloc, NULL, section, value); if (h->type == bfd_link_hash_new) { @@ -1016,7 +1135,7 @@ add_to_set (info, h, reloc, abfd, section, value) ourselves. */ } - return true; + return TRUE; } /* This is called when BFD has discovered a constructor. This is only @@ -1024,14 +1143,13 @@ add_to_set (info, h, reloc, abfd, section, value) constructors in some more clever fashion. This is similar to adding an element to a set, but less general. */ -static boolean -constructor_callback (info, constructor, name, abfd, section, value) - struct bfd_link_info *info; - boolean constructor; - const char *name; - bfd *abfd; - asection *section; - bfd_vma value; +static bfd_boolean +constructor_callback (struct bfd_link_info *info, + bfd_boolean constructor, + const char *name, + bfd *abfd, + asection *section, + bfd_vma value) { char *s; struct bfd_link_hash_entry *h; @@ -1041,12 +1159,12 @@ constructor_callback (info, constructor, name, abfd, section, value) einfo (_("%P: warning: global constructor %s used\n"), name); if (! config.build_constructors) - return true; + return TRUE; /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a useful error message. */ if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL - && (link_info.relocateable + && (info->relocatable || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL)) einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n")); @@ -1058,7 +1176,7 @@ constructor_callback (info, constructor, name, abfd, section, value) else strcpy (s, "__DTOR_LIST__"); - h = bfd_link_hash_lookup (info->hash, set_name, true, true, true); + h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE); if (h == (struct bfd_link_hash_entry *) NULL) einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); if (h->type == bfd_link_hash_new) @@ -1071,14 +1189,15 @@ constructor_callback (info, constructor, name, abfd, section, value) } ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value); - return true; + return TRUE; } /* A structure used by warning_callback to pass information through bfd_map_over_sections. */ -struct warning_callback_info { - boolean found; +struct warning_callback_info +{ + bfd_boolean found; const char *warning; const char *symbol; asymbol **asymbols; @@ -1086,27 +1205,26 @@ struct warning_callback_info { /* This is called when there is a reference to a warning symbol. */ -static boolean -warning_callback (info, warning, symbol, abfd, section, address) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - const char *warning; - const char *symbol; - bfd *abfd; - asection *section; - bfd_vma address; +static bfd_boolean +warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED, + const char *warning, + const char *symbol, + bfd *abfd, + asection *section, + bfd_vma address) { /* This is a hack to support warn_multiple_gp. FIXME: This should have a cleaner interface, but what? */ if (! config.warn_multiple_gp && strcmp (warning, "using multiple gp values") == 0) - return true; + return TRUE; if (section != NULL) - einfo ("%C: %s\n", abfd, section, address, warning); + einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning); else if (abfd == NULL) - einfo ("%P: %s\n", warning); + einfo ("%P: %s%s\n", _("warning: "), warning); else if (symbol == NULL) - einfo ("%B: %s\n", abfd, warning); + einfo ("%B: %s%s\n", abfd, _("warning: "), warning); else { lang_input_statement_type *entry; @@ -1115,7 +1233,6 @@ warning_callback (info, warning, symbol, abfd, section, address) /* Look through the relocs to see if we can find a plausible address. */ - entry = (lang_input_statement_type *) abfd->usrdata; if (entry != NULL && entry->asymbols != NULL) asymbols = entry->asymbols; @@ -1127,7 +1244,7 @@ warning_callback (info, warning, symbol, abfd, section, address) symsize = bfd_get_symtab_upper_bound (abfd); if (symsize < 0) einfo (_("%B%F: could not read symbols: %E\n"), abfd); - asymbols = (asymbol **) xmalloc (symsize); + asymbols = xmalloc (symsize); symbol_count = bfd_canonicalize_symtab (abfd, asymbols); if (symbol_count < 0) einfo (_("%B%F: could not read symbols: %E\n"), abfd); @@ -1138,20 +1255,20 @@ warning_callback (info, warning, symbol, abfd, section, address) } } - info.found = false; + info.found = FALSE; info.warning = warning; info.symbol = symbol; info.asymbols = asymbols; - bfd_map_over_sections (abfd, warning_find_reloc, (PTR) &info); + bfd_map_over_sections (abfd, warning_find_reloc, &info); if (! info.found) - einfo ("%B: %s\n", abfd, warning); + einfo ("%B: %s%s\n", abfd, _("warning: "), warning); if (entry == NULL) free (asymbols); } - return true; + return TRUE; } /* This is called by warning_callback for each section. It checks the @@ -1160,12 +1277,9 @@ warning_callback (info, warning, symbol, abfd, section, address) to give an error message with a file and line number. */ static void -warning_find_reloc (abfd, sec, iarg) - bfd *abfd; - asection *sec; - PTR iarg; +warning_find_reloc (bfd *abfd, asection *sec, void *iarg) { - struct warning_callback_info *info = (struct warning_callback_info *) iarg; + struct warning_callback_info *info = iarg; long relsize; arelent **relpp; long relcount; @@ -1180,7 +1294,7 @@ warning_find_reloc (abfd, sec, iarg) if (relsize == 0) return; - relpp = (arelent **) xmalloc (relsize); + relpp = xmalloc (relsize); relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols); if (relcount < 0) einfo (_("%B%F: could not read relocs: %E\n"), abfd); @@ -1196,8 +1310,9 @@ warning_find_reloc (abfd, sec, iarg) && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0) { /* We found a reloc for the symbol we are looking for. */ - einfo ("%C: %s\n", abfd, sec, q->address, info->warning); - info->found = true; + einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "), + info->warning); + info->found = TRUE; break; } } @@ -1207,14 +1322,13 @@ warning_find_reloc (abfd, sec, iarg) /* This is called when an undefined symbol is found. */ -static boolean -undefined_symbol (info, name, abfd, section, address, fatal) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - const char *name; - bfd *abfd; - asection *section; - bfd_vma address; - boolean fatal ATTRIBUTE_UNUSED; +static bfd_boolean +undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED, + const char *name, + bfd *abfd, + asection *section, + bfd_vma address, + bfd_boolean error) { static char *error_name; static unsigned int error_count; @@ -1226,31 +1340,30 @@ undefined_symbol (info, name, abfd, section, address, fatal) static struct bfd_hash_table *hash; /* Only warn once about a particular undefined symbol. */ - if (hash == NULL) { - hash = ((struct bfd_hash_table *) - xmalloc (sizeof (struct bfd_hash_table))); - if (! bfd_hash_table_init (hash, bfd_hash_newfunc)) + hash = xmalloc (sizeof (struct bfd_hash_table)); + if (!bfd_hash_table_init (hash, bfd_hash_newfunc, + sizeof (struct bfd_hash_entry))) einfo (_("%F%P: bfd_hash_table_init failed: %E\n")); } - if (bfd_hash_lookup (hash, name, false, false) != NULL) - return true; + if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL) + return TRUE; - if (bfd_hash_lookup (hash, name, true, true) == NULL) + if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL) einfo (_("%F%P: bfd_hash_lookup failed: %E\n")); } /* We never print more than a reasonable number of errors in a row for a single symbol. */ - if (error_name != (char *) NULL + if (error_name != NULL && strcmp (name, error_name) == 0) ++error_count; else { error_count = 0; - if (error_name != (char *) NULL) + if (error_name != NULL) free (error_name); error_name = xstrdup (name); } @@ -1259,107 +1372,169 @@ undefined_symbol (info, name, abfd, section, address, fatal) { if (error_count < MAX_ERRORS_IN_A_ROW) { - einfo (_("%C: undefined reference to `%T'\n"), - abfd, section, address, name); - if (fatal) - einfo ("%X"); + if (error) + einfo (_("%X%C: undefined reference to `%T'\n"), + abfd, section, address, name); + else + einfo (_("%C: warning: undefined reference to `%T'\n"), + abfd, section, address, name); } else if (error_count == MAX_ERRORS_IN_A_ROW) - einfo (_("%D: more undefined references to `%T' follow\n"), - abfd, section, address, name); + { + if (error) + einfo (_("%X%D: more undefined references to `%T' follow\n"), + abfd, section, address, name); + else + einfo (_("%D: warning: more undefined references to `%T' follow\n"), + abfd, section, address, name); + } + else if (error) + einfo ("%X"); } else { if (error_count < MAX_ERRORS_IN_A_ROW) { - einfo (_("%B: undefined reference to `%T'\n"), - abfd, name); - if (fatal) - einfo ("%X"); + if (error) + einfo (_("%X%B: undefined reference to `%T'\n"), + abfd, name); + else + einfo (_("%B: warning: undefined reference to `%T'\n"), + abfd, name); } else if (error_count == MAX_ERRORS_IN_A_ROW) - einfo (_("%B: more undefined references to `%T' follow\n"), - abfd, name); + { + if (error) + einfo (_("%X%B: more undefined references to `%T' follow\n"), + abfd, name); + else + einfo (_("%B: warning: more undefined references to `%T' follow\n"), + abfd, name); + } + else if (error) + einfo ("%X"); } - return true; + return TRUE; } +/* Counter to limit the number of relocation overflow error messages + to print. Errors are printed as it is decremented. When it's + called and the counter is zero, a final message is printed + indicating more relocations were omitted. When it gets to -1, no + such errors are printed. If it's initially set to a value less + than -1, all such errors will be printed (--verbose does this). */ + +int overflow_cutoff_limit = 10; + /* This is called when a reloc overflows. */ -static boolean -reloc_overflow (info, name, reloc_name, addend, abfd, section, address) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - const char *name; - const char *reloc_name; - bfd_vma addend; - bfd *abfd; - asection *section; - bfd_vma address; +static bfd_boolean +reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED, + struct bfd_link_hash_entry *entry, + const char *name, + const char *reloc_name, + bfd_vma addend, + bfd *abfd, + asection *section, + bfd_vma address) { - if (abfd == (bfd *) NULL) - einfo (_("%P%X: generated")); + if (overflow_cutoff_limit == -1) + return TRUE; + + einfo ("%X%C:", abfd, section, address); + + if (overflow_cutoff_limit >= 0 + && overflow_cutoff_limit-- == 0) + { + einfo (_(" additional relocation overflows omitted from the output\n")); + return TRUE; + } + + if (entry) + { + while (entry->type == bfd_link_hash_indirect + || entry->type == bfd_link_hash_warning) + entry = entry->u.i.link; + switch (entry->type) + { + case bfd_link_hash_undefined: + case bfd_link_hash_undefweak: + einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"), + reloc_name, entry->root.string); + break; + case bfd_link_hash_defined: + case bfd_link_hash_defweak: + einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"), + reloc_name, entry->root.string, + entry->u.def.section, + entry->u.def.section == bfd_abs_section_ptr + ? output_bfd : entry->u.def.section->owner); + break; + default: + abort (); + break; + } + } else - einfo ("%X%C:", abfd, section, address); - einfo (_(" relocation truncated to fit: %s %T"), reloc_name, name); + einfo (_(" relocation truncated to fit: %s against `%T'"), + reloc_name, name); if (addend != 0) einfo ("+%v", addend); einfo ("\n"); - return true; + return TRUE; } /* This is called when a dangerous relocation is made. */ -static boolean -reloc_dangerous (info, message, abfd, section, address) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - const char *message; - bfd *abfd; - asection *section; - bfd_vma address; +static bfd_boolean +reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED, + const char *message, + bfd *abfd, + asection *section, + bfd_vma address) { - if (abfd == (bfd *) NULL) - einfo (_("%P%X: generated")); - else - einfo ("%X%C:", abfd, section, address); - einfo (_("dangerous relocation: %s\n"), message); - return true; + einfo (_("%X%C: dangerous relocation: %s\n"), + abfd, section, address, message); + return TRUE; } /* This is called when a reloc is being generated attached to a symbol that is not being output. */ -static boolean -unattached_reloc (info, name, abfd, section, address) - struct bfd_link_info *info ATTRIBUTE_UNUSED; - const char *name; - bfd *abfd; - asection *section; - bfd_vma address; +static bfd_boolean +unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED, + const char *name, + bfd *abfd, + asection *section, + bfd_vma address) { - if (abfd == (bfd *) NULL) - einfo (_("%P%X: generated")); - else - einfo ("%X%C:", abfd, section, address); - einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name); - return true; + einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"), + abfd, section, address, name); + return TRUE; } /* This is called if link_info.notice_all is set, or when a symbol in link_info.notice_hash is found. Symbols are put in notice_hash using the -y option. */ -static boolean -notice (info, name, abfd, section, value) - struct bfd_link_info *info; - const char *name; - bfd *abfd; - asection *section; - bfd_vma value; +static bfd_boolean +notice (struct bfd_link_info *info, + const char *name, + bfd *abfd, + asection *section, + bfd_vma value) { + if (name == NULL) + { + if (command_line.cref || nocrossref_list != NULL) + return handle_asneeded_cref (abfd, value); + return TRUE; + } + if (! info->notice_all || (info->notice_hash != NULL - && bfd_hash_lookup (info->notice_hash, name, false, false) != NULL)) + && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)) { if (bfd_is_und_section (section)) einfo ("%B: reference to %s\n", abfd, name); @@ -1370,5 +1545,5 @@ notice (info, name, abfd, section, value) if (command_line.cref || nocrossref_list != NULL) add_cref (name, abfd, section, value); - return true; + return TRUE; }