/* Linker file opening and searching.
- Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004, 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1991-2024 Free Software Foundation, Inc.
This file is part of the GNU Binutils.
#include "sysdep.h"
#include "bfd.h"
#include "bfdlink.h"
+#include "ctf-api.h"
#include "safe-ctype.h"
#include "ld.h"
#include "ldmisc.h"
#include "ldemul.h"
#include "libiberty.h"
#include "filenames.h"
-#ifdef ENABLE_PLUGINS
+#include <fnmatch.h>
+#if BFD_SUPPORTS_PLUGINS
#include "plugin-api.h"
#include "plugin.h"
-#endif /* ENABLE_PLUGINS */
+#endif /* BFD_SUPPORTS_PLUGINS */
-const char * ldfile_input_filename;
-bfd_boolean ldfile_assumed_script = FALSE;
-const char * ldfile_output_machine_name = "";
+bool ldfile_assumed_script = false;
+const char *ldfile_output_machine_name = "";
unsigned long ldfile_output_machine;
enum bfd_architecture ldfile_output_architecture;
-search_dirs_type * search_head;
+search_dirs_type *search_head;
#ifdef VMS
-static char * slash = "";
+static char *slash = "";
#else
-#if defined (_WIN32) && ! defined (__CYGWIN32__)
-static char * slash = "\\";
+#if defined (_WIN32) && !defined (__CYGWIN32__)
+static char *slash = "\\";
#else
-static char * slash = "/";
+static char *slash = "/";
#endif
#endif
static search_arch_type *search_arch_head;
static search_arch_type **search_arch_tail_ptr = &search_arch_head;
+typedef struct input_remap
+{
+ const char * pattern; /* Pattern to match input files. */
+ const char * renamed; /* Filename to use if the pattern matches. */
+ struct input_remap * next; /* Link in a chain of these structures. */
+} input_remap;
+
+static struct input_remap * input_remaps = NULL;
+
+void
+ldfile_add_remap (const char * pattern, const char * renamed)
+{
+ struct input_remap * new_entry;
+
+ new_entry = xmalloc (sizeof * new_entry);
+ new_entry->pattern = xstrdup (pattern);
+ new_entry->next = NULL;
+
+ /* Look for special filenames that mean that the input file should be ignored. */
+ if (strcmp (renamed, "/dev/null") == 0
+ || strcmp (renamed, "NUL") == 0)
+ new_entry->renamed = NULL;
+ else
+ /* FIXME: Should we add sanity checking of the 'renamed' string ? */
+ new_entry->renamed = xstrdup (renamed);
+
+ /* It would be easier to add this new node at the start of the chain,
+ but users expect that remapping will occur in the order in which
+ they occur on the command line, and in the remapping files. */
+ if (input_remaps == NULL)
+ {
+ input_remaps = new_entry;
+ }
+ else
+ {
+ struct input_remap * i;
+
+ for (i = input_remaps; i->next != NULL; i = i->next)
+ ;
+ i->next = new_entry;
+ }
+}
+
+void
+ldfile_remap_input_free (void)
+{
+ while (input_remaps != NULL)
+ {
+ struct input_remap * i = input_remaps;
+
+ input_remaps = i->next;
+ free ((void *) i->pattern);
+ free ((void *) i->renamed);
+ free (i);
+ }
+}
+
+bool
+ldfile_add_remap_file (const char * file)
+{
+ FILE * f;
+
+ f = fopen (file, FOPEN_RT);
+ if (f == NULL)
+ return false;
+
+ size_t linelen = 256;
+ char * line = xmalloc (linelen);
+
+ do
+ {
+ char * p = line;
+ char * q;
+
+ /* Normally this would use getline(3), but we need to be portable. */
+ while ((q = fgets (p, linelen - (p - line), f)) != NULL
+ && strlen (q) == linelen - (p - line) - 1
+ && line[linelen - 2] != '\n')
+ {
+ line = xrealloc (line, 2 * linelen);
+ p = line + linelen - 1;
+ linelen += linelen;
+ }
+
+ if (q == NULL && p == line)
+ break;
+
+ p = strchr (line, '\n');
+ if (p)
+ *p = '\0';
+
+ /* Because the file format does not know any form of quoting we
+ can search forward for the next '#' character and if found
+ make it terminating the line. */
+ p = strchr (line, '#');
+ if (p)
+ *p = '\0';
+
+ /* Remove leading whitespace. NUL is no whitespace character. */
+ p = line;
+ while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
+ ++p;
+
+ /* If the line is blank it is ignored. */
+ if (*p == '\0')
+ continue;
+
+ char * pattern = p;
+
+ /* Advance past the pattern. We accept whitespace or '=' as an
+ end-of-pattern marker. */
+ while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
+ && *p != '\r' && *p != '\v')
+ ++p;
+
+ if (*p == '\0')
+ {
+ einfo ("%F%P: malformed remap file entry: %s\n", line);
+ continue;
+ }
+
+ * p++ = '\0';
+
+ /* Skip whitespace again. */
+ while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
+ ++p;
+
+ if (*p == '\0')
+ {
+ einfo ("%F%P: malformed remap file entry: %s\n", line);
+ continue;
+ }
+
+ char * renamed = p;
+
+ /* Advance past the rename entry. */
+ while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
+ && *p != '\r' && *p != '\v')
+ ++p;
+ /* And terminate it. */
+ *p = '\0';
+
+ ldfile_add_remap (pattern, renamed);
+ }
+ while (! feof (f));
+
+ free (line);
+ fclose (f);
+
+ return true;
+}
+
+const char *
+ldfile_possibly_remap_input (const char * filename)
+{
+ struct input_remap * i;
+
+ if (filename == NULL)
+ return NULL;
+
+ for (i = input_remaps; i != NULL; i = i->next)
+ {
+ if (fnmatch (i->pattern, filename, 0) == 0)
+ {
+ if (verbose)
+ {
+ if (strpbrk ((i->pattern), "?*[") != NULL)
+ {
+ if (i->renamed)
+ info_msg (_("remap input file '%s' to '%s' based upon pattern '%s'\n"),
+ filename, i->renamed, i->pattern);
+ else
+ info_msg (_("remove input file '%s' based upon pattern '%s'\n"),
+ filename, i->pattern);
+ }
+ else
+ {
+ if (i->renamed)
+ info_msg (_("remap input file '%s' to '%s'\n"),
+ filename, i->renamed);
+ else
+ info_msg (_("remove input file '%s'\n"),
+ filename);
+ }
+ }
+
+ return i->renamed;
+ }
+ }
+
+ return filename;
+}
+
+void
+ldfile_print_input_remaps (void)
+{
+ if (input_remaps == NULL)
+ return;
+
+ minfo (_("\nInput File Remapping\n\n"));
+
+ struct input_remap * i;
+
+ for (i = input_remaps; i != NULL; i = i->next)
+ minfo (_(" Pattern: %s\tMaps To: %s\n"), i->pattern,
+ i->renamed ? i->renamed : _("<discard>"));
+}
+
+
/* Test whether a pathname, after canonicalization, is the same or a
sub-directory of the sysroot directory. */
-static bfd_boolean
-is_sysrooted_pathname (const char *name, bfd_boolean notsame)
+static bool
+is_sysrooted_pathname (const char *name)
{
- char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
+ char *realname;
int len;
- bfd_boolean result;
+ bool result;
- if (! realname)
- return FALSE;
+ if (ld_canon_sysroot == NULL)
+ return false;
+ realname = lrealpath (name);
len = strlen (realname);
+ result = false;
+ if (len > ld_canon_sysroot_len
+ && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
+ {
+ realname[ld_canon_sysroot_len] = '\0';
+ result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
+ }
- if (((! notsame && len == ld_canon_sysroot_len)
- || (len >= ld_canon_sysroot_len
- && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
- && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
- && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
- result = TRUE;
- else
- result = FALSE;
-
- if (realname)
- free (realname);
-
+ free (realname);
return result;
}
Makes a copy of NAME using xmalloc(). */
void
-ldfile_add_library_path (const char *name, bfd_boolean cmdline)
+ldfile_add_library_path (const char *name, bool cmdline)
{
search_dirs_type *new_dirs;
/* If a directory is marked as honoring sysroot, prepend the sysroot path
now. */
if (name[0] == '=')
- {
- new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
- new_dirs->sysrooted = TRUE;
- }
+ new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
+ else if (startswith (name, "$SYSROOT"))
+ new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL);
else
- {
- new_dirs->name = xstrdup (name);
- new_dirs->sysrooted = is_sysrooted_pathname (name, FALSE);
- }
+ new_dirs->name = xstrdup (name);
}
/* Try to open a BFD for a lang_input_statement. */
-bfd_boolean
+bool
ldfile_try_open_bfd (const char *attempt,
lang_input_statement_type *entry)
{
entry->the_bfd = bfd_openr (attempt, entry->target);
- if (trace_file_tries)
+ if (verbose)
{
if (entry->the_bfd == NULL)
info_msg (_("attempt to open %s failed\n"), attempt);
{
if (bfd_get_error () == bfd_error_invalid_target)
einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
- return FALSE;
+ return false;
}
+ /* PR 30568: Do not track lto generated temporary object files. */
+#if BFD_SUPPORTS_PLUGINS
+ if (!entry->flags.lto_output)
+#endif
+ track_dependency_files (attempt);
+
/* Linker needs to decompress sections. */
entry->the_bfd->flags |= BFD_DECOMPRESS;
+ /* This is a linker input BFD. */
+ entry->the_bfd->is_linker_input = 1;
+
+#if BFD_SUPPORTS_PLUGINS
+ if (entry->flags.lto_output)
+ entry->the_bfd->lto_output = 1;
+#endif
+
/* If we are searching for this file, see if the architecture is
compatible with the output file. If it isn't, keep searching.
If we can't open the file as an object file, stop the search
a dynamic object.
In the code below, it's OK to exit early if the check fails,
- closing the checked BFD and returning FALSE, but if the BFD
- checks out compatible, do not exit early returning TRUE, or
+ closing the checked BFD and returning false, but if the BFD
+ checks out compatible, do not exit early returning true, or
the plugins will not get a chance to claim the file. */
- if (entry->search_dirs_flag || !entry->dynamic)
+ if (entry->flags.search_dirs || !entry->flags.dynamic)
{
bfd *check;
if (check != NULL)
{
- if (! bfd_check_format (check, bfd_object))
+ if (!bfd_check_format (check, bfd_object))
{
if (check == entry->the_bfd
- && entry->search_dirs_flag
+ && entry->flags.search_dirs
&& bfd_get_error () == bfd_error_file_not_recognized
- && ! ldemul_unrecognized_file (entry))
+ && !ldemul_unrecognized_file (entry))
{
int token, skip = 0;
char *arg, *arg1, *arg2, *arg3;
/* Try to interpret the file as a linker script. */
ldfile_open_command_file (attempt);
- ldfile_assumed_script = TRUE;
+ ldfile_assumed_script = true;
parser_input = input_selected;
- ldlex_both ();
+ ldlex_script ();
token = INPUT_SCRIPT;
while (token != 0)
{
skip = 1;
}
free (arg1);
- if (arg2) free (arg2);
- if (arg3) free (arg3);
+ free (arg2);
+ free (arg3);
break;
case NAME:
case LNAME:
free (yylval.name);
break;
case INT:
- if (yylval.bigint.str)
- free (yylval.bigint.str);
+ free (yylval.bigint.str);
break;
}
token = yylex ();
}
ldlex_popstate ();
- ldfile_assumed_script = FALSE;
+ ldfile_assumed_script = false;
fclose (yyin);
yyin = NULL;
if (skip)
attempt, entry->local_sym_name);
bfd_close (entry->the_bfd);
entry->the_bfd = NULL;
- return FALSE;
+ return false;
}
}
goto success;
}
- if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
+ if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
{
einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
attempt);
bfd_close (entry->the_bfd);
entry->the_bfd = NULL;
- return FALSE;
+ return false;
}
- if (entry->search_dirs_flag
+ if (entry->flags.search_dirs
&& !bfd_arch_get_compatible (check, link_info.output_bfd,
command_line.accept_unknown_input_arch)
/* XCOFF archives can have 32 and 64 bit objects. */
- && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
- && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
- && bfd_check_format (entry->the_bfd, bfd_archive)))
+ && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour
+ && (bfd_get_flavour (link_info.output_bfd)
+ == bfd_target_xcoff_flavour)
+ && bfd_check_format (entry->the_bfd, bfd_archive)))
{
if (command_line.warn_search_mismatch)
einfo (_("%P: skipping incompatible %s "
attempt, entry->local_sym_name);
bfd_close (entry->the_bfd);
entry->the_bfd = NULL;
- return FALSE;
+ return false;
}
}
}
-success:
-#ifdef ENABLE_PLUGINS
+ success:
+#if BFD_SUPPORTS_PLUGINS
/* If plugins are active, they get first chance to claim
any successfully-opened input file. We skip archives
here; the plugin wants us to offer it the individual
bfd_object that it sets the bfd's arch and mach, which
will be needed when and if we want to bfd_create a new
one using this one as a template. */
- if (bfd_check_format (entry->the_bfd, bfd_object)
- && plugin_active_plugins_p ())
- {
- int fd = open (attempt, O_RDONLY | O_BINARY);
- if (fd >= 0)
- {
- struct ld_plugin_input_file file;
- int claimed = 0;
-
- file.name = attempt;
- file.offset = 0;
- file.filesize = lseek (fd, 0, SEEK_END);
- file.fd = fd;
- /* We create a dummy BFD, initially empty, to house
- whatever symbols the plugin may want to add. */
- file.handle = plugin_get_ir_dummy_bfd (attempt, entry->the_bfd);
- if (plugin_call_claim_file (&file, &claimed))
- einfo (_("%P%F: %s: plugin reported error claiming file\n"),
- plugin_error_plugin ());
- /* fd belongs to us, not the plugin; but we don't need it. */
- close (fd);
- if (claimed)
- {
- /* Discard the real file's BFD and substitute the dummy one. */
- bfd_close (entry->the_bfd);
- entry->the_bfd = file.handle;
- entry->claimed = TRUE;
- bfd_make_readable (entry->the_bfd);
- }
- else
- {
- /* If plugin didn't claim the file, we don't need the dummy
- bfd. Can't avoid speculatively creating it, alas. */
- bfd_close_all_done (file.handle);
- entry->claimed = FALSE;
- }
- }
- }
-#endif /* ENABLE_PLUGINS */
+ if (link_info.lto_plugin_active
+ && !no_more_claiming
+ && bfd_check_format (entry->the_bfd, bfd_object))
+ plugin_maybe_claim (entry);
+#endif /* BFD_SUPPORTS_PLUGINS */
/* It opened OK, the format checked out, and the plugins have had
their chance to claim it, so this is success. */
- return TRUE;
+ return true;
}
/* Search for and open the file specified by ENTRY. If it is an
archive, use ARCH, LIB and SUFFIX to modify the file name. */
-bfd_boolean
+bool
ldfile_open_file_search (const char *arch,
lang_input_statement_type *entry,
const char *lib,
/* If this is not an archive, try to open it in the current
directory first. */
- if (! entry->is_archive)
+ if (!entry->flags.maybe_archive)
{
- if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
+ if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
{
char *name = concat (ld_sysroot, entry->filename,
(const char *) NULL);
if (ldfile_try_open_bfd (name, entry))
{
entry->filename = name;
- return TRUE;
+ return true;
}
free (name);
}
else if (ldfile_try_open_bfd (entry->filename, entry))
- {
- entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
- && is_sysrooted_pathname (entry->filename, TRUE);
- return TRUE;
- }
+ return true;
if (IS_ABSOLUTE_PATH (entry->filename))
- return FALSE;
+ return false;
}
for (search = search_head; search != NULL; search = search->next)
{
char *string;
- if (entry->dynamic && ! link_info.relocatable)
+ if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
{
if (ldemul_open_dynamic_archive (arch, search, entry))
- {
- entry->sysrooted = search->sysrooted;
- return TRUE;
- }
+ return true;
}
- if (entry->is_archive)
+ if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
string = concat (search->name, slash, lib, entry->filename,
arch, suffix, (const char *) NULL);
else
if (ldfile_try_open_bfd (string, entry))
{
entry->filename = string;
- entry->sysrooted = search->sysrooted;
- return TRUE;
+ return true;
}
free (string);
}
- return FALSE;
+ return false;
}
/* Open the input file specified by ENTRY.
if (entry->the_bfd != NULL)
return;
- if (! entry->search_dirs_flag)
+ if (!entry->flags.search_dirs)
{
if (ldfile_try_open_bfd (entry->filename, entry))
return;
- if (strcmp (entry->filename, entry->local_sym_name) != 0)
+ if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
einfo (_("%P: cannot find %s (%s): %E\n"),
entry->filename, entry->local_sym_name);
else
einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
- entry->missing_file = TRUE;
- missing_file = TRUE;
+ entry->flags.missing_file = true;
+ input_flags.missing_file = true;
}
else
{
search_arch_type *arch;
- bfd_boolean found = FALSE;
+ bool found = false;
+
+ /* If extra_search_path is set, entry->filename is a relative path.
+ Search the directory of the current linker script before searching
+ other paths. */
+ if (entry->extra_search_path)
+ {
+ char *path = concat (entry->extra_search_path, slash, entry->filename,
+ (const char *)0);
+ if (ldfile_try_open_bfd (path, entry))
+ {
+ entry->filename = path;
+ entry->flags.search_dirs = false;
+ return;
+ }
- /* Try to open <filename><suffix> or lib<filename><suffix>.a */
+ free (path);
+ }
+
+ /* Try to open <filename><suffix> or lib<filename><suffix>.a. */
for (arch = search_arch_head; arch != NULL; arch = arch->next)
{
found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
/* If we have found the file, we don't need to search directories
again. */
if (found)
- entry->search_dirs_flag = FALSE;
+ entry->flags.search_dirs = false;
else
{
- if (entry->sysrooted
+ if (entry->flags.sysrooted
&& ld_sysroot
&& IS_ABSOLUTE_PATH (entry->local_sym_name))
einfo (_("%P: cannot find %s inside %s\n"),
entry->local_sym_name, ld_sysroot);
+#if SUPPORT_ERROR_HANDLING_SCRIPT
+ else if (error_handling_script != NULL)
+ {
+ char * argv[4];
+ const char * res;
+ int status, err;
+
+ argv[0] = error_handling_script;
+ argv[1] = "missing-lib";
+ argv[2] = (char *) entry->local_sym_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);
+ }
+ else /* We ignore the return status of the script
+ and always print the error message. */
+ einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
+ }
+#endif
else
- einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
- entry->missing_file = TRUE;
- missing_file = TRUE;
+ einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
+
+ /* PR 25747: Be kind to users who forgot to add the
+ "lib" prefix to their library when it was created. */
+ for (arch = search_arch_head; arch != NULL; arch = arch->next)
+ {
+ if (ldfile_open_file_search (arch->name, entry, "", ".a"))
+ {
+ const char * base = lbasename (entry->filename);
+
+ einfo (_("%P: note to link with %s use -l:%s or rename it to lib%s\n"),
+ entry->filename, base, base);
+ bfd_close (entry->the_bfd);
+ entry->the_bfd = NULL;
+ break;
+ }
+ }
+
+ entry->flags.missing_file = true;
+ input_flags.missing_file = true;
}
}
}
-/* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
+/* Try to open NAME. */
static FILE *
-try_open (const char *name, const char *exten)
+try_open (const char *name, bool *sysrooted)
{
FILE *result;
result = fopen (name, "r");
- if (trace_file_tries)
+ if (result != NULL)
+ {
+ *sysrooted = is_sysrooted_pathname (name);
+ track_dependency_files (name);
+ }
+
+ if (verbose)
{
if (result == NULL)
info_msg (_("cannot find script file %s\n"), name);
info_msg (_("opened script file %s\n"), name);
}
- if (result != NULL)
- return result;
-
- if (*exten)
- {
- char *buff;
-
- buff = concat (name, exten, (const char *) NULL);
- result = fopen (buff, "r");
-
- if (trace_file_tries)
- {
- if (result == NULL)
- info_msg (_("cannot find script file %s\n"), buff);
- else
- info_msg (_("opened script file %s\n"), buff);
- }
- free (buff);
- }
-
return result;
}
/* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */
-static bfd_boolean
+static bool
check_for_scripts_dir (char *dir)
{
char *buf;
struct stat s;
- bfd_boolean res;
+ bool res;
buf = concat (dir, "/ldscripts", (const char *) NULL);
res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
/* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
it in directories specified with -L, then in the default script
- directory, without and with EXTEND appended. If DEFAULT_ONLY is
- true, the search is restricted to the default script location. */
+ directory. If DEFAULT_ONLY is true, the search is restricted to
+ the default script location. */
static FILE *
-ldfile_find_command_file (const char *name, const char *extend,
- bfd_boolean default_only)
+ldfile_find_command_file (const char *name,
+ bool default_only,
+ bool *sysrooted)
{
search_dirs_type *search;
FILE *result = NULL;
- char *buffer;
+ char *path;
static search_dirs_type *script_search;
if (!default_only)
{
/* First try raw name. */
- result = try_open (name, "");
+ result = try_open (name, sysrooted);
if (result != NULL)
return result;
}
{
search_dirs_type **save_tail_ptr = search_tail_ptr;
search_tail_ptr = &script_search;
- ldfile_add_library_path (script_dir, TRUE);
+ ldfile_add_library_path (script_dir, true);
search_tail_ptr = save_tail_ptr;
}
}
search != NULL;
search = search->next)
{
- buffer = concat (search->name, slash, name, (const char *) NULL);
- result = try_open (buffer, extend);
- free (buffer);
+ path = concat (search->name, slash, name, (const char *) NULL);
+ result = try_open (path, sysrooted);
+ free (path);
if (result)
break;
}
return result;
}
+struct script_name_list *processed_scripts = NULL;
/* Open command file NAME. */
static void
-ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
+ldfile_open_command_file_1 (const char *name, enum script_open_style open_how)
{
FILE *ldlex_input_stack;
- ldlex_input_stack = ldfile_find_command_file (name, "", default_only);
+ bool sysrooted;
+ struct script_name_list *script;
+ size_t len;
+ /* PR 24576: Catch the case where the user has accidentally included
+ the same linker script twice. */
+ for (script = processed_scripts; script != NULL; script = script->next)
+ {
+ if ((open_how != script_nonT || script->open_how != script_nonT)
+ && strcmp (name, script->name) == 0)
+ {
+ einfo (_("%F%P: error: linker script file '%s'"
+ " appears multiple times\n"), name);
+ return;
+ }
+ }
+
+ /* FIXME: This memory is never freed, but that should not really matter.
+ It will be released when the linker exits, and it is unlikely to ever
+ be more than a few tens of bytes. */
+ len = strlen (name);
+ script = xmalloc (sizeof (*script) + len);
+ script->next = processed_scripts;
+ script->open_how = open_how;
+ memcpy (script->name, name, len + 1);
+ processed_scripts = script;
+
+ ldlex_input_stack = ldfile_find_command_file (name,
+ open_how == script_defaultT,
+ &sysrooted);
if (ldlex_input_stack == NULL)
{
bfd_set_error (bfd_error_system_call);
- einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
+ einfo (_("%F%P: cannot open linker script file %s: %E\n"), name);
+ return;
}
- lex_push_file (ldlex_input_stack, name);
+ lex_push_file (ldlex_input_stack, name, sysrooted);
- ldfile_input_filename = name;
lineno = 1;
saved_script_handle = ldlex_input_stack;
void
ldfile_open_command_file (const char *name)
{
- ldfile_open_command_file_1 (name, FALSE);
+ ldfile_open_command_file_1 (name, script_nonT);
+}
+
+void
+ldfile_open_script_file (const char *name)
+{
+ ldfile_open_command_file_1 (name, script_T);
}
/* Open command file NAME at the default script location. */
void
ldfile_open_default_command_file (const char *name)
{
- ldfile_open_command_file_1 (name, TRUE);
+ ldfile_open_command_file_1 (name, script_defaultT);
}
void
ldfile_add_arch (const char *in_name)
{
char *name = xstrdup (in_name);
- search_arch_type *new_arch = (search_arch_type *)
- xmalloc (sizeof (search_arch_type));
+ search_arch_type *new_arch
+ = (search_arch_type *) xmalloc (sizeof (search_arch_type));
ldfile_output_machine_name = in_name;
else if (defarch != bfd_arch_unknown)
ldfile_output_architecture = defarch;
else
- einfo (_("%P%F: cannot represent machine `%s'\n"), string);
+ einfo (_("%F%P: cannot represent machine `%s'\n"), string);
}
projects / thirdparty / binutils-gdb.git / blobdiff