+/* Linker file opening and searching.
+ Copyright (C) 1991-2020 Free Software Foundation, Inc.
-/* Copyright (C) 1991 Free Software Foundation, Inc.
+ This file is part of the GNU Binutils.
-This file is part of GLD, the Gnu Linker.
+ This program 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 3 of the License, 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 1, or (at your option)
-any later version.
+ This program 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/*
- $Id$
-*/
-
-/*
- ldfile.c
-
- look after all the file stuff
-
- */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
#include "sysdep.h"
#include "bfd.h"
-
+#include "bfdlink.h"
+#include "ctf-api.h"
+#include "safe-ctype.h"
+#include "ld.h"
#include "ldmisc.h"
+#include "ldexp.h"
#include "ldlang.h"
#include "ldfile.h"
-
-/* EXPORT */
-char *ldfile_input_filename;
-CONST char * ldfile_output_machine_name ="";
+#include "ldmain.h"
+#include <ldgram.h>
+#include "ldlex.h"
+#include "ldemul.h"
+#include "libiberty.h"
+#include "filenames.h"
+#ifdef ENABLE_PLUGINS
+#include "plugin-api.h"
+#include "plugin.h"
+#endif /* ENABLE_PLUGINS */
+
+bfd_boolean ldfile_assumed_script = FALSE;
+const char *ldfile_output_machine_name = "";
unsigned long ldfile_output_machine;
enum bfd_architecture ldfile_output_architecture;
-boolean had_script;
-
-/* IMPORT */
-
-extern boolean option_v;
-
-
-
-
+search_dirs_type *search_head;
+
+#ifdef VMS
+static char *slash = "";
+#else
+#if defined (_WIN32) && !defined (__CYGWIN32__)
+static char *slash = "\\";
+#else
+static char *slash = "/";
+#endif
+#endif
-/* LOACL */
-typedef struct search_dirs_struct
+typedef struct search_arch
{
char *name;
- struct search_dirs_struct *next;
-} search_dirs_type;
+ struct search_arch *next;
+} search_arch_type;
-static search_dirs_type *search_head;
static search_dirs_type **search_tail_ptr = &search_head;
+static search_arch_type *search_arch_head;
+static search_arch_type **search_arch_tail_ptr = &search_arch_head;
-typedef struct search_arch_struct
+/* 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)
{
- char *name;
- struct search_arch_struct *next;
-} search_arch_type;
+ char *realname;
+ int len;
+ bfd_boolean result;
+
+ 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;
+ }
-static search_arch_type *search_arch_head;
-static search_arch_type **search_arch_tail_ptr = &search_arch_head;
-
+ free (realname);
+ return result;
+}
+/* Adds NAME to the library search path.
+ Makes a copy of NAME using xmalloc(). */
void
-ldfile_add_library_path(name)
-char *name;
+ldfile_add_library_path (const char *name, bfd_boolean cmdline)
{
- search_dirs_type *new =
- (search_dirs_type *)ldmalloc(sizeof(search_dirs_type));
- new->name = name;
- new->next = (search_dirs_type*)NULL;
- *search_tail_ptr = new;
- search_tail_ptr = &new->next;
+ search_dirs_type *new_dirs;
+
+ if (!cmdline && config.only_cmd_line_lib_dirs)
+ return;
+
+ new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
+ new_dirs->next = NULL;
+ new_dirs->cmdline = cmdline;
+ *search_tail_ptr = new_dirs;
+ search_tail_ptr = &new_dirs->next;
+
+ /* 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);
+ else if (CONST_STRNEQ (name, "$SYSROOT"))
+ new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL);
+ else
+ new_dirs->name = xstrdup (name);
}
+/* Try to open a BFD for a lang_input_statement. */
-static bfd*
-cached_bfd_openr(attempt,entry)
-char *attempt;
-lang_input_statement_type *entry;
+bfd_boolean
+ldfile_try_open_bfd (const char *attempt,
+ lang_input_statement_type *entry)
{
- entry->the_bfd = bfd_openr(attempt, entry->target);
- if (option_v == true ) {
- info("attempt to open %s %s\n", attempt,
- (entry->the_bfd == (bfd *)NULL) ? "failed" : "succeeded" );
- }
- return entry->the_bfd;
+ entry->the_bfd = bfd_openr (attempt, entry->target);
+
+ if (verbose)
+ {
+ if (entry->the_bfd == NULL)
+ info_msg (_("attempt to open %s failed\n"), attempt);
+ else
+ info_msg (_("attempt to open %s succeeded\n"), attempt);
+ }
+
+ if (entry->the_bfd == NULL)
+ {
+ if (bfd_get_error () == bfd_error_invalid_target)
+ einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
+ return FALSE;
+ }
+
+ /* Linker needs to decompress sections. */
+ entry->the_bfd->flags |= BFD_DECOMPRESS;
+
+ /* This is a linker input BFD. */
+ entry->the_bfd->is_linker_input = 1;
+
+#ifdef ENABLE_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
+ here. If we are statically linking, ensure that we don't link
+ 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
+ the plugins will not get a chance to claim the file. */
+
+ if (entry->flags.search_dirs || !entry->flags.dynamic)
+ {
+ bfd *check;
+
+ if (bfd_check_format (entry->the_bfd, bfd_archive))
+ check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
+ else
+ check = entry->the_bfd;
+
+ if (check != NULL)
+ {
+ if (!bfd_check_format (check, bfd_object))
+ {
+ if (check == entry->the_bfd
+ && entry->flags.search_dirs
+ && bfd_get_error () == bfd_error_file_not_recognized
+ && !ldemul_unrecognized_file (entry))
+ {
+ int token, skip = 0;
+ char *arg, *arg1, *arg2, *arg3;
+ extern FILE *yyin;
+
+ /* Try to interpret the file as a linker script. */
+ ldfile_open_command_file (attempt);
+
+ ldfile_assumed_script = TRUE;
+ parser_input = input_selected;
+ ldlex_both ();
+ token = INPUT_SCRIPT;
+ while (token != 0)
+ {
+ switch (token)
+ {
+ case OUTPUT_FORMAT:
+ if ((token = yylex ()) != '(')
+ continue;
+ if ((token = yylex ()) != NAME)
+ continue;
+ arg1 = yylval.name;
+ arg2 = NULL;
+ arg3 = NULL;
+ token = yylex ();
+ if (token == ',')
+ {
+ if ((token = yylex ()) != NAME)
+ {
+ free (arg1);
+ continue;
+ }
+ arg2 = yylval.name;
+ if ((token = yylex ()) != ','
+ || (token = yylex ()) != NAME)
+ {
+ free (arg1);
+ free (arg2);
+ continue;
+ }
+ arg3 = yylval.name;
+ token = yylex ();
+ }
+ if (token == ')')
+ {
+ switch (command_line.endian)
+ {
+ default:
+ case ENDIAN_UNSET:
+ arg = arg1; break;
+ case ENDIAN_BIG:
+ arg = arg2 ? arg2 : arg1; break;
+ case ENDIAN_LITTLE:
+ arg = arg3 ? arg3 : arg1; break;
+ }
+ if (strcmp (arg, lang_get_output_target ()) != 0)
+ skip = 1;
+ }
+ free (arg1);
+ if (arg2) free (arg2);
+ if (arg3) free (arg3);
+ break;
+ case NAME:
+ case LNAME:
+ case VERS_IDENTIFIER:
+ case VERS_TAG:
+ free (yylval.name);
+ break;
+ case INT:
+ if (yylval.bigint.str)
+ free (yylval.bigint.str);
+ break;
+ }
+ token = yylex ();
+ }
+ ldlex_popstate ();
+ ldfile_assumed_script = FALSE;
+ fclose (yyin);
+ yyin = NULL;
+ if (skip)
+ {
+ if (command_line.warn_search_mismatch)
+ einfo (_("%P: skipping incompatible %s "
+ "when searching for %s\n"),
+ attempt, entry->local_sym_name);
+ bfd_close (entry->the_bfd);
+ entry->the_bfd = NULL;
+ return FALSE;
+ }
+ }
+ goto success;
+ }
+
+ 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;
+ }
+
+ 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)))
+ {
+ if (command_line.warn_search_mismatch)
+ einfo (_("%P: skipping incompatible %s "
+ "when searching for %s\n"),
+ attempt, entry->local_sym_name);
+ bfd_close (entry->the_bfd);
+ entry->the_bfd = NULL;
+ return FALSE;
+ }
+ }
+ }
+success:
+#ifdef ENABLE_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
+ members when we enumerate them, not the whole file. We
+ also ignore corefiles, because that's just weird. It is
+ a needed side-effect of calling bfd_check_format with
+ 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 (link_info.lto_plugin_active
+ && !no_more_claiming
+ && bfd_check_format (entry->the_bfd, bfd_object))
+ plugin_maybe_claim (entry);
+#endif /* ENABLE_PLUGINS */
+
+ /* It opened OK, the format checked out, and the plugins have had
+ their chance to claim it, so this is success. */
+ return TRUE;
}
-static bfd *
-open_a(arch, entry, lib, suffix)
-char *arch;
-lang_input_statement_type *entry;
-char *lib;
-char *suffix;
+/* 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
+ldfile_open_file_search (const char *arch,
+ lang_input_statement_type *entry,
+ const char *lib,
+ const char *suffix)
{
- bfd*desc;
- search_dirs_type *search ;
- for (search = search_head;
- search != (search_dirs_type *)NULL;
- search = search->next)
+ search_dirs_type *search;
+
+ /* If this is not an archive, try to open it in the current
+ directory first. */
+ if (!entry->flags.maybe_archive)
+ {
+ 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;
+ }
+ free (name);
+ }
+ else if (ldfile_try_open_bfd (entry->filename, entry))
+ return TRUE;
+
+ if (IS_ABSOLUTE_PATH (entry->filename))
+ return FALSE;
+ }
+
+ for (search = search_head; search != NULL; search = search->next)
{
- char buffer[1000];
char *string;
- if (entry->is_archive == true) {
- sprintf(buffer,
- "%s/%s%s%s%s",
- search->name,
- lib,
- entry->filename, arch, suffix);
- }
- else {
- if (entry->filename[0] == '/' || entry->filename[0] == '.') {
- strcpy(buffer, entry->filename);
- } else {
- sprintf(buffer,"%s/%s",search->name, entry->filename);
- }
- }
- string = buystring(buffer);
- desc = cached_bfd_openr (string, entry);
- if (desc)
+
+ if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
+ {
+ if (ldemul_open_dynamic_archive (arch, search, entry))
+ return TRUE;
+ }
+
+ if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
+ string = concat (search->name, slash, lib, entry->filename,
+ arch, suffix, (const char *) NULL);
+ else
+ string = concat (search->name, slash, entry->filename,
+ (const char *) 0);
+
+ if (ldfile_try_open_bfd (string, entry))
{
entry->filename = string;
- entry->search_dirs_flag = false;
- entry->the_bfd = desc;
- return desc;
+ return TRUE;
}
- free(string);
+
+ free (string);
}
- return (bfd *)NULL;
+
+ return FALSE;
}
-/* Open the input file specified by 'entry', and return a descriptor.
- The open file is remembered; if the same file is opened twice in a row,
- a new open is not actually done. */
+/* Open the input file specified by ENTRY.
+ PR 4437: Do not stop on the first missing file, but
+ continue processing other input files in case there
+ are more errors to report. */
void
-ldfile_open_file (entry)
-lang_input_statement_type *entry;
+ldfile_open_file (lang_input_statement_type *entry)
{
+ if (entry->the_bfd != NULL)
+ return;
+
+ if (!entry->flags.search_dirs)
+ {
+ if (ldfile_try_open_bfd (entry->filename, entry))
+ return;
- if (entry->superfile)
- ldfile_open_file (entry->superfile);
+ 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);
- if (entry->search_dirs_flag)
+ entry->flags.missing_file = TRUE;
+ input_flags.missing_file = TRUE;
+ }
+ else
{
search_arch_type *arch;
+ bfd_boolean found = FALSE;
+
/* Try to open <filename><suffix> or lib<filename><suffix>.a */
-
- for (arch = search_arch_head;
- arch != (search_arch_type *)NULL;
- arch = arch->next) {
- if (open_a(arch->name,entry,"","") != (bfd *)NULL) {
- return;
+ for (arch = search_arch_head; arch != NULL; arch = arch->next)
+ {
+ found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
+ if (found)
+ break;
+#ifdef VMS
+ found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
+ if (found)
+ break;
+#endif
+ found = ldemul_find_potential_libraries (arch->name, entry);
+ if (found)
+ break;
}
- if (open_a(arch->name,entry,"lib",".a") != (bfd *)NULL) {
- return;
+
+ /* If we have found the file, we don't need to search directories
+ again. */
+ if (found)
+ entry->flags.search_dirs = FALSE;
+ else
+ {
+ 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);
+ else
+ einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
+ entry->flags.missing_file = TRUE;
+ input_flags.missing_file = TRUE;
}
+ }
+}
- }
+/* Try to open NAME. */
+static FILE *
+try_open (const char *name, bfd_boolean *sysrooted)
+{
+ FILE *result;
- }
- else {
- entry->the_bfd = cached_bfd_openr (entry->filename, entry);
+ result = fopen (name, "r");
- }
- if (!entry->the_bfd) info("%F%P: %E %I\n", entry);
+ if (result != NULL)
+ *sysrooted = is_sysrooted_pathname (name);
-}
+ if (verbose)
+ {
+ if (result == NULL)
+ info_msg (_("cannot find script file %s\n"), name);
+ else
+ info_msg (_("opened script file %s\n"), name);
+ }
+ return result;
+}
+/* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */
+static bfd_boolean
+check_for_scripts_dir (char *dir)
+{
+ char *buf;
+ struct stat s;
+ bfd_boolean res;
+
+ buf = concat (dir, "/ldscripts", (const char *) NULL);
+ res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
+ free (buf);
+ return res;
+}
+/* Return the default directory for finding script files.
+ We look for the "ldscripts" directory in:
+ SCRIPTDIR (passed from Makefile)
+ (adjusted according to the current location of the binary)
+ the dir where this program is (for using it from the build tree). */
-static FILE *
-try_open(name, exten)
-char *name;
-char *exten;
+static char *
+find_scripts_dir (void)
{
- FILE *result;
- char buff[1000];
- result = fopen(name, "r");
- if (option_v == true) {
- if (result == (FILE *)NULL) {
- info("can't find ");
+ char *dir;
+
+ dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
+ if (dir)
+ {
+ if (check_for_scripts_dir (dir))
+ return dir;
+ free (dir);
+ }
+
+ dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
+ if (dir)
+ {
+ if (check_for_scripts_dir (dir))
+ return dir;
+ free (dir);
}
- info("%s\n",name);
-
- return result;
- }
- sprintf(buff, "%s%s", name, exten);
- result = fopen(buff, "r");
-
- if (option_v == true) {
- if (result == (FILE *)NULL) {
- info("can't find ");
+
+ /* Look for "ldscripts" in the dir where our binary is. */
+ dir = make_relative_prefix (program_name, ".", ".");
+ if (dir)
+ {
+ if (check_for_scripts_dir (dir))
+ return dir;
+ free (dir);
}
- info("%s\n", buff);
- }
- return result;
+
+ return NULL;
}
+
+/* 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. If DEFAULT_ONLY is true, the search is restricted to
+ the default script location. */
+
static FILE *
-find_a_name(name, extend)
-char *name;
-char *extend;
+ldfile_find_command_file (const char *name,
+ bfd_boolean default_only,
+ bfd_boolean *sysrooted)
{
search_dirs_type *search;
- FILE *result;
- char buffer[1000];
- /* First try raw name */
- result = try_open(name,"");
- if (result == (FILE *)NULL) {
- /* Try now prefixes */
- for (search = search_head;
- search != (search_dirs_type *)NULL;
- search = search->next) {
- sprintf(buffer,"%s/%s", search->name, name);
- result = try_open(buffer, extend);
- if (result)break;
+ FILE *result = NULL;
+ char *path;
+ static search_dirs_type *script_search;
+
+ if (!default_only)
+ {
+ /* First try raw name. */
+ result = try_open (name, sysrooted);
+ if (result != NULL)
+ return result;
}
- }
+
+ if (!script_search)
+ {
+ char *script_dir = find_scripts_dir ();
+ if (script_dir)
+ {
+ search_dirs_type **save_tail_ptr = search_tail_ptr;
+ search_tail_ptr = &script_search;
+ ldfile_add_library_path (script_dir, TRUE);
+ search_tail_ptr = save_tail_ptr;
+ }
+ }
+
+ /* Temporarily append script_search to the path list so that the
+ paths specified with -L will be searched first. */
+ *search_tail_ptr = script_search;
+
+ /* Try now prefixes. */
+ for (search = default_only ? script_search : search_head;
+ search != NULL;
+ search = search->next)
+ {
+ path = concat (search->name, slash, name, (const char *) NULL);
+ result = try_open (path, sysrooted);
+ free (path);
+ if (result)
+ break;
+ }
+
+ /* Restore the original path list. */
+ *search_tail_ptr = NULL;
+
return result;
}
-void ldfile_open_command_file(name)
-char *name;
+enum script_open_style {
+ script_nonT,
+ script_T,
+ script_defaultT
+};
+
+struct script_name_list
{
- extern FILE *ldlex_input_stack;
- ldlex_input_stack = find_a_name(name, ".ld");
-
- if (ldlex_input_stack == (FILE *)NULL) {
- info("%P%F cannot open load script file %s\n",name);
- }
- ldfile_input_filename = name;
- had_script = true;
-}
+ struct script_name_list *next;
+ enum script_open_style open_how;
+ char name[1];
+};
+/* Open command file NAME. */
+static void
+ldfile_open_command_file_1 (const char *name, enum script_open_style open_how)
+{
+ FILE *ldlex_input_stack;
+ bfd_boolean sysrooted;
+ static struct script_name_list *processed_scripts = NULL;
+ 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 (_("%F%P: cannot open linker script file %s: %E\n"), name);
+ return;
+ }
+ lex_push_file (ldlex_input_stack, name, sysrooted);
-#ifdef GNU960
-static
-char *
-gnu960_map_archname( name )
-char *name;
-{
- struct tabentry { char *cmd_switch; char *arch; };
- static struct tabentry arch_tab[] = {
- "", "",
- "KA", "ka",
- "KB", "kb",
- "KC", "mc", /* Synonym for MC */
- "MC", "mc",
- "CA", "ca",
- "SA", "ka", /* Functionally equivalent to KA */
- "SB", "kb", /* Functionally equivalent to KB */
- NULL, ""
- };
- struct tabentry *tp;
-
-
- for ( tp = arch_tab; tp->cmd_switch != NULL; tp++ ){
- if ( !strcmp(name,tp->cmd_switch) ){
- break;
- }
- }
+ lineno = 1;
- if ( tp->cmd_switch == NULL ){
- info("%P%F: unknown architecture: %s\n",name);
- }
- return tp->arch;
+ saved_script_handle = ldlex_input_stack;
}
-
+/* Open command file NAME in the current directory, -L directories,
+ the default script location, in that order. */
void
-ldfile_add_arch(name)
-char *name;
+ldfile_open_command_file (const char *name)
{
- search_arch_type *new =
- (search_arch_type *)ldmalloc(sizeof(search_arch_type));
-
-
- if (*name != '\0') {
- if (ldfile_output_machine_name[0] != '\0') {
- info("%P%F: target architecture respecified\n");
- return;
- }
- ldfile_output_machine_name = name;
- }
-
- new->next = (search_arch_type*)NULL;
- new->name = gnu960_map_archname( name );
- *search_arch_tail_ptr = new;
- search_arch_tail_ptr = &new->next;
+ ldfile_open_command_file_1 (name, script_nonT);
+}
+void
+ldfile_open_script_file (const char *name)
+{
+ ldfile_open_command_file_1 (name, script_T);
}
-#else /* not GNU960 */
+/* Open command file NAME at the default script location. */
+void
+ldfile_open_default_command_file (const char *name)
+{
+ ldfile_open_command_file_1 (name, script_defaultT);
+}
void
-DEFUN(ldfile_add_arch,(in_name),
- CONST char * in_name)
+ldfile_add_arch (const char *in_name)
{
- char *name = buystring(in_name);
- search_arch_type *new =
- (search_arch_type *)ldmalloc(sizeof(search_arch_type));
+ char *name = xstrdup (in_name);
+ search_arch_type *new_arch
+ = (search_arch_type *) xmalloc (sizeof (search_arch_type));
ldfile_output_machine_name = in_name;
- new->name = name;
- new->next = (search_arch_type*)NULL;
- while (*name) {
- if (isupper(*name)) *name = tolower(*name);
- name++;
- }
- *search_arch_tail_ptr = new;
- search_arch_tail_ptr = &new->next;
+ new_arch->name = name;
+ new_arch->next = NULL;
+ while (*name)
+ {
+ *name = TOLOWER (*name);
+ name++;
+ }
+ *search_arch_tail_ptr = new_arch;
+ search_arch_tail_ptr = &new_arch->next;
}
-#endif
-/* Set the output architecture */
+/* Set the output architecture. */
+
void
-DEFUN(ldfile_set_output_arch,(string),
-CONST char *string)
+ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
{
- enum bfd_architecture arch;
- unsigned long machine;
- if (bfd_scan_arch_mach(string, &arch, &machine) == true) {
- ldfile_output_architecture = arch;
- ldfile_output_machine = machine;
- ldfile_output_machine_name = string;
- }
- else {
- info("%P%F: Can't represent machine `%s'\n", string);
- }
+ const bfd_arch_info_type *arch = bfd_scan_arch (string);
+
+ if (arch)
+ {
+ ldfile_output_architecture = arch->arch;
+ ldfile_output_machine = arch->mach;
+ ldfile_output_machine_name = arch->printable_name;
+ }
+ else if (defarch != bfd_arch_unknown)
+ ldfile_output_architecture = defarch;
+ else
+ einfo (_("%F%P: cannot represent machine `%s'\n"), string);
}