ld/ldfile.c

   1 /* Linker file opening and searching.
   2    Copyright (C) 1991-2020 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 bfd_boolean 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 bfd_boolean
  72 is_sysrooted_pathname (const char *name)
  73 {
  74   char *realname;
  75   int len;
  76   bfd_boolean 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
  99 ldfile_add_library_path (const char *name, bfd_boolean 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 (CONST_STRNEQ (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 bfd_boolean
 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_both ();
 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 bfd_boolean
 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
 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       bfd_boolean 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           else
 465             einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 466
 467           /* PR 25747: Be kind to users who forgot to add the
 468              "lib" prefix to their library when it was created.  */
 469           for (arch = search_arch_head; arch != NULL; arch = arch->next)
 470             {
 471               if (ldfile_open_file_search (arch->name, entry, "", ".a"))
 472                 {
 473                   const char * base = lbasename (entry->filename);
 474
 475                   einfo (_("%P: note to link with %s use -l:%s or rename it to lib%s\n"),
 476                          entry->filename, base, base);
 477                   bfd_close (entry->the_bfd);
 478                   entry->the_bfd = NULL;
 479                   break;
 480                 }
 481             }
 482           entry->flags.missing_file = TRUE;
 483           input_flags.missing_file = TRUE;
 484         }
 485     }
 486 }
 487
 488 /* Try to open NAME.  */
 489
 490 static FILE *
 491 try_open (const char *name, bfd_boolean *sysrooted)
 492 {
 493   FILE *result;
 494
 495   result = fopen (name, "r");
 496
 497   if (result != NULL)
 498     *sysrooted = is_sysrooted_pathname (name);
 499
 500   if (verbose)
 501     {
 502       if (result == NULL)
 503         info_msg (_("cannot find script file %s\n"), name);
 504       else
 505         info_msg (_("opened script file %s\n"), name);
 506     }
 507
 508   return result;
 509 }
 510
 511 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 512
 513 static bfd_boolean
 514 check_for_scripts_dir (char *dir)
 515 {
 516   char *buf;
 517   struct stat s;
 518   bfd_boolean res;
 519
 520   buf = concat (dir, "/ldscripts", (const char *) NULL);
 521   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 522   free (buf);
 523   return res;
 524 }
 525
 526 /* Return the default directory for finding script files.
 527    We look for the "ldscripts" directory in:
 528
 529    SCRIPTDIR (passed from Makefile)
 530              (adjusted according to the current location of the binary)
 531    the dir where this program is (for using it from the build tree).  */
 532
 533 static char *
 534 find_scripts_dir (void)
 535 {
 536   char *dir;
 537
 538   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 539   if (dir)
 540     {
 541       if (check_for_scripts_dir (dir))
 542         return dir;
 543       free (dir);
 544     }
 545
 546   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 547   if (dir)
 548     {
 549       if (check_for_scripts_dir (dir))
 550         return dir;
 551       free (dir);
 552     }
 553
 554   /* Look for "ldscripts" in the dir where our binary is.  */
 555   dir = make_relative_prefix (program_name, ".", ".");
 556   if (dir)
 557     {
 558       if (check_for_scripts_dir (dir))
 559         return dir;
 560       free (dir);
 561     }
 562
 563   return NULL;
 564 }
 565
 566 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
 567    it in directories specified with -L, then in the default script
 568    directory.  If DEFAULT_ONLY is true, the search is restricted to
 569    the default script location.  */
 570
 571 static FILE *
 572 ldfile_find_command_file (const char *name,
 573                           bfd_boolean default_only,
 574                           bfd_boolean *sysrooted)
 575 {
 576   search_dirs_type *search;
 577   FILE *result = NULL;
 578   char *path;
 579   static search_dirs_type *script_search;
 580
 581   if (!default_only)
 582     {
 583       /* First try raw name.  */
 584       result = try_open (name, sysrooted);
 585       if (result != NULL)
 586         return result;
 587     }
 588
 589   if (!script_search)
 590     {
 591       char *script_dir = find_scripts_dir ();
 592       if (script_dir)
 593         {
 594           search_dirs_type **save_tail_ptr = search_tail_ptr;
 595           search_tail_ptr = &script_search;
 596           ldfile_add_library_path (script_dir, TRUE);
 597           search_tail_ptr = save_tail_ptr;
 598         }
 599     }
 600
 601   /* Temporarily append script_search to the path list so that the
 602      paths specified with -L will be searched first.  */
 603   *search_tail_ptr = script_search;
 604
 605   /* Try now prefixes.  */
 606   for (search = default_only ? script_search : search_head;
 607        search != NULL;
 608        search = search->next)
 609     {
 610       path = concat (search->name, slash, name, (const char *) NULL);
 611       result = try_open (path, sysrooted);
 612       free (path);
 613       if (result)
 614         break;
 615     }
 616
 617   /* Restore the original path list.  */
 618   *search_tail_ptr = NULL;
 619
 620   return result;
 621 }
 622
 623 enum script_open_style {
 624   script_nonT,
 625   script_T,
 626   script_defaultT
 627 };
 628
 629 struct script_name_list
 630 {
 631   struct script_name_list *next;
 632   enum script_open_style open_how;
 633   char name[1];
 634 };
 635
 636 /* Open command file NAME.  */
 637
 638 static void
 639 ldfile_open_command_file_1 (const char *name, enum script_open_style open_how)
 640 {
 641   FILE *ldlex_input_stack;
 642   bfd_boolean sysrooted;
 643   static struct script_name_list *processed_scripts = NULL;
 644   struct script_name_list *script;
 645   size_t len;
 646
 647   /* PR 24576: Catch the case where the user has accidentally included
 648      the same linker script twice.  */
 649   for (script = processed_scripts; script != NULL; script = script->next)
 650     {
 651       if ((open_how != script_nonT || script->open_how != script_nonT)
 652           && strcmp (name, script->name) == 0)
 653         {
 654           einfo (_("%F%P: error: linker script file '%s'"
 655                    " appears multiple times\n"), name);
 656           return;
 657         }
 658     }
 659
 660   /* FIXME: This memory is never freed, but that should not really matter.
 661      It will be released when the linker exits, and it is unlikely to ever
 662      be more than a few tens of bytes.  */
 663   len = strlen (name);
 664   script = xmalloc (sizeof (*script) + len);
 665   script->next = processed_scripts;
 666   script->open_how = open_how;
 667   memcpy (script->name, name, len + 1);
 668   processed_scripts = script;
 669
 670   ldlex_input_stack = ldfile_find_command_file (name,
 671                                                 open_how == script_defaultT,
 672                                                 &sysrooted);
 673   if (ldlex_input_stack == NULL)
 674     {
 675       bfd_set_error (bfd_error_system_call);
 676       einfo (_("%F%P: cannot open linker script file %s: %E\n"), name);
 677       return;
 678     }
 679
 680   track_dependency_files (name);
 681
 682   lex_push_file (ldlex_input_stack, name, sysrooted);
 683
 684   lineno = 1;
 685
 686   saved_script_handle = ldlex_input_stack;
 687 }
 688
 689 /* Open command file NAME in the current directory, -L directories,
 690    the default script location, in that order.  */
 691
 692 void
 693 ldfile_open_command_file (const char *name)
 694 {
 695   ldfile_open_command_file_1 (name, script_nonT);
 696 }
 697
 698 void
 699 ldfile_open_script_file (const char *name)
 700 {
 701   ldfile_open_command_file_1 (name, script_T);
 702 }
 703
 704 /* Open command file NAME at the default script location.  */
 705
 706 void
 707 ldfile_open_default_command_file (const char *name)
 708 {
 709   ldfile_open_command_file_1 (name, script_defaultT);
 710 }
 711
 712 void
 713 ldfile_add_arch (const char *in_name)
 714 {
 715   char *name = xstrdup (in_name);
 716   search_arch_type *new_arch
 717     = (search_arch_type *) xmalloc (sizeof (search_arch_type));
 718
 719   ldfile_output_machine_name = in_name;
 720
 721   new_arch->name = name;
 722   new_arch->next = NULL;
 723   while (*name)
 724     {
 725       *name = TOLOWER (*name);
 726       name++;
 727     }
 728   *search_arch_tail_ptr = new_arch;
 729   search_arch_tail_ptr = &new_arch->next;
 730
 731 }
 732
 733 /* Set the output architecture.  */
 734
 735 void
 736 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 737 {
 738   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 739
 740   if (arch)
 741     {
 742       ldfile_output_architecture = arch->arch;
 743       ldfile_output_machine = arch->mach;
 744       ldfile_output_machine_name = arch->printable_name;
 745     }
 746   else if (defarch != bfd_arch_unknown)
 747     ldfile_output_architecture = defarch;
 748   else
 749     einfo (_("%F%P: cannot represent machine `%s'\n"), string);
 750 }