ld/ldfile.c

   1 /* Linker file opening and searching.
   2    Copyright (C) 1991-2019 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 "safe-ctype.h"
  25 #include "ld.h"
  26 #include "ldmisc.h"
  27 #include "ldexp.h"
  28 #include "ldlang.h"
  29 #include "ldfile.h"
  30 #include "ldmain.h"
  31 #include <ldgram.h>
  32 #include "ldlex.h"
  33 #include "ldemul.h"
  34 #include "libiberty.h"
  35 #include "filenames.h"
  36 #ifdef ENABLE_PLUGINS
  37 #include "plugin-api.h"
  38 #include "plugin.h"
  39 #endif /* ENABLE_PLUGINS */
  40
  41 bfd_boolean ldfile_assumed_script = FALSE;
  42 const char *ldfile_output_machine_name = "";
  43 unsigned long ldfile_output_machine;
  44 enum bfd_architecture ldfile_output_architecture;
  45 search_dirs_type *search_head;
  46
  47 #ifdef VMS
  48 static char *slash = "";
  49 #else
  50 #if defined (_WIN32) && !defined (__CYGWIN32__)
  51 static char *slash = "\\";
  52 #else
  53 static char *slash = "/";
  54 #endif
  55 #endif
  56
  57 typedef struct search_arch
  58 {
  59   char *name;
  60   struct search_arch *next;
  61 } search_arch_type;
  62
  63 static search_dirs_type **search_tail_ptr = &search_head;
  64 static search_arch_type *search_arch_head;
  65 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
  66
  67 /* Test whether a pathname, after canonicalization, is the same or a
  68    sub-directory of the sysroot directory.  */
  69
  70 static bfd_boolean
  71 is_sysrooted_pathname (const char *name)
  72 {
  73   char *realname;
  74   int len;
  75   bfd_boolean result;
  76
  77   if (ld_canon_sysroot == NULL)
  78     return FALSE;
  79
  80   realname = lrealpath (name);
  81   len = strlen (realname);
  82   result = FALSE;
  83   if (len > ld_canon_sysroot_len
  84       && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
  85     {
  86       realname[ld_canon_sysroot_len] = '\0';
  87       result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
  88     }
  89
  90   free (realname);
  91   return result;
  92 }
  93
  94 /* Adds NAME to the library search path.
  95    Makes a copy of NAME using xmalloc().  */
  96
  97 void
  98 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
  99 {
 100   search_dirs_type *new_dirs;
 101
 102   if (!cmdline && config.only_cmd_line_lib_dirs)
 103     return;
 104
 105   new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
 106   new_dirs->next = NULL;
 107   new_dirs->cmdline = cmdline;
 108   *search_tail_ptr = new_dirs;
 109   search_tail_ptr = &new_dirs->next;
 110
 111   /* If a directory is marked as honoring sysroot, prepend the sysroot path
 112      now.  */
 113   if (name[0] == '=')
 114     new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
 115   else if (CONST_STRNEQ (name, "$SYSROOT"))
 116     new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL);
 117   else
 118     new_dirs->name = xstrdup (name);
 119 }
 120
 121 /* Try to open a BFD for a lang_input_statement.  */
 122
 123 bfd_boolean
 124 ldfile_try_open_bfd (const char *attempt,
 125                      lang_input_statement_type *entry)
 126 {
 127   entry->the_bfd = bfd_openr (attempt, entry->target);
 128
 129   if (verbose)
 130     {
 131       if (entry->the_bfd == NULL)
 132         info_msg (_("attempt to open %s failed\n"), attempt);
 133       else
 134         info_msg (_("attempt to open %s succeeded\n"), attempt);
 135     }
 136
 137   if (entry->the_bfd == NULL)
 138     {
 139       if (bfd_get_error () == bfd_error_invalid_target)
 140         einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
 141       return FALSE;
 142     }
 143
 144   /* Linker needs to decompress sections.  */
 145   entry->the_bfd->flags |= BFD_DECOMPRESS;
 146
 147   /* This is a linker input BFD.  */
 148   entry->the_bfd->is_linker_input = 1;
 149
 150 #ifdef ENABLE_PLUGINS
 151   if (entry->flags.lto_output)
 152     entry->the_bfd->lto_output = 1;
 153 #endif
 154
 155   /* If we are searching for this file, see if the architecture is
 156      compatible with the output file.  If it isn't, keep searching.
 157      If we can't open the file as an object file, stop the search
 158      here.  If we are statically linking, ensure that we don't link
 159      a dynamic object.
 160
 161      In the code below, it's OK to exit early if the check fails,
 162      closing the checked BFD and returning FALSE, but if the BFD
 163      checks out compatible, do not exit early returning TRUE, or
 164      the plugins will not get a chance to claim the file.  */
 165
 166   if (entry->flags.search_dirs || !entry->flags.dynamic)
 167     {
 168       bfd *check;
 169
 170       if (bfd_check_format (entry->the_bfd, bfd_archive))
 171         check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
 172       else
 173         check = entry->the_bfd;
 174
 175       if (check != NULL)
 176         {
 177           if (!bfd_check_format (check, bfd_object))
 178             {
 179               if (check == entry->the_bfd
 180                   && entry->flags.search_dirs
 181                   && bfd_get_error () == bfd_error_file_not_recognized
 182                   && !ldemul_unrecognized_file (entry))
 183                 {
 184                   int token, skip = 0;
 185                   char *arg, *arg1, *arg2, *arg3;
 186                   extern FILE *yyin;
 187
 188                   /* Try to interpret the file as a linker script.  */
 189                   ldfile_open_command_file (attempt);
 190
 191                   ldfile_assumed_script = TRUE;
 192                   parser_input = input_selected;
 193                   ldlex_both ();
 194                   token = INPUT_SCRIPT;
 195                   while (token != 0)
 196                     {
 197                       switch (token)
 198                         {
 199                         case OUTPUT_FORMAT:
 200                           if ((token = yylex ()) != '(')
 201                             continue;
 202                           if ((token = yylex ()) != NAME)
 203                             continue;
 204                           arg1 = yylval.name;
 205                           arg2 = NULL;
 206                           arg3 = NULL;
 207                           token = yylex ();
 208                           if (token == ',')
 209                             {
 210                               if ((token = yylex ()) != NAME)
 211                                 {
 212                                   free (arg1);
 213                                   continue;
 214                                 }
 215                               arg2 = yylval.name;
 216                               if ((token = yylex ()) != ','
 217                                   || (token = yylex ()) != NAME)
 218                                 {
 219                                   free (arg1);
 220                                   free (arg2);
 221                                   continue;
 222                                 }
 223                               arg3 = yylval.name;
 224                               token = yylex ();
 225                             }
 226                           if (token == ')')
 227                             {
 228                               switch (command_line.endian)
 229                                 {
 230                                 default:
 231                                 case ENDIAN_UNSET:
 232                                   arg = arg1; break;
 233                                 case ENDIAN_BIG:
 234                                   arg = arg2 ? arg2 : arg1; break;
 235                                 case ENDIAN_LITTLE:
 236                                   arg = arg3 ? arg3 : arg1; break;
 237                                 }
 238                               if (strcmp (arg, lang_get_output_target ()) != 0)
 239                                 skip = 1;
 240                             }
 241                           free (arg1);
 242                           if (arg2) free (arg2);
 243                           if (arg3) free (arg3);
 244                           break;
 245                         case NAME:
 246                         case LNAME:
 247                         case VERS_IDENTIFIER:
 248                         case VERS_TAG:
 249                           free (yylval.name);
 250                           break;
 251                         case INT:
 252                           if (yylval.bigint.str)
 253                             free (yylval.bigint.str);
 254                           break;
 255                         }
 256                       token = yylex ();
 257                     }
 258                   ldlex_popstate ();
 259                   ldfile_assumed_script = FALSE;
 260                   fclose (yyin);
 261                   yyin = NULL;
 262                   if (skip)
 263                     {
 264                       if (command_line.warn_search_mismatch)
 265                         einfo (_("%P: skipping incompatible %s "
 266                                  "when searching for %s\n"),
 267                                attempt, entry->local_sym_name);
 268                       bfd_close (entry->the_bfd);
 269                       entry->the_bfd = NULL;
 270                       return FALSE;
 271                     }
 272                 }
 273               goto success;
 274             }
 275
 276           if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
 277             {
 278               einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
 279                      attempt);
 280               bfd_close (entry->the_bfd);
 281               entry->the_bfd = NULL;
 282               return FALSE;
 283             }
 284
 285           if (entry->flags.search_dirs
 286               && !bfd_arch_get_compatible (check, link_info.output_bfd,
 287                                            command_line.accept_unknown_input_arch)
 288               /* XCOFF archives can have 32 and 64 bit objects.  */
 289               && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour
 290                    && (bfd_get_flavour (link_info.output_bfd)
 291                        == bfd_target_xcoff_flavour)
 292                    && bfd_check_format (entry->the_bfd, bfd_archive)))
 293             {
 294               if (command_line.warn_search_mismatch)
 295                 einfo (_("%P: skipping incompatible %s "
 296                          "when searching for %s\n"),
 297                        attempt, entry->local_sym_name);
 298               bfd_close (entry->the_bfd);
 299               entry->the_bfd = NULL;
 300               return FALSE;
 301             }
 302         }
 303     }
 304 success:
 305 #ifdef ENABLE_PLUGINS
 306   /* If plugins are active, they get first chance to claim
 307      any successfully-opened input file.  We skip archives
 308      here; the plugin wants us to offer it the individual
 309      members when we enumerate them, not the whole file.  We
 310      also ignore corefiles, because that's just weird.  It is
 311      a needed side-effect of calling  bfd_check_format with
 312      bfd_object that it sets the bfd's arch and mach, which
 313      will be needed when and if we want to bfd_create a new
 314      one using this one as a template.  */
 315   if (link_info.lto_plugin_active
 316       && !no_more_claiming
 317       && bfd_check_format (entry->the_bfd, bfd_object))
 318     plugin_maybe_claim (entry);
 319 #endif /* ENABLE_PLUGINS */
 320
 321   /* It opened OK, the format checked out, and the plugins have had
 322      their chance to claim it, so this is success.  */
 323   return TRUE;
 324 }
 325
 326 /* Search for and open the file specified by ENTRY.  If it is an
 327    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 328
 329 bfd_boolean
 330 ldfile_open_file_search (const char *arch,
 331                          lang_input_statement_type *entry,
 332                          const char *lib,
 333                          const char *suffix)
 334 {
 335   search_dirs_type *search;
 336
 337   /* If this is not an archive, try to open it in the current
 338      directory first.  */
 339   if (!entry->flags.maybe_archive)
 340     {
 341       if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 342         {
 343           char *name = concat (ld_sysroot, entry->filename,
 344                                (const char *) NULL);
 345           if (ldfile_try_open_bfd (name, entry))
 346             {
 347               entry->filename = name;
 348               return TRUE;
 349             }
 350           free (name);
 351         }
 352       else if (ldfile_try_open_bfd (entry->filename, entry))
 353         return TRUE;
 354
 355       if (IS_ABSOLUTE_PATH (entry->filename))
 356         return FALSE;
 357     }
 358
 359   for (search = search_head; search != NULL; search = search->next)
 360     {
 361       char *string;
 362
 363       if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
 364         {
 365           if (ldemul_open_dynamic_archive (arch, search, entry))
 366             return TRUE;
 367         }
 368
 369       if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
 370         string = concat (search->name, slash, lib, entry->filename,
 371                          arch, suffix, (const char *) NULL);
 372       else
 373         string = concat (search->name, slash, entry->filename,
 374                          (const char *) 0);
 375
 376       if (ldfile_try_open_bfd (string, entry))
 377         {
 378           entry->filename = string;
 379           return TRUE;
 380         }
 381
 382       free (string);
 383     }
 384
 385   return FALSE;
 386 }
 387
 388 /* Open the input file specified by ENTRY.
 389    PR 4437: Do not stop on the first missing file, but
 390    continue processing other input files in case there
 391    are more errors to report.  */
 392
 393 void
 394 ldfile_open_file (lang_input_statement_type *entry)
 395 {
 396   if (entry->the_bfd != NULL)
 397     return;
 398
 399   if (!entry->flags.search_dirs)
 400     {
 401       if (ldfile_try_open_bfd (entry->filename, entry))
 402         return;
 403
 404       if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
 405         einfo (_("%P: cannot find %s (%s): %E\n"),
 406                entry->filename, entry->local_sym_name);
 407       else
 408         einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 409
 410       entry->flags.missing_file = TRUE;
 411       input_flags.missing_file = TRUE;
 412     }
 413   else
 414     {
 415       search_arch_type *arch;
 416       bfd_boolean found = FALSE;
 417
 418       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 419       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 420         {
 421           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 422           if (found)
 423             break;
 424 #ifdef VMS
 425           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 426           if (found)
 427             break;
 428 #endif
 429           found = ldemul_find_potential_libraries (arch->name, entry);
 430           if (found)
 431             break;
 432         }
 433
 434       /* If we have found the file, we don't need to search directories
 435          again.  */
 436       if (found)
 437         entry->flags.search_dirs = FALSE;
 438       else
 439         {
 440           if (entry->flags.sysrooted
 441                && ld_sysroot
 442                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 443             einfo (_("%P: cannot find %s inside %s\n"),
 444                    entry->local_sym_name, ld_sysroot);
 445           else
 446             einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 447           entry->flags.missing_file = TRUE;
 448           input_flags.missing_file = TRUE;
 449         }
 450     }
 451 }
 452
 453 /* Try to open NAME.  */
 454
 455 static FILE *
 456 try_open (const char *name, bfd_boolean *sysrooted)
 457 {
 458   FILE *result;
 459
 460   result = fopen (name, "r");
 461
 462   if (result != NULL)
 463     *sysrooted = is_sysrooted_pathname (name);
 464
 465   if (verbose)
 466     {
 467       if (result == NULL)
 468         info_msg (_("cannot find script file %s\n"), name);
 469       else
 470         info_msg (_("opened script file %s\n"), name);
 471     }
 472
 473   return result;
 474 }
 475
 476 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 477
 478 static bfd_boolean
 479 check_for_scripts_dir (char *dir)
 480 {
 481   char *buf;
 482   struct stat s;
 483   bfd_boolean res;
 484
 485   buf = concat (dir, "/ldscripts", (const char *) NULL);
 486   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 487   free (buf);
 488   return res;
 489 }
 490
 491 /* Return the default directory for finding script files.
 492    We look for the "ldscripts" directory in:
 493
 494    SCRIPTDIR (passed from Makefile)
 495              (adjusted according to the current location of the binary)
 496    the dir where this program is (for using it from the build tree).  */
 497
 498 static char *
 499 find_scripts_dir (void)
 500 {
 501   char *dir;
 502
 503   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 504   if (dir)
 505     {
 506       if (check_for_scripts_dir (dir))
 507         return dir;
 508       free (dir);
 509     }
 510
 511   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 512   if (dir)
 513     {
 514       if (check_for_scripts_dir (dir))
 515         return dir;
 516       free (dir);
 517     }
 518
 519   /* Look for "ldscripts" in the dir where our binary is.  */
 520   dir = make_relative_prefix (program_name, ".", ".");
 521   if (dir)
 522     {
 523       if (check_for_scripts_dir (dir))
 524         return dir;
 525       free (dir);
 526     }
 527
 528   return NULL;
 529 }
 530
 531 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
 532    it in directories specified with -L, then in the default script
 533    directory.  If DEFAULT_ONLY is true, the search is restricted to
 534    the default script location.  */
 535
 536 static FILE *
 537 ldfile_find_command_file (const char *name,
 538                           bfd_boolean default_only,
 539                           bfd_boolean *sysrooted)
 540 {
 541   search_dirs_type *search;
 542   FILE *result = NULL;
 543   char *path;
 544   static search_dirs_type *script_search;
 545
 546   if (!default_only)
 547     {
 548       /* First try raw name.  */
 549       result = try_open (name, sysrooted);
 550       if (result != NULL)
 551         return result;
 552     }
 553
 554   if (!script_search)
 555     {
 556       char *script_dir = find_scripts_dir ();
 557       if (script_dir)
 558         {
 559           search_dirs_type **save_tail_ptr = search_tail_ptr;
 560           search_tail_ptr = &script_search;
 561           ldfile_add_library_path (script_dir, TRUE);
 562           search_tail_ptr = save_tail_ptr;
 563         }
 564     }
 565
 566   /* Temporarily append script_search to the path list so that the
 567      paths specified with -L will be searched first.  */
 568   *search_tail_ptr = script_search;
 569
 570   /* Try now prefixes.  */
 571   for (search = default_only ? script_search : search_head;
 572        search != NULL;
 573        search = search->next)
 574     {
 575       path = concat (search->name, slash, name, (const char *) NULL);
 576       result = try_open (path, sysrooted);
 577       free (path);
 578       if (result)
 579         break;
 580     }
 581
 582   /* Restore the original path list.  */
 583   *search_tail_ptr = NULL;
 584
 585   return result;
 586 }
 587
 588 /* Open command file NAME.  */
 589
 590 static void
 591 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
 592 {
 593   FILE *ldlex_input_stack;
 594   bfd_boolean sysrooted;
 595
 596   ldlex_input_stack = ldfile_find_command_file (name, default_only, &sysrooted);
 597
 598   if (ldlex_input_stack == NULL)
 599     {
 600       bfd_set_error (bfd_error_system_call);
 601       einfo (_("%F%P: cannot open linker script file %s: %E\n"), name);
 602       return;
 603     }
 604
 605   lex_push_file (ldlex_input_stack, name, sysrooted);
 606
 607   lineno = 1;
 608
 609   saved_script_handle = ldlex_input_stack;
 610 }
 611
 612 /* Open command file NAME in the current directory, -L directories,
 613    the default script location, in that order.  */
 614
 615 void
 616 ldfile_open_command_file (const char *name)
 617 {
 618   ldfile_open_command_file_1 (name, FALSE);
 619 }
 620
 621 /* Open command file NAME at the default script location.  */
 622
 623 void
 624 ldfile_open_default_command_file (const char *name)
 625 {
 626   ldfile_open_command_file_1 (name, TRUE);
 627 }
 628
 629 void
 630 ldfile_add_arch (const char *in_name)
 631 {
 632   char *name = xstrdup (in_name);
 633   search_arch_type *new_arch
 634     = (search_arch_type *) xmalloc (sizeof (search_arch_type));
 635
 636   ldfile_output_machine_name = in_name;
 637
 638   new_arch->name = name;
 639   new_arch->next = NULL;
 640   while (*name)
 641     {
 642       *name = TOLOWER (*name);
 643       name++;
 644     }
 645   *search_arch_tail_ptr = new_arch;
 646   search_arch_tail_ptr = &new_arch->next;
 647
 648 }
 649
 650 /* Set the output architecture.  */
 651
 652 void
 653 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 654 {
 655   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 656
 657   if (arch)
 658     {
 659       ldfile_output_architecture = arch->arch;
 660       ldfile_output_machine = arch->mach;
 661       ldfile_output_machine_name = arch->printable_name;
 662     }
 663   else if (defarch != bfd_arch_unknown)
 664     ldfile_output_architecture = defarch;
 665   else
 666     einfo (_("%F%P: cannot represent machine `%s'\n"), string);
 667 }