/* Main program of GNU linker.
- Copyright (C) 1991-2019 Free Software Foundation, Inc.
+ Copyright (C) 1991-2021 Free Software Foundation, Inc.
Written by Steve Chamberlain steve@cygnus.com
This file is part of the GNU Binutils.
#include "libiberty.h"
#include "progress.h"
#include "bfdlink.h"
+#include "ctf-api.h"
#include "filenames.h"
+#include "elf/common.h"
#include "ld.h"
#include "ldmain.h"
#include "ldfile.h"
#include "ldemul.h"
#include "ldctor.h"
-#ifdef ENABLE_PLUGINS
+#if BFD_SUPPORTS_PLUGINS
#include "plugin.h"
#include "plugin-api.h"
-#endif /* ENABLE_PLUGINS */
+#endif /* BFD_SUPPORTS_PLUGINS */
/* Somewhere above, sys/stat.h got included. */
#if !defined(S_ISDIR) && defined(S_IFDIR)
FILE *saved_script_handle = NULL;
FILE *previous_script_handle = NULL;
-bfd_boolean force_make_executable = FALSE;
+bool force_make_executable = false;
char *default_target;
const char *output_filename = "a.out";
unsigned int trace_files;
/* Nonzero means report actions taken by the linker, and describe the linker script in use. */
-bfd_boolean verbose;
+bool verbose;
/* Nonzero means version number was printed, so exit successfully
instead of complaining if no input files are given. */
-bfd_boolean version_printed;
+bool version_printed;
/* TRUE if we should demangle symbol names. */
-bfd_boolean demangling;
+bool demangling;
args_type command_line;
(int, char **);
static char *get_emulation
(int, char **);
-static bfd_boolean add_archive_element
+static bool add_archive_element
(struct bfd_link_info *, bfd *, const char *, bfd **);
static void multiple_definition
(struct bfd_link_info *, struct bfd_link_hash_entry *,
(struct bfd_link_info *, struct bfd_link_hash_entry *,
bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
static void constructor_callback
- (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
+ (struct bfd_link_info *, bool, const char *, bfd *,
asection *, bfd_vma);
static void warning_callback
(struct bfd_link_info *, const char *, const char *, bfd *,
(bfd *, asection *, void *);
static void undefined_symbol
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
- bfd_boolean);
+ bool);
static void reloc_overflow
(struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
const char *, bfd_vma, bfd *, asection *, bfd_vma);
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
static void unattached_reloc
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
-static bfd_boolean notice
+static bool notice
(struct bfd_link_info *, struct bfd_link_hash_entry *,
struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
einfo,
info_msg,
minfo,
- ldlang_override_segment_assignment
+ ldlang_override_segment_assignment,
+ ldlang_ctf_acquire_strings,
+ NULL,
+ ldlang_ctf_new_dynsym,
+ ldlang_write_ctf_late
};
static bfd_assert_handler_type default_bfd_assert_handler;
struct bfd_link_info link_info;
\f
+struct dependency_file
+{
+ struct dependency_file *next;
+ char *name;
+};
+
+static struct dependency_file *dependency_files, *dependency_files_tail;
+
+void
+track_dependency_files (const char *filename)
+{
+ struct dependency_file *dep
+ = (struct dependency_file *) xmalloc (sizeof (*dep));
+ dep->name = xstrdup (filename);
+ dep->next = NULL;
+ if (dependency_files == NULL)
+ dependency_files = dep;
+ else
+ dependency_files_tail->next = dep;
+ dependency_files_tail = dep;
+}
+
+static void
+write_dependency_file (void)
+{
+ FILE *out;
+ struct dependency_file *dep;
+
+ out = fopen (config.dependency_file, FOPEN_WT);
+ if (out == NULL)
+ {
+ einfo (_("%F%P: cannot open dependency file %s: %E\n"),
+ config.dependency_file);
+ }
+
+ fprintf (out, "%s:", output_filename);
+
+ for (dep = dependency_files; dep != NULL; dep = dep->next)
+ fprintf (out, " \\\n %s", dep->name);
+
+ fprintf (out, "\n");
+ for (dep = dependency_files; dep != NULL; dep = dep->next)
+ fprintf (out, "\n%s:\n", dep->name);
+
+ fclose (out);
+}
+\f
static void
ld_cleanup (void)
{
bfd_cache_close_all ();
-#ifdef ENABLE_PLUGINS
+#if BFD_SUPPORTS_PLUGINS
plugin_call_cleanup ();
#endif
if (output_filename && delete_output_file_on_failure)
ld_bfd_assert_handler (const char *fmt, const char *bfdver,
const char *file, int line)
{
- config.make_executable = FALSE;
+ config.make_executable = false;
(*default_bfd_assert_handler) (fmt, bfdver, file, line);
}
ld_bfd_error_handler (const char *fmt, va_list ap)
{
if (config.fatal_warnings)
- config.make_executable = FALSE;
+ config.make_executable = false;
(*default_bfd_error_handler) (fmt, ap);
}
char *emulation;
long start_time = get_run_time ();
-#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+#ifdef HAVE_LC_MESSAGES
setlocale (LC_MESSAGES, "");
#endif
-#if defined (HAVE_SETLOCALE)
setlocale (LC_CTYPE, "");
-#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* is_sysrooted_pathname() relies on no trailing dirsep. */
if (ld_canon_sysroot_len > 0
&& IS_DIR_SEPARATOR (ld_canon_sysroot [ld_canon_sysroot_len - 1]))
- ld_canon_sysroot [--ld_canon_sysroot_len] = '\0';
+ ld_canon_sysroot [--ld_canon_sysroot_len] = '\0';
}
else
ld_canon_sysroot_len = -1;
}
#endif
- config.build_constructors = TRUE;
+ config.build_constructors = true;
config.rpath_separator = ':';
config.split_by_reloc = (unsigned) -1;
config.split_by_file = (bfd_size_type) -1;
- config.make_executable = TRUE;
- config.magic_demand_paged = TRUE;
- config.text_read_only = TRUE;
- config.print_map_discarded = TRUE;
+ config.make_executable = true;
+ config.magic_demand_paged = true;
+ config.text_read_only = true;
+ config.print_map_discarded = true;
link_info.disable_target_specific_optimizations = -1;
- command_line.warn_mismatch = TRUE;
- command_line.warn_search_mismatch = TRUE;
+ command_line.warn_mismatch = true;
+ command_line.warn_search_mismatch = true;
command_line.check_section_addresses = -1;
/* We initialize DEMANGLING based on the environment variable
interface by default. */
demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
- link_info.allow_undefined_version = TRUE;
- link_info.keep_memory = TRUE;
- link_info.combreloc = TRUE;
- link_info.strip_discarded = TRUE;
- link_info.prohibit_multiple_definition_absolute = FALSE;
+ link_info.allow_undefined_version = true;
+ link_info.keep_memory = true;
+ link_info.combreloc = true;
+ link_info.strip_discarded = true;
+ link_info.prohibit_multiple_definition_absolute = false;
+ link_info.textrel_check = DEFAULT_LD_TEXTREL_CHECK;
link_info.emit_hash = DEFAULT_EMIT_SYSV_HASH;
link_info.emit_gnu_hash = DEFAULT_EMIT_GNU_HASH;
link_info.callbacks = &link_callbacks;
#ifdef DEFAULT_NEW_DTAGS
link_info.new_dtags = DEFAULT_NEW_DTAGS;
#endif
+ link_info.start_stop_gc = false;
+ link_info.start_stop_visibility = STV_PROTECTED;
ldfile_add_arch ("");
emulation = get_emulation (argc, argv);
lang_init ();
ldexp_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);
-#ifdef ENABLE_PLUGINS
+#if BFD_SUPPORTS_PLUGINS
/* Now all the plugin arguments have been gathered, we can load them. */
plugin_load_plugins ();
-#endif /* ENABLE_PLUGINS */
+#endif /* BFD_SUPPORTS_PLUGINS */
ldemul_set_symbols ();
if (command_line.force_group_allocation
|| !bfd_link_relocatable (&link_info))
- link_info.resolve_section_groups = TRUE;
+ link_info.resolve_section_groups = true;
else
- link_info.resolve_section_groups = FALSE;
+ link_info.resolve_section_groups = false;
if (command_line.print_output_format)
info_msg ("%s\n", lang_get_output_target ());
config.map_filename);
}
}
- link_info.has_map_file = TRUE;
+ link_info.has_map_file = true;
}
lang_process ();
ldexp_finish ();
lang_finish ();
+ if (config.dependency_file != NULL)
+ write_dependency_file ();
+
/* 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?) */
const char *path = NULL;
for (i = 1; i < argc; i++)
- if (CONST_STRNEQ (argv[i], "--sysroot="))
+ if (startswith (argv[i], "--sysroot="))
path = argv[i] + strlen ("--sysroot=");
if (!path)
for (i = 1; i < argc; i++)
{
- if (CONST_STRNEQ (argv[i], "-m"))
+ if (startswith (argv[i], "-m"))
{
if (argv[i][2] == '\0')
{
|| strcmp (argv[i], "-mips5") == 0
|| strcmp (argv[i], "-mips32") == 0
|| strcmp (argv[i], "-mips32r2") == 0
+ || strcmp (argv[i], "-mips32r3") == 0
+ || strcmp (argv[i], "-mips32r5") == 0
|| strcmp (argv[i], "-mips32r6") == 0
|| strcmp (argv[i], "-mips64") == 0
|| strcmp (argv[i], "-mips64r2") == 0
+ || strcmp (argv[i], "-mips64r3") == 0
+ || strcmp (argv[i], "-mips64r5") == 0
|| strcmp (argv[i], "-mips64r6") == 0)
{
/* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
}
- if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
+ if (bfd_hash_lookup (link_info.notice_hash, name, true, true) == NULL)
einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
}
einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
}
- if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
+ if (bfd_hash_lookup (info->ignore_hash, name, true, true) == NULL)
einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
}
einfo (_("%F%P: 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 (_("%F%P: bfd_hash_lookup failed: %E\n"));
}
buf[len] = '\0';
- if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
+ if (bfd_hash_lookup (link_info.keep_hash, buf, true, true) == NULL)
einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
}
}
/* This is called when BFD has decided to include an archive member in
a link. */
-static bfd_boolean
+static bool
add_archive_element (struct bfd_link_info *info,
bfd *abfd,
const char *name,
input = (lang_input_statement_type *)
xcalloc (1, sizeof (lang_input_statement_type));
input->header.type = lang_input_statement_enum;
- input->filename = abfd->filename;
- input->local_sym_name = abfd->filename;
+ input->filename = bfd_get_filename (abfd);
+ input->local_sym_name = bfd_get_filename (abfd);
input->the_bfd = abfd;
- parent = bfd_usrdata (abfd->my_archive);
- if (parent != NULL && !parent->flags.reload)
- parent->next = input;
-
/* Save the original data for trace files/tries below, as plugins
(if enabled) may possibly alter it to point to a replacement
BFD, but we still want to output the original BFD filename. */
orig_input = *input;
-#ifdef ENABLE_PLUGINS
+#if BFD_SUPPORTS_PLUGINS
if (link_info.lto_plugin_active)
{
/* We must offer this archive member to the plugins to claim. */
/* Don't claim new IR symbols after all IR symbols have
been claimed. */
if (verbose)
- info_msg ("%pI: no new IR symbols to claimi\n",
+ info_msg ("%pI: no new IR symbols to claim\n",
&orig_input);
input->flags.claimed = 0;
- return FALSE;
+ return false;
}
- input->flags.claim_archive = TRUE;
+ input->flags.claim_archive = true;
*subsbfd = input->the_bfd;
}
}
-#endif /* ENABLE_PLUGINS */
+#endif /* BFD_SUPPORTS_PLUGINS */
+
+ if (link_info.input_bfds_tail == &input->the_bfd->link.next
+ || input->the_bfd->link.next != NULL)
+ {
+ /* We have already loaded this element, and are attempting to
+ load it again. This can happen when the archive map doesn't
+ match actual symbols defined by the element. */
+ free (input);
+ bfd_set_error (bfd_error_malformed_archive);
+ return false;
+ }
+
+ /* Set the file_chain pointer of archives to the last element loaded
+ from the archive. See ldlang.c:find_rescan_insertion. */
+ parent = bfd_usrdata (abfd->my_archive);
+ if (parent != NULL && !parent->flags.reload)
+ parent->next = input;
ldlang_add_file (input);
if (config.map_file != NULL)
{
- static bfd_boolean header_printed;
+ static bool header_printed;
struct bfd_link_hash_entry *h;
bfd *from;
int len;
- h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
+ h = bfd_link_hash_lookup (info->hash, name, false, false, true);
if (h == NULL
&& info->pei386_auto_import
- && CONST_STRNEQ (name, "__imp_"))
- h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
+ && startswith (name, "__imp_"))
+ h = bfd_link_hash_lookup (info->hash, name + 6, false, false, true);
if (h == NULL)
from = NULL;
if (!header_printed)
{
minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
- header_printed = TRUE;
+ header_printed = true;
}
if (abfd->my_archive == NULL
|| trace_files > 1
|| (trace_files && bfd_is_thin_archive (orig_input.the_bfd->my_archive)))
info_msg ("%pI\n", &orig_input);
- return TRUE;
+ return true;
}
/* This is called when BFD has discovered a symbol which is defined
nval = oval;
obfd = NULL;
}
- einfo (_("%X%P: %C: multiple definition of `%pT'"),
- nbfd, nsec, nval, name);
+ if (info->warn_multiple_definition)
+ einfo (_("%P: %C: warning: multiple definition of `%pT'"),
+ nbfd, nsec, nval, name);
+ else
+ einfo (_("%X%P: %C: multiple definition of `%pT'"),
+ nbfd, nsec, nval, name);
if (obfd != NULL)
einfo (_("; %D: first defined here"), obfd, osec, oval);
einfo ("\n");
static void
constructor_callback (struct bfd_link_info *info,
- bfd_boolean constructor,
+ bool constructor,
const char *name,
bfd *abfd,
asection *section,
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 (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
if (h->type == bfd_link_hash_new)
struct warning_callback_info
{
- bfd_boolean found;
+ bool found;
const char *warning;
const char *symbol;
asymbol **asymbols;
/* Look through the relocs to see if we can find a plausible address
for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
-static bfd_boolean
+static bool
symbol_warning (const char *warning, const char *symbol, bfd *abfd)
{
struct warning_callback_info cinfo;
if (!bfd_generic_link_read_symbols (abfd))
einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
- cinfo.found = FALSE;
+ cinfo.found = false;
cinfo.warning = warning;
cinfo.symbol = symbol;
cinfo.asymbols = bfd_get_outsymbols (abfd);
/* We found a reloc for the symbol we are looking for. */
einfo ("%P: %C: %s%s\n", abfd, sec, q->address, _("warning: "),
info->warning);
- info->found = TRUE;
+ info->found = true;
break;
}
}
free (relpp);
}
+#if SUPPORT_ERROR_HANDLING_SCRIPT
+char * error_handling_script = NULL;
+#endif
+
/* This is called when an undefined symbol is found. */
static void
bfd *abfd,
asection *section,
bfd_vma address,
- bfd_boolean error)
+ bool error)
{
static char *error_name;
static unsigned int error_count;
#define MAX_ERRORS_IN_A_ROW 5
if (info->ignore_hash != NULL
- && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
+ && bfd_hash_lookup (info->ignore_hash, name, false, false) != NULL)
return;
if (config.warn_once)
else
{
error_count = 0;
- if (error_name != NULL)
- free (error_name);
+ free (error_name);
error_name = xstrdup (name);
}
+#if SUPPORT_ERROR_HANDLING_SCRIPT
+ if (error_handling_script != NULL
+ && error_count < MAX_ERRORS_IN_A_ROW)
+ {
+ char * argv[4];
+ const char * res;
+ int status, err;
+
+ argv[0] = error_handling_script;
+ argv[1] = "undefined-symbol";
+ argv[2] = (char *) name;
+ argv[3] = NULL;
+
+ if (verbose)
+ einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"),
+ argv[0], argv[1], argv[2]);
+
+ res = pex_one (PEX_SEARCH, error_handling_script, argv,
+ N_("error handling script"),
+ NULL /* Send stdout to random, temp file. */,
+ NULL /* Write to stderr. */,
+ &status, &err);
+ if (res != NULL)
+ {
+ einfo (_("%P: Failed to run error handling script '%s', reason: "),
+ error_handling_script);
+ /* FIXME: We assume here that errrno == err. */
+ perror (res);
+ }
+ /* We ignore the return status of the script and
+ carry on to issue the normal error message. */
+ }
+#endif /* SUPPORT_ERROR_HANDLING_SCRIPT */
+
if (section != NULL)
{
if (error_count < MAX_ERRORS_IN_A_ROW)
linker script; and if plugins are active, since they need to monitor
all references from non-IR files. */
-static bfd_boolean
+static bool
notice (struct bfd_link_info *info,
struct bfd_link_hash_entry *h,
struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
{
if (command_line.cref || nocrossref_list != NULL)
return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
- return TRUE;
+ return true;
}
name = h->root.string;
if (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 (_("%P: %pB: reference to %s\n"), abfd, name);
if (command_line.cref || nocrossref_list != NULL)
add_cref (name, abfd, section, value);
- return TRUE;
+ return true;
}
projects / deliverable / binutils-gdb.git / blobdiff