xref: /netbsd-src/external/gpl3/binutils.old/dist/ld/ldfile.c (revision e992f068c547fd6e84b3f104dc2340adcc955732)
1 /* Linker file opening and searching.
2    Copyright (C) 1991-2022 Free Software Foundation, Inc.
3 
4    This file is part of the GNU Binutils.
5 
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10 
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15 
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20 
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfdlink.h"
24 #include "ctf-api.h"
25 #include "safe-ctype.h"
26 #include "ld.h"
27 #include "ldmisc.h"
28 #include "ldexp.h"
29 #include "ldlang.h"
30 #include "ldfile.h"
31 #include "ldmain.h"
32 #include <ldgram.h>
33 #include "ldlex.h"
34 #include "ldemul.h"
35 #include "libiberty.h"
36 #include "filenames.h"
37 #if BFD_SUPPORTS_PLUGINS
38 #include "plugin-api.h"
39 #include "plugin.h"
40 #endif /* BFD_SUPPORTS_PLUGINS */
41 
42 bool ldfile_assumed_script = false;
43 const char *ldfile_output_machine_name = "";
44 unsigned long ldfile_output_machine;
45 enum bfd_architecture ldfile_output_architecture;
46 search_dirs_type *search_head;
47 
48 #ifdef VMS
49 static char *slash = "";
50 #else
51 #if defined (_WIN32) && !defined (__CYGWIN32__)
52 static char *slash = "\\";
53 #else
54 static char *slash = "/";
55 #endif
56 #endif
57 
58 typedef struct search_arch
59 {
60   char *name;
61   struct search_arch *next;
62 } search_arch_type;
63 
64 static search_dirs_type **search_tail_ptr = &search_head;
65 static search_arch_type *search_arch_head;
66 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
67 
68 /* Test whether a pathname, after canonicalization, is the same or a
69    sub-directory of the sysroot directory.  */
70 
71 static bool
is_sysrooted_pathname(const char * name)72 is_sysrooted_pathname (const char *name)
73 {
74   char *realname;
75   int len;
76   bool result;
77 
78   if (ld_canon_sysroot == NULL)
79     return false;
80 
81   realname = lrealpath (name);
82   len = strlen (realname);
83   result = false;
84   if (len > ld_canon_sysroot_len
85       && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
86     {
87       realname[ld_canon_sysroot_len] = '\0';
88       result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
89     }
90 
91   free (realname);
92   return result;
93 }
94 
95 /* Adds NAME to the library search path.
96    Makes a copy of NAME using xmalloc().  */
97 
98 void
ldfile_add_library_path(const char * name,bool cmdline)99 ldfile_add_library_path (const char *name, bool cmdline)
100 {
101   search_dirs_type *new_dirs;
102 
103   if (!cmdline && config.only_cmd_line_lib_dirs)
104     return;
105 
106   new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
107   new_dirs->next = NULL;
108   new_dirs->cmdline = cmdline;
109   *search_tail_ptr = new_dirs;
110   search_tail_ptr = &new_dirs->next;
111 
112   /* If a directory is marked as honoring sysroot, prepend the sysroot path
113      now.  */
114   if (name[0] == '=')
115     new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
116   else if (startswith (name, "$SYSROOT"))
117     new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL);
118   else
119     new_dirs->name = xstrdup (name);
120 }
121 
122 /* Try to open a BFD for a lang_input_statement.  */
123 
124 bool
ldfile_try_open_bfd(const char * attempt,lang_input_statement_type * entry)125 ldfile_try_open_bfd (const char *attempt,
126 		     lang_input_statement_type *entry)
127 {
128   entry->the_bfd = bfd_openr (attempt, entry->target);
129 
130   if (verbose)
131     {
132       if (entry->the_bfd == NULL)
133 	info_msg (_("attempt to open %s failed\n"), attempt);
134       else
135 	info_msg (_("attempt to open %s succeeded\n"), attempt);
136     }
137 
138   if (entry->the_bfd == NULL)
139     {
140       if (bfd_get_error () == bfd_error_invalid_target)
141 	einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
142       return false;
143     }
144 
145   track_dependency_files (attempt);
146 
147   /* Linker needs to decompress sections.  */
148   entry->the_bfd->flags |= BFD_DECOMPRESS;
149 
150   /* This is a linker input BFD.  */
151   entry->the_bfd->is_linker_input = 1;
152 
153 #if BFD_SUPPORTS_PLUGINS
154   if (entry->flags.lto_output)
155     entry->the_bfd->lto_output = 1;
156 #endif
157 
158   /* If we are searching for this file, see if the architecture is
159      compatible with the output file.  If it isn't, keep searching.
160      If we can't open the file as an object file, stop the search
161      here.  If we are statically linking, ensure that we don't link
162      a dynamic object.
163 
164      In the code below, it's OK to exit early if the check fails,
165      closing the checked BFD and returning false, but if the BFD
166      checks out compatible, do not exit early returning true, or
167      the plugins will not get a chance to claim the file.  */
168 
169   if (entry->flags.search_dirs || !entry->flags.dynamic)
170     {
171       bfd *check;
172 
173       if (bfd_check_format (entry->the_bfd, bfd_archive))
174 	check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
175       else
176 	check = entry->the_bfd;
177 
178       if (check != NULL)
179 	{
180 	  if (!bfd_check_format (check, bfd_object))
181 	    {
182 	      if (check == entry->the_bfd
183 		  && entry->flags.search_dirs
184 		  && bfd_get_error () == bfd_error_file_not_recognized
185 		  && !ldemul_unrecognized_file (entry))
186 		{
187 		  int token, skip = 0;
188 		  char *arg, *arg1, *arg2, *arg3;
189 		  extern FILE *yyin;
190 
191 		  /* Try to interpret the file as a linker script.  */
192 		  ldfile_open_command_file (attempt);
193 
194 		  ldfile_assumed_script = true;
195 		  parser_input = input_selected;
196 		  ldlex_script ();
197 		  token = INPUT_SCRIPT;
198 		  while (token != 0)
199 		    {
200 		      switch (token)
201 			{
202 			case OUTPUT_FORMAT:
203 			  if ((token = yylex ()) != '(')
204 			    continue;
205 			  if ((token = yylex ()) != NAME)
206 			    continue;
207 			  arg1 = yylval.name;
208 			  arg2 = NULL;
209 			  arg3 = NULL;
210 			  token = yylex ();
211 			  if (token == ',')
212 			    {
213 			      if ((token = yylex ()) != NAME)
214 				{
215 				  free (arg1);
216 				  continue;
217 				}
218 			      arg2 = yylval.name;
219 			      if ((token = yylex ()) != ','
220 				  || (token = yylex ()) != NAME)
221 				{
222 				  free (arg1);
223 				  free (arg2);
224 				  continue;
225 				}
226 			      arg3 = yylval.name;
227 			      token = yylex ();
228 			    }
229 			  if (token == ')')
230 			    {
231 			      switch (command_line.endian)
232 				{
233 				default:
234 				case ENDIAN_UNSET:
235 				  arg = arg1; break;
236 				case ENDIAN_BIG:
237 				  arg = arg2 ? arg2 : arg1; break;
238 				case ENDIAN_LITTLE:
239 				  arg = arg3 ? arg3 : arg1; break;
240 				}
241 			      if (strcmp (arg, lang_get_output_target ()) != 0)
242 				skip = 1;
243 			    }
244 			  free (arg1);
245 			  free (arg2);
246 			  free (arg3);
247 			  break;
248 			case NAME:
249 			case LNAME:
250 			case VERS_IDENTIFIER:
251 			case VERS_TAG:
252 			  free (yylval.name);
253 			  break;
254 			case INT:
255 			  free (yylval.bigint.str);
256 			  break;
257 			}
258 		      token = yylex ();
259 		    }
260 		  ldlex_popstate ();
261 		  ldfile_assumed_script = false;
262 		  fclose (yyin);
263 		  yyin = NULL;
264 		  if (skip)
265 		    {
266 		      if (command_line.warn_search_mismatch)
267 			einfo (_("%P: skipping incompatible %s "
268 				 "when searching for %s\n"),
269 			       attempt, entry->local_sym_name);
270 		      bfd_close (entry->the_bfd);
271 		      entry->the_bfd = NULL;
272 		      return false;
273 		    }
274 		}
275 	      goto success;
276 	    }
277 
278 	  if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
279 	    {
280 	      einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
281 		     attempt);
282 	      bfd_close (entry->the_bfd);
283 	      entry->the_bfd = NULL;
284 	      return false;
285 	    }
286 
287 	  if (entry->flags.search_dirs
288 	      && !bfd_arch_get_compatible (check, link_info.output_bfd,
289 					   command_line.accept_unknown_input_arch)
290 	      /* XCOFF archives can have 32 and 64 bit objects.  */
291 	      && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour
292 		   && (bfd_get_flavour (link_info.output_bfd)
293 		       == bfd_target_xcoff_flavour)
294 		   && bfd_check_format (entry->the_bfd, bfd_archive)))
295 	    {
296 	      if (command_line.warn_search_mismatch)
297 		einfo (_("%P: skipping incompatible %s "
298 			 "when searching for %s\n"),
299 		       attempt, entry->local_sym_name);
300 	      bfd_close (entry->the_bfd);
301 	      entry->the_bfd = NULL;
302 	      return false;
303 	    }
304 	}
305     }
306  success:
307 #if BFD_SUPPORTS_PLUGINS
308   /* If plugins are active, they get first chance to claim
309      any successfully-opened input file.  We skip archives
310      here; the plugin wants us to offer it the individual
311      members when we enumerate them, not the whole file.  We
312      also ignore corefiles, because that's just weird.  It is
313      a needed side-effect of calling  bfd_check_format with
314      bfd_object that it sets the bfd's arch and mach, which
315      will be needed when and if we want to bfd_create a new
316      one using this one as a template.  */
317   if (link_info.lto_plugin_active
318       && !no_more_claiming
319       && bfd_check_format (entry->the_bfd, bfd_object))
320     plugin_maybe_claim (entry);
321 #endif /* BFD_SUPPORTS_PLUGINS */
322 
323   /* It opened OK, the format checked out, and the plugins have had
324      their chance to claim it, so this is success.  */
325   return true;
326 }
327 
328 /* Search for and open the file specified by ENTRY.  If it is an
329    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
330 
331 bool
ldfile_open_file_search(const char * arch,lang_input_statement_type * entry,const char * lib,const char * suffix)332 ldfile_open_file_search (const char *arch,
333 			 lang_input_statement_type *entry,
334 			 const char *lib,
335 			 const char *suffix)
336 {
337   search_dirs_type *search;
338 
339   /* If this is not an archive, try to open it in the current
340      directory first.  */
341   if (!entry->flags.maybe_archive)
342     {
343       if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
344 	{
345 	  char *name = concat (ld_sysroot, entry->filename,
346 			       (const char *) NULL);
347 	  if (ldfile_try_open_bfd (name, entry))
348 	    {
349 	      entry->filename = name;
350 	      return true;
351 	    }
352 	  free (name);
353 	}
354       else if (ldfile_try_open_bfd (entry->filename, entry))
355 	return true;
356 
357       if (IS_ABSOLUTE_PATH (entry->filename))
358 	return false;
359     }
360 
361   for (search = search_head; search != NULL; search = search->next)
362     {
363       char *string;
364 
365       if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
366 	{
367 	  if (ldemul_open_dynamic_archive (arch, search, entry))
368 	    return true;
369 	}
370 
371       if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
372 	string = concat (search->name, slash, lib, entry->filename,
373 			 arch, suffix, (const char *) NULL);
374       else
375 	string = concat (search->name, slash, entry->filename,
376 			 (const char *) 0);
377 
378       if (ldfile_try_open_bfd (string, entry))
379 	{
380 	  entry->filename = string;
381 	  return true;
382 	}
383 
384       free (string);
385     }
386 
387   return false;
388 }
389 
390 /* Open the input file specified by ENTRY.
391    PR 4437: Do not stop on the first missing file, but
392    continue processing other input files in case there
393    are more errors to report.  */
394 
395 void
ldfile_open_file(lang_input_statement_type * entry)396 ldfile_open_file (lang_input_statement_type *entry)
397 {
398   if (entry->the_bfd != NULL)
399     return;
400 
401   if (!entry->flags.search_dirs)
402     {
403       if (ldfile_try_open_bfd (entry->filename, entry))
404 	return;
405 
406       if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
407 	einfo (_("%P: cannot find %s (%s): %E\n"),
408 	       entry->filename, entry->local_sym_name);
409       else
410 	einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
411 
412       entry->flags.missing_file = true;
413       input_flags.missing_file = true;
414     }
415   else
416     {
417       search_arch_type *arch;
418       bool found = false;
419 
420       /* If extra_search_path is set, entry->filename is a relative path.
421 	 Search the directory of the current linker script before searching
422 	 other paths. */
423       if (entry->extra_search_path)
424 	{
425 	  char *path = concat (entry->extra_search_path, slash, entry->filename,
426 			       (const char *)0);
427 	  if (ldfile_try_open_bfd (path, entry))
428 	    {
429 	      entry->filename = path;
430 	      entry->flags.search_dirs = false;
431 	      return;
432 	    }
433 
434 	  free (path);
435 	}
436 
437       /* Try to open <filename><suffix> or lib<filename><suffix>.a.  */
438       for (arch = search_arch_head; arch != NULL; arch = arch->next)
439 	{
440 	  found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
441 	  if (found)
442 	    break;
443 #ifdef VMS
444 	  found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
445 	  if (found)
446 	    break;
447 #endif
448 	  found = ldemul_find_potential_libraries (arch->name, entry);
449 	  if (found)
450 	    break;
451 	}
452 
453       /* If we have found the file, we don't need to search directories
454 	 again.  */
455       if (found)
456 	entry->flags.search_dirs = false;
457       else
458 	{
459 	  if (entry->flags.sysrooted
460 	       && ld_sysroot
461 	       && IS_ABSOLUTE_PATH (entry->local_sym_name))
462 	    einfo (_("%P: cannot find %s inside %s\n"),
463 		   entry->local_sym_name, ld_sysroot);
464 #if SUPPORT_ERROR_HANDLING_SCRIPT
465 	  else if (error_handling_script != NULL)
466 	    {
467 	      char *        argv[4];
468 	      const char *  res;
469 	      int           status, err;
470 
471 	      argv[0] = error_handling_script;
472 	      argv[1] = "missing-lib";
473 	      argv[2] = (char *) entry->local_sym_name;
474 	      argv[3] = NULL;
475 
476 	      if (verbose)
477 		einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"),
478 		       argv[0], argv[1], argv[2]);
479 
480 	      res = pex_one (PEX_SEARCH, error_handling_script, argv,
481 			     N_("error handling script"),
482 			     NULL /* Send stdout to random, temp file.  */,
483 			     NULL /* Write to stderr.  */,
484 			     &status, &err);
485 	      if (res != NULL)
486 		{
487 		  einfo (_("%P: Failed to run error handling script '%s', reason: "),
488 			 error_handling_script);
489 		  /* FIXME: We assume here that errrno == err.  */
490 		  perror (res);
491 		}
492 	      else /* We ignore the return status of the script
493 		      and always print the error message.  */
494 		einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
495 	    }
496 #endif
497 	  else
498 	    einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
499 
500 	  /* PR 25747: Be kind to users who forgot to add the
501 	     "lib" prefix to their library when it was created.  */
502 	  for (arch = search_arch_head; arch != NULL; arch = arch->next)
503 	    {
504 	      if (ldfile_open_file_search (arch->name, entry, "", ".a"))
505 		{
506 		  const char * base = lbasename (entry->filename);
507 
508 		  einfo (_("%P: note to link with %s use -l:%s or rename it to lib%s\n"),
509 			 entry->filename, base, base);
510 		  bfd_close (entry->the_bfd);
511 		  entry->the_bfd = NULL;
512 		  break;
513 		}
514 	    }
515 
516 	  entry->flags.missing_file = true;
517 	  input_flags.missing_file = true;
518 	}
519     }
520 }
521 
522 /* Try to open NAME.  */
523 
524 static FILE *
try_open(const char * name,bool * sysrooted)525 try_open (const char *name, bool *sysrooted)
526 {
527   FILE *result;
528 
529   result = fopen (name, "r");
530 
531   if (result != NULL)
532     *sysrooted = is_sysrooted_pathname (name);
533 
534   if (verbose)
535     {
536       if (result == NULL)
537 	info_msg (_("cannot find script file %s\n"), name);
538       else
539 	info_msg (_("opened script file %s\n"), name);
540     }
541 
542   return result;
543 }
544 
545 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
546 
547 static bool
check_for_scripts_dir(char * dir)548 check_for_scripts_dir (char *dir)
549 {
550   char *buf;
551   struct stat s;
552   bool res;
553 
554   buf = concat (dir, "/ldscripts", (const char *) NULL);
555   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
556   free (buf);
557   return res;
558 }
559 
560 /* Return the default directory for finding script files.
561    We look for the "ldscripts" directory in:
562 
563    SCRIPTDIR (passed from Makefile)
564 	     (adjusted according to the current location of the binary)
565    the dir where this program is (for using it from the build tree).  */
566 
567 static char *
find_scripts_dir(void)568 find_scripts_dir (void)
569 {
570   char *dir;
571 
572   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
573   if (dir)
574     {
575       if (check_for_scripts_dir (dir))
576 	return dir;
577       free (dir);
578     }
579 
580   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
581   if (dir)
582     {
583       if (check_for_scripts_dir (dir))
584 	return dir;
585       free (dir);
586     }
587 
588   /* Look for "ldscripts" in the dir where our binary is.  */
589   dir = make_relative_prefix (program_name, ".", ".");
590   if (dir)
591     {
592       if (check_for_scripts_dir (dir))
593 	return dir;
594       free (dir);
595     }
596 
597   return NULL;
598 }
599 
600 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
601    it in directories specified with -L, then in the default script
602    directory.  If DEFAULT_ONLY is true, the search is restricted to
603    the default script location.  */
604 
605 static FILE *
ldfile_find_command_file(const char * name,bool default_only,bool * sysrooted)606 ldfile_find_command_file (const char *name,
607 			  bool default_only,
608 			  bool *sysrooted)
609 {
610   search_dirs_type *search;
611   FILE *result = NULL;
612   char *path;
613   static search_dirs_type *script_search;
614 
615   if (!default_only)
616     {
617       /* First try raw name.  */
618       result = try_open (name, sysrooted);
619       if (result != NULL)
620 	return result;
621     }
622 
623   if (!script_search)
624     {
625       char *script_dir = find_scripts_dir ();
626       if (script_dir)
627 	{
628 	  search_dirs_type **save_tail_ptr = search_tail_ptr;
629 	  search_tail_ptr = &script_search;
630 	  ldfile_add_library_path (script_dir, true);
631 	  search_tail_ptr = save_tail_ptr;
632 	}
633     }
634 
635   /* Temporarily append script_search to the path list so that the
636      paths specified with -L will be searched first.  */
637   *search_tail_ptr = script_search;
638 
639   /* Try now prefixes.  */
640   for (search = default_only ? script_search : search_head;
641        search != NULL;
642        search = search->next)
643     {
644       path = concat (search->name, slash, name, (const char *) NULL);
645       result = try_open (path, sysrooted);
646       free (path);
647       if (result)
648 	break;
649     }
650 
651   /* Restore the original path list.  */
652   *search_tail_ptr = NULL;
653 
654   return result;
655 }
656 
657 enum script_open_style {
658   script_nonT,
659   script_T,
660   script_defaultT
661 };
662 
663 struct script_name_list
664 {
665   struct script_name_list *next;
666   enum script_open_style open_how;
667   char name[1];
668 };
669 
670 /* Open command file NAME.  */
671 
672 static void
ldfile_open_command_file_1(const char * name,enum script_open_style open_how)673 ldfile_open_command_file_1 (const char *name, enum script_open_style open_how)
674 {
675   FILE *ldlex_input_stack;
676   bool sysrooted;
677   static struct script_name_list *processed_scripts = NULL;
678   struct script_name_list *script;
679   size_t len;
680 
681   /* PR 24576: Catch the case where the user has accidentally included
682      the same linker script twice.  */
683   for (script = processed_scripts; script != NULL; script = script->next)
684     {
685       if ((open_how != script_nonT || script->open_how != script_nonT)
686 	  && strcmp (name, script->name) == 0)
687 	{
688 	  einfo (_("%F%P: error: linker script file '%s'"
689 		   " appears multiple times\n"), name);
690 	  return;
691 	}
692     }
693 
694   /* FIXME: This memory is never freed, but that should not really matter.
695      It will be released when the linker exits, and it is unlikely to ever
696      be more than a few tens of bytes.  */
697   len = strlen (name);
698   script = xmalloc (sizeof (*script) + len);
699   script->next = processed_scripts;
700   script->open_how = open_how;
701   memcpy (script->name, name, len + 1);
702   processed_scripts = script;
703 
704   ldlex_input_stack = ldfile_find_command_file (name,
705 						open_how == script_defaultT,
706 						&sysrooted);
707   if (ldlex_input_stack == NULL)
708     {
709       bfd_set_error (bfd_error_system_call);
710       einfo (_("%F%P: cannot open linker script file %s: %E\n"), name);
711       return;
712     }
713 
714   track_dependency_files (name);
715 
716   lex_push_file (ldlex_input_stack, name, sysrooted);
717 
718   lineno = 1;
719 
720   saved_script_handle = ldlex_input_stack;
721 }
722 
723 /* Open command file NAME in the current directory, -L directories,
724    the default script location, in that order.  */
725 
726 void
ldfile_open_command_file(const char * name)727 ldfile_open_command_file (const char *name)
728 {
729   ldfile_open_command_file_1 (name, script_nonT);
730 }
731 
732 void
ldfile_open_script_file(const char * name)733 ldfile_open_script_file (const char *name)
734 {
735   ldfile_open_command_file_1 (name, script_T);
736 }
737 
738 /* Open command file NAME at the default script location.  */
739 
740 void
ldfile_open_default_command_file(const char * name)741 ldfile_open_default_command_file (const char *name)
742 {
743   ldfile_open_command_file_1 (name, script_defaultT);
744 }
745 
746 void
ldfile_add_arch(const char * in_name)747 ldfile_add_arch (const char *in_name)
748 {
749   char *name = xstrdup (in_name);
750   search_arch_type *new_arch
751     = (search_arch_type *) xmalloc (sizeof (search_arch_type));
752 
753   ldfile_output_machine_name = in_name;
754 
755   new_arch->name = name;
756   new_arch->next = NULL;
757   while (*name)
758     {
759       *name = TOLOWER (*name);
760       name++;
761     }
762   *search_arch_tail_ptr = new_arch;
763   search_arch_tail_ptr = &new_arch->next;
764 
765 }
766 
767 /* Set the output architecture.  */
768 
769 void
ldfile_set_output_arch(const char * string,enum bfd_architecture defarch)770 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
771 {
772   const bfd_arch_info_type *arch = bfd_scan_arch (string);
773 
774   if (arch)
775     {
776       ldfile_output_architecture = arch->arch;
777       ldfile_output_machine = arch->mach;
778       ldfile_output_machine_name = arch->printable_name;
779     }
780   else if (defarch != bfd_arch_unknown)
781     ldfile_output_architecture = defarch;
782   else
783     einfo (_("%F%P: cannot represent machine `%s'\n"), string);
784 }
785