M68K TLS support.
[deliverable/binutils-gdb.git] / ld / ldfile.c
index 4806534a74a0358c8624fe41a4dad5ebb396d70d..a24eae6c038f46cba8443025c17bd7751aeee317 100644 (file)
@@ -1,28 +1,26 @@
 /* Linker file opening and searching.
 /* Linker file opening and searching.
-   Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003
-   Free Software Foundation, Inc.
+   Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
+   2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
 
 
-   This file is part of GLD, the Gnu Linker.
+   This file is part of the GNU Binutils.
 
 
-   GLD is free software; you can redistribute it and/or modify
+   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
    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.
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
 
 
-   GLD is distributed in the hope that it will be useful,
+   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.
 
    You should have received a copy of the GNU General Public License
    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.  */
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
 
 
-/* ldfile.c:  look after all the file stuff.  */
-
-#include "bfd.h"
 #include "sysdep.h"
 #include "sysdep.h"
+#include "bfd.h"
 #include "bfdlink.h"
 #include "safe-ctype.h"
 #include "ld.h"
 #include "bfdlink.h"
 #include "safe-ctype.h"
 #include "ld.h"
@@ -44,20 +42,15 @@ unsigned long ldfile_output_machine;
 enum bfd_architecture ldfile_output_architecture;
 search_dirs_type * search_head;
 
 enum bfd_architecture ldfile_output_architecture;
 search_dirs_type * search_head;
 
-#ifndef MPW
 #ifdef VMS
 #ifdef VMS
-char * slash = "";
+static char * slash = "";
 #else
 #if defined (_WIN32) && ! defined (__CYGWIN32__)
 #else
 #if defined (_WIN32) && ! defined (__CYGWIN32__)
-char * slash = "\\";
+static char * slash = "\\";
 #else
 #else
-char * slash = "/";
+static char * slash = "/";
 #endif
 #endif
 #endif
 #endif
-#else /* MPW */
-/* The MPW path char is a colon.  */
-char * slash = ":";
-#endif /* MPW */
 
 typedef struct search_arch
 {
 
 typedef struct search_arch
 {
@@ -69,18 +62,11 @@ 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;
 
 static search_arch_type *search_arch_head;
 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
 
-static FILE *try_open
-  PARAMS ((const char *, const char *));
-static bfd_boolean is_sysrooted_pathname
-  PARAMS ((const char *, bfd_boolean));
-
 /* Test whether a pathname, after canonicalization, is the same or a
    sub-directory of the sysroot directory.  */
 
 static bfd_boolean
 /* Test whether a pathname, after canonicalization, is the same or a
    sub-directory of the sysroot directory.  */
 
 static bfd_boolean
-is_sysrooted_pathname (name, notsame)
-     const char *name;
-     bfd_boolean notsame;
+is_sysrooted_pathname (const char *name, bfd_boolean notsame)
 {
   char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
   int len;
 {
   char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
   int len;
@@ -88,7 +74,7 @@ is_sysrooted_pathname (name, notsame)
 
   if (! realname)
     return FALSE;
 
   if (! realname)
     return FALSE;
-  
+
   len = strlen (realname);
 
   if (((! notsame && len == ld_canon_sysroot_len)
   len = strlen (realname);
 
   if (((! notsame && len == ld_canon_sysroot_len)
@@ -110,16 +96,14 @@ is_sysrooted_pathname (name, notsame)
    Makes a copy of NAME using xmalloc().  */
 
 void
    Makes a copy of NAME using xmalloc().  */
 
 void
-ldfile_add_library_path (name, cmdline)
-     const char *name;
-     bfd_boolean cmdline;
+ldfile_add_library_path (const char *name, bfd_boolean cmdline)
 {
   search_dirs_type *new;
 
   if (!cmdline && config.only_cmd_line_lib_dirs)
     return;
 
 {
   search_dirs_type *new;
 
   if (!cmdline && config.only_cmd_line_lib_dirs)
     return;
 
-  new = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
+  new = xmalloc (sizeof (search_dirs_type));
   new->next = NULL;
   new->cmdline = cmdline;
   *search_tail_ptr = new;
   new->next = NULL;
   new->cmdline = cmdline;
   *search_tail_ptr = new;
@@ -129,7 +113,7 @@ ldfile_add_library_path (name, cmdline)
      now.  */
   if (name[0] == '=')
     {
      now.  */
   if (name[0] == '=')
     {
-      new->name = concat (ld_sysroot, name + 1, NULL);
+      new->name = concat (ld_sysroot, name + 1, (const char *) NULL);
       new->sysrooted = TRUE;
     }
   else
       new->sysrooted = TRUE;
     }
   else
@@ -142,9 +126,8 @@ ldfile_add_library_path (name, cmdline)
 /* Try to open a BFD for a lang_input_statement.  */
 
 bfd_boolean
 /* Try to open a BFD for a lang_input_statement.  */
 
 bfd_boolean
-ldfile_try_open_bfd (attempt, entry)
-     const char *attempt;
-     lang_input_statement_type *entry;
+ldfile_try_open_bfd (const char *attempt,
+                    lang_input_statement_type *entry)
 {
   entry->the_bfd = bfd_openr (attempt, entry->target);
 
 {
   entry->the_bfd = bfd_openr (attempt, entry->target);
 
@@ -166,9 +149,10 @@ ldfile_try_open_bfd (attempt, entry)
   /* 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
   /* 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.  */
+     here.  If we are statically linking, ensure that we don't link
+     a dynamic object.  */
 
 
-  if (entry->search_dirs_flag)
+  if (entry->search_dirs_flag || !entry->dynamic)
     {
       bfd *check;
 
     {
       bfd *check;
 
@@ -182,6 +166,7 @@ ldfile_try_open_bfd (attempt, entry)
          if (! bfd_check_format (check, bfd_object))
            {
              if (check == entry->the_bfd
          if (! bfd_check_format (check, bfd_object))
            {
              if (check == entry->the_bfd
+                 && entry->search_dirs_flag
                  && bfd_get_error () == bfd_error_file_not_recognized
                  && ! ldemul_unrecognized_file (entry))
                {
                  && bfd_get_error () == bfd_error_file_not_recognized
                  && ! ldemul_unrecognized_file (entry))
                {
@@ -256,7 +241,7 @@ ldfile_try_open_bfd (attempt, entry)
                          if (yylval.bigint.str)
                            free (yylval.bigint.str);
                          break;
                          if (yylval.bigint.str)
                            free (yylval.bigint.str);
                          break;
-                       }
+                       }
                      token = yylex ();
                    }
                  ldlex_popstate ();
                      token = yylex ();
                    }
                  ldlex_popstate ();
@@ -265,8 +250,10 @@ ldfile_try_open_bfd (attempt, entry)
                  yyin = NULL;
                  if (skip)
                    {
                  yyin = NULL;
                  if (skip)
                    {
-                     einfo (_("%P: skipping incompatible %s when searching for %s\n"),
-                            attempt, entry->local_sym_name);
+                     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;
                      bfd_close (entry->the_bfd);
                      entry->the_bfd = NULL;
                      return FALSE;
@@ -275,15 +262,27 @@ ldfile_try_open_bfd (attempt, entry)
              return TRUE;
            }
 
              return TRUE;
            }
 
-         if ((bfd_arch_get_compatible (check, output_bfd,
-                                       command_line.accept_unknown_input_arch) == NULL)
+         if (!entry->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->search_dirs_flag
+             && !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
              /* XCOFF archives can have 32 and 64 bit objects.  */
              && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
-                   && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
+                   && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
                    && bfd_check_format (entry->the_bfd, bfd_archive)))
            {
                    && bfd_check_format (entry->the_bfd, bfd_archive)))
            {
-             einfo (_("%P: skipping incompatible %s when searching for %s\n"),
-                    attempt, entry->local_sym_name);
+             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;
              bfd_close (entry->the_bfd);
              entry->the_bfd = NULL;
              return FALSE;
@@ -298,11 +297,10 @@ ldfile_try_open_bfd (attempt, entry)
    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 
 bfd_boolean
    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 
 bfd_boolean
-ldfile_open_file_search (arch, entry, lib, suffix)
-     const char *arch;
-     lang_input_statement_type *entry;
-     const char *lib;
-     const char *suffix;
+ldfile_open_file_search (const char *arch,
+                        lang_input_statement_type *entry,
+                        const char *lib,
+                        const char *suffix)
 {
   search_dirs_type *search;
 
 {
   search_dirs_type *search;
 
@@ -332,13 +330,11 @@ ldfile_open_file_search (arch, entry, lib, suffix)
        return FALSE;
     }
 
        return FALSE;
     }
 
-  for (search = search_head;
-       search != (search_dirs_type *) NULL;
-       search = search->next)
+  for (search = search_head; search != NULL; search = search->next)
     {
       char *string;
 
     {
       char *string;
 
-      if (entry->dynamic && ! link_info.relocateable)
+      if (entry->dynamic && ! link_info.relocatable)
        {
          if (ldemul_open_dynamic_archive (arch, search, entry))
            {
        {
          if (ldemul_open_dynamic_archive (arch, search, entry))
            {
@@ -347,19 +343,12 @@ ldfile_open_file_search (arch, entry, lib, suffix)
            }
        }
 
            }
        }
 
-      string = (char *) xmalloc (strlen (search->name)
-                                + strlen (slash)
-                                + strlen (lib)
-                                + strlen (entry->filename)
-                                + strlen (arch)
-                                + strlen (suffix)
-                                + 1);
-
       if (entry->is_archive)
       if (entry->is_archive)
-       sprintf (string, "%s%s%s%s%s%s", search->name, slash,
-                lib, entry->filename, arch, suffix);
+       string = concat (search->name, slash, lib, entry->filename,
+                        arch, suffix, (const char *) NULL);
       else
       else
-       sprintf (string, "%s%s%s", search->name, slash, entry->filename);
+       string = concat (search->name, slash, entry->filename,
+                        (const char *) 0);
 
       if (ldfile_try_open_bfd (string, entry))
        {
 
       if (ldfile_try_open_bfd (string, entry))
        {
@@ -377,8 +366,7 @@ ldfile_open_file_search (arch, entry, lib, suffix)
 /* Open the input file specified by ENTRY.  */
 
 void
 /* Open the input file specified by ENTRY.  */
 
 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->the_bfd != NULL)
     return;
@@ -388,10 +376,10 @@ ldfile_open_file (entry)
       if (ldfile_try_open_bfd (entry->filename, entry))
        return;
       if (strcmp (entry->filename, entry->local_sym_name) != 0)
       if (ldfile_try_open_bfd (entry->filename, entry))
        return;
       if (strcmp (entry->filename, entry->local_sym_name) != 0)
-       einfo (_("%F%P: cannot open %s for %s: %E\n"),
+       einfo (_("%F%P: %s (%s): No such file: %E\n"),
               entry->filename, entry->local_sym_name);
       else
               entry->filename, entry->local_sym_name);
       else
-       einfo (_("%F%P: cannot open %s: %E\n"), entry->local_sym_name);
+       einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
     }
   else
     {
     }
   else
     {
@@ -399,9 +387,7 @@ ldfile_open_file (entry)
       bfd_boolean found = FALSE;
 
       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
       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)
+      for (arch = search_arch_head; arch != NULL; arch = arch->next)
        {
          found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
          if (found)
        {
          found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
          if (found)
@@ -433,12 +419,9 @@ ldfile_open_file (entry)
 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 
 static FILE *
 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 
 static FILE *
-try_open (name, exten)
-     const char *name;
-     const char *exten;
+try_open (const char *name, const char *exten)
 {
   FILE *result;
 {
   FILE *result;
-  char buff[1000];
 
   result = fopen (name, "r");
 
 
   result = fopen (name, "r");
 
@@ -455,7 +438,9 @@ try_open (name, exten)
 
   if (*exten)
     {
 
   if (*exten)
     {
-      sprintf (buff, "%s%s", name, exten);
+      char *buff;
+
+      buff = concat (name, exten, (const char *) NULL);
       result = fopen (buff, "r");
 
       if (trace_file_tries)
       result = fopen (buff, "r");
 
       if (trace_file_tries)
@@ -465,51 +450,152 @@ try_open (name, exten)
          else
            info_msg (_("opened script file %s\n"), buff);
        }
          else
            info_msg (_("opened script file %s\n"), buff);
        }
+      free (buff);
     }
 
   return result;
 }
 
     }
 
   return result;
 }
 
-/* Try to open NAME; if that fails, look for it in any directories
-   specified with -L, without and with EXTEND appended.  */
+/* 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)
+   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).  */
+
+static char *
+find_scripts_dir (void)
+{
+  char *end, *dir;
+  size_t dirlen;
+
+  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);
+    }
+
+  if (check_for_scripts_dir (SCRIPTDIR))
+    /* We've been installed normally.  */
+    return SCRIPTDIR;
+
+  /* Look for "ldscripts" in the dir where our binary is.  */
+  end = strrchr (program_name, '/');
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+  {
+    /* 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 NULL;
+
+  dirlen = end - program_name;
+  /* Make a copy of program_name in dir.
+     Leave room for later "/../lib".  */
+  dir = xmalloc (dirlen + sizeof ("/../lib"));
+  strncpy (dir, program_name, dirlen);
+  dir[dirlen] = '\0';
+
+  if (check_for_scripts_dir (dir))
+    return dir;
+
+  /* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
+  strcpy (dir + dirlen, "/../lib");
+  if (check_for_scripts_dir (dir))
+    return dir;
+  free (dir);
+  return NULL;
+}
+
+/* Try to open NAME; if that fails, look for it in the default script
+   directory, then in any directories specified with -L, without and
+   with EXTEND appended.  */
 
 
-FILE *
-ldfile_find_command_file (name, extend)
-     const char *name;
-     const char *extend;
+static FILE *
+ldfile_find_command_file (const char *name, const char *extend)
 {
   search_dirs_type *search;
   FILE *result;
 {
   search_dirs_type *search;
   FILE *result;
-  char buffer[1000];
+  char *buffer;
+  static search_dirs_type *script_search;
 
   /* First try raw name.  */
   result = try_open (name, "");
 
   /* First try raw name.  */
   result = try_open (name, "");
-  if (result == (FILE *) NULL)
+  if (result != NULL)
+    return result;
+
+  if (!script_search)
     {
     {
-      /* Try now prefixes.  */
-      for (search = search_head;
-          search != (search_dirs_type *) NULL;
-          search = search->next)
+      char *script_dir = find_scripts_dir ();
+      if (script_dir)
        {
        {
-         sprintf (buffer, "%s%s%s", search->name, slash, name);
-
-         result = try_open (buffer, extend);
-         if (result)
-           break;
+         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;
        }
        }
+      if (!script_search)
+       script_search = search_head;
+      else
+       script_search->next = search_head;
+    }
+
+  /* Try now prefixes.  */
+  for (search = script_search; search != NULL; search = search->next)
+    {
+
+      buffer = concat (search->name, slash, name, (const char *) NULL);
+      result = try_open (buffer, extend);
+      free (buffer);
+      if (result)
+       break;
     }
 
   return result;
 }
 
 void
     }
 
   return result;
 }
 
 void
-ldfile_open_command_file (name)
-     const char *name;
+ldfile_open_command_file (const char *name)
 {
   FILE *ldlex_input_stack;
   ldlex_input_stack = ldfile_find_command_file (name, "");
 
 {
   FILE *ldlex_input_stack;
   ldlex_input_stack = ldfile_find_command_file (name, "");
 
-  if (ldlex_input_stack == (FILE *) NULL)
+  if (ldlex_input_stack == NULL)
     {
       bfd_set_error (bfd_error_system_call);
       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
     {
       bfd_set_error (bfd_error_system_call);
       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
@@ -523,76 +609,16 @@ ldfile_open_command_file (name)
   saved_script_handle = ldlex_input_stack;
 }
 
   saved_script_handle = ldlex_input_stack;
 }
 
-#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;
-    }
-
-  if (tp->cmd_switch == NULL)
-    einfo (_("%P%F: unknown architecture: %s\n"), name);
-
-  return tp->arch;
-}
-
 void
 void
-ldfile_add_arch (name)
-     char *name;
-{
-  search_arch_type *new =
-    (search_arch_type *) xmalloc ((bfd_size_type) (sizeof (search_arch_type)));
-
-  if (*name != '\0')
-    {
-      if (ldfile_output_machine_name[0] != '\0')
-       {
-         einfo (_("%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;
-}
-
-#else /* not GNU960 */
-
-void
-ldfile_add_arch (in_name)
-     const char *in_name;
+ldfile_add_arch (const char *in_name)
 {
   char *name = xstrdup (in_name);
 {
   char *name = xstrdup (in_name);
-  search_arch_type *new =
-    (search_arch_type *) xmalloc (sizeof (search_arch_type));
+  search_arch_type *new = xmalloc (sizeof (search_arch_type));
 
   ldfile_output_machine_name = in_name;
 
   new->name = name;
 
   ldfile_output_machine_name = in_name;
 
   new->name = name;
-  new->next = (search_arch_type *) NULL;
+  new->next = NULL;
   while (*name)
     {
       *name = TOLOWER (*name);
   while (*name)
     {
       *name = TOLOWER (*name);
@@ -602,13 +628,11 @@ ldfile_add_arch (in_name)
   search_arch_tail_ptr = &new->next;
 
 }
   search_arch_tail_ptr = &new->next;
 
 }
-#endif
 
 /* Set the output architecture.  */
 
 void
 
 /* Set the output architecture.  */
 
 void
-ldfile_set_output_arch (string)
-     const char *string;
+ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 {
   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 
 {
   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 
@@ -618,8 +642,8 @@ ldfile_set_output_arch (string)
       ldfile_output_machine = arch->mach;
       ldfile_output_machine_name = arch->printable_name;
     }
       ldfile_output_machine = arch->mach;
       ldfile_output_machine_name = arch->printable_name;
     }
+  else if (defarch != bfd_arch_unknown)
+    ldfile_output_architecture = defarch;
   else
   else
-    {
-      einfo (_("%P%F: cannot represent machine `%s'\n"), string);
-    }
+    einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 }
 }
This page took 0.030667 seconds and 4 git commands to generate.