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 #ifdef ENABLE_PLUGINS
  38 #include "plugin-api.h"
  39 #include "plugin.h"
  40 #endif /* ENABLE_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   /* Linker needs to decompress sections.  */
 146   entry->the_bfd->flags |= BFD_DECOMPRESS;
 147
 148   /* This is a linker input BFD.  */
 149   entry->the_bfd->is_linker_input = 1;
 150
 151 #ifdef ENABLE_PLUGINS
 152   if (entry->flags.lto_output)
 153     entry->the_bfd->lto_output = 1;
 154 #endif
 155
 156   /* If we are searching for this file, see if the architecture is
 157      compatible with the output file.  If it isn't, keep searching.
 158      If we can't open the file as an object file, stop the search
 159      here.  If we are statically linking, ensure that we don't link
 160      a dynamic object.
 161
 162      In the code below, it's OK to exit early if the check fails,
 163      closing the checked BFD and returning FALSE, but if the BFD
 164      checks out compatible, do not exit early returning TRUE, or
 165      the plugins will not get a chance to claim the file.  */
 166
 167   if (entry->flags.search_dirs || !entry->flags.dynamic)
 168     {
 169       bfd *check;
 170
 171       if (bfd_check_format (entry->the_bfd, bfd_archive))
 172         check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
 173       else
 174         check = entry->the_bfd;
 175
 176       if (check != NULL)
 177         {
 178           if (!bfd_check_format (check, bfd_object))
 179             {
 180               if (check == entry->the_bfd
 181                   && entry->flags.search_dirs
 182                   && bfd_get_error () == bfd_error_file_not_recognized
 183                   && !ldemul_unrecognized_file (entry))
 184                 {
 185                   int token, skip = 0;
 186                   char *arg, *arg1, *arg2, *arg3;
 187                   extern FILE *yyin;
 188
 189                   /* Try to interpret the file as a linker script.  */
 190                   ldfile_open_command_file (attempt);
 191
 192                   ldfile_assumed_script = TRUE;
 193                   parser_input = input_selected;
 194                   ldlex_both ();
 195                   token = INPUT_SCRIPT;
 196                   while (token != 0)
 197                     {
 198                       switch (token)
 199                         {
 200                         case OUTPUT_FORMAT:
 201                           if ((token = yylex ()) != '(')
 202                             continue;
 203                           if ((token = yylex ()) != NAME)
 204                             continue;
 205                           arg1 = yylval.name;
 206                           arg2 = NULL;
 207                           arg3 = NULL;
 208                           token = yylex ();
 209                           if (token == ',')
 210                             {
 211                               if ((token = yylex ()) != NAME)
 212                                 {
 213                                   free (arg1);
 214                                   continue;
 215                                 }
 216                               arg2 = yylval.name;
 217                               if ((token = yylex ()) != ','
 218                                   || (token = yylex ()) != NAME)
 219                                 {
 220                                   free (arg1);
 221                                   free (arg2);
 222                                   continue;
 223                                 }
 224                               arg3 = yylval.name;
 225                               token = yylex ();
 226                             }
 227                           if (token == ')')
 228                             {
 229                               switch (command_line.endian)
 230                                 {
 231                                 default:
 232                                 case ENDIAN_UNSET:
 233                                   arg = arg1; break;
 234                                 case ENDIAN_BIG:
 235                                   arg = arg2 ? arg2 : arg1; break;
 236                                 case ENDIAN_LITTLE:
 237                                   arg = arg3 ? arg3 : arg1; break;
 238                                 }
 239                               if (strcmp (arg, lang_get_output_target ()) != 0)
 240                                 skip = 1;
 241                             }
 242                           free (arg1);
 243                           if (arg2) free (arg2);
 244                           if (arg3) free (arg3);
 245                           break;
 246                         case NAME:
 247                         case LNAME:
 248                         case VERS_IDENTIFIER:
 249                         case VERS_TAG:
 250                           free (yylval.name);
 251                           break;
 252                         case INT:
 253                           if (yylval.bigint.str)
 254                             free (yylval.bigint.str);
 255                           break;
 256                         }
 257                       token = yylex ();
 258                     }
 259                   ldlex_popstate ();
 260                   ldfile_assumed_script = FALSE;
 261                   fclose (yyin);
 262                   yyin = NULL;
 263                   if (skip)
 264                     {
 265                       if (command_line.warn_search_mismatch)
 266                         einfo (_("%P: skipping incompatible %s "
 267                                  "when searching for %s\n"),
 268                                attempt, entry->local_sym_name);
 269                       bfd_close (entry->the_bfd);
 270                       entry->the_bfd = NULL;
 271                       return FALSE;
 272                     }
 273                 }
 274               goto success;
 275             }
 276
 277           if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
 278             {
 279               einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
 280                      attempt);
 281               bfd_close (entry->the_bfd);
 282               entry->the_bfd = NULL;
 283               return FALSE;
 284             }
 285
 286           if (entry->flags.search_dirs
 287               && !bfd_arch_get_compatible (check, link_info.output_bfd,
 288                                            command_line.accept_unknown_input_arch)
 289               /* XCOFF archives can have 32 and 64 bit objects.  */
 290               && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour
 291                    && (bfd_get_flavour (link_info.output_bfd)
 292                        == bfd_target_xcoff_flavour)
 293                    && bfd_check_format (entry->the_bfd, bfd_archive)))
 294             {
 295               if (command_line.warn_search_mismatch)
 296                 einfo (_("%P: skipping incompatible %s "
 297                          "when searching for %s\n"),
 298                        attempt, entry->local_sym_name);
 299               bfd_close (entry->the_bfd);
 300               entry->the_bfd = NULL;
 301               return FALSE;
 302             }
 303         }
 304     }
 305 success:
 306 #ifdef ENABLE_PLUGINS
 307   /* If plugins are active, they get first chance to claim
 308      any successfully-opened input file.  We skip archives
 309      here; the plugin wants us to offer it the individual
 310      members when we enumerate them, not the whole file.  We
 311      also ignore corefiles, because that's just weird.  It is
 312      a needed side-effect of calling  bfd_check_format with
 313      bfd_object that it sets the bfd's arch and mach, which
 314      will be needed when and if we want to bfd_create a new
 315      one using this one as a template.  */
 316   if (link_info.lto_plugin_active
 317       && !no_more_claiming
 318       && bfd_check_format (entry->the_bfd, bfd_object))
 319     plugin_maybe_claim (entry);
 320 #endif /* ENABLE_PLUGINS */
 321
 322   /* It opened OK, the format checked out, and the plugins have had
 323      their chance to claim it, so this is success.  */
 324   return TRUE;
 325 }
 326
 327 /* Search for and open the file specified by ENTRY.  If it is an
 328    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 329
 330 bfd_boolean
 331 ldfile_open_file_search (const char *arch,
 332                          lang_input_statement_type *entry,
 333                          const char *lib,
 334                          const char *suffix)
 335 {
 336   search_dirs_type *search;
 337
 338   /* If this is not an archive, try to open it in the current
 339      directory first.  */
 340   if (!entry->flags.maybe_archive)
 341     {
 342       if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 343         {
 344           char *name = concat (ld_sysroot, entry->filename,
 345                                (const char *) NULL);
 346           if (ldfile_try_open_bfd (name, entry))
 347             {
 348               entry->filename = name;
 349               return TRUE;
 350             }
 351           free (name);
 352         }
 353       else if (ldfile_try_open_bfd (entry->filename, entry))
 354         return TRUE;
 355
 356       if (IS_ABSOLUTE_PATH (entry->filename))
 357         return FALSE;
 358     }
 359
 360   for (search = search_head; search != NULL; search = search->next)
 361     {
 362       char *string;
 363
 364       if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
 365         {
 366           if (ldemul_open_dynamic_archive (arch, search, entry))
 367             return TRUE;
 368         }
 369
 370       if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
 371         string = concat (search->name, slash, lib, entry->filename,
 372                          arch, suffix, (const char *) NULL);
 373       else
 374         string = concat (search->name, slash, entry->filename,
 375                          (const char *) 0);
 376
 377       if (ldfile_try_open_bfd (string, entry))
 378         {
 379           entry->filename = string;
 380           return TRUE;
 381         }
 382
 383       free (string);
 384     }
 385
 386   return FALSE;
 387 }
 388
 389 /* Open the input file specified by ENTRY.
 390    PR 4437: Do not stop on the first missing file, but
 391    continue processing other input files in case there
 392    are more errors to report.  */
 393
 394 void
 395 ldfile_open_file (lang_input_statement_type *entry)
 396 {
 397   if (entry->the_bfd != NULL)
 398     return;
 399
 400   if (!entry->flags.search_dirs)
 401     {
 402       if (ldfile_try_open_bfd (entry->filename, entry))
 403         return;
 404
 405       if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
 406         einfo (_("%P: cannot find %s (%s): %E\n"),
 407                entry->filename, entry->local_sym_name);
 408       else
 409         einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 410
 411       entry->flags.missing_file = TRUE;
 412       input_flags.missing_file = TRUE;
 413     }
 414   else
 415     {
 416       search_arch_type *arch;
 417       bfd_boolean found = FALSE;
 418
 419       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 420       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 421         {
 422           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 423           if (found)
 424             break;
 425 #ifdef VMS
 426           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 427           if (found)
 428             break;
 429 #endif
 430           found = ldemul_find_potential_libraries (arch->name, entry);
 431           if (found)
 432             break;
 433         }
 434
 435       /* If we have found the file, we don't need to search directories
 436          again.  */
 437       if (found)
 438         entry->flags.search_dirs = FALSE;
 439       else
 440         {
 441           if (entry->flags.sysrooted
 442                && ld_sysroot
 443                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 444             einfo (_("%P: cannot find %s inside %s\n"),
 445                    entry->local_sym_name, ld_sysroot);
 446           else
 447             einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 448           entry->flags.missing_file = TRUE;
 449           input_flags.missing_file = TRUE;
 450         }
 451     }
 452 }
 453
 454 /* Try to open NAME.  */
 455
 456 static FILE *
 457 try_open (const char *name, bfd_boolean *sysrooted)
 458 {
 459   FILE *result;
 460
 461   result = fopen (name, "r");
 462
 463   if (result != NULL)
 464     *sysrooted = is_sysrooted_pathname (name);
 465
 466   if (verbose)
 467     {
 468       if (result == NULL)
 469         info_msg (_("cannot find script file %s\n"), name);
 470       else
 471         info_msg (_("opened script file %s\n"), name);
 472     }
 473
 474   return result;
 475 }
 476
 477 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 478
 479 static bfd_boolean
 480 check_for_scripts_dir (char *dir)
 481 {
 482   char *buf;
 483   struct stat s;
 484   bfd_boolean res;
 485
 486   buf = concat (dir, "/ldscripts", (const char *) NULL);
 487   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 488   free (buf);
 489   return res;
 490 }
 491
 492 /* Return the default directory for finding script files.
 493    We look for the "ldscripts" directory in:
 494
 495    SCRIPTDIR (passed from Makefile)
 496              (adjusted according to the current location of the binary)
 497    the dir where this program is (for using it from the build tree).  */
 498
 499 static char *
 500 find_scripts_dir (void)
 501 {
 502   char *dir;
 503
 504   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 505   if (dir)
 506     {
 507       if (check_for_scripts_dir (dir))
 508         return dir;
 509       free (dir);
 510     }
 511
 512   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 513   if (dir)
 514     {
 515       if (check_for_scripts_dir (dir))
 516         return dir;
 517       free (dir);
 518     }
 519
 520   /* Look for "ldscripts" in the dir where our binary is.  */
 521   dir = make_relative_prefix (program_name, ".", ".");
 522   if (dir)
 523     {
 524       if (check_for_scripts_dir (dir))
 525         return dir;
 526       free (dir);
 527     }
 528
 529   return NULL;
 530 }
 531
 532 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
 533    it in directories specified with -L, then in the default script
 534    directory.  If DEFAULT_ONLY is true, the search is restricted to
 535    the default script location.  */
 536
 537 static FILE *
 538 ldfile_find_command_file (const char *name,
 539                           bfd_boolean default_only,
 540                           bfd_boolean *sysrooted)
 541 {
 542   search_dirs_type *search;
 543   FILE *result = NULL;
 544   char *path;
 545   static search_dirs_type *script_search;
 546
 547   if (!default_only)
 548     {
 549       /* First try raw name.  */
 550       result = try_open (name, sysrooted);
 551       if (result != NULL)
 552         return result;
 553     }
 554
 555   if (!script_search)
 556     {
 557       char *script_dir = find_scripts_dir ();
 558       if (script_dir)
 559         {
 560           search_dirs_type **save_tail_ptr = search_tail_ptr;
 561           search_tail_ptr = &script_search;
 562           ldfile_add_library_path (script_dir, TRUE);
 563           search_tail_ptr = save_tail_ptr;
 564         }
 565     }
 566
 567   /* Temporarily append script_search to the path list so that the
 568      paths specified with -L will be searched first.  */
 569   *search_tail_ptr = script_search;
 570
 571   /* Try now prefixes.  */
 572   for (search = default_only ? script_search : search_head;
 573        search != NULL;
 574        search = search->next)
 575     {
 576       path = concat (search->name, slash, name, (const char *) NULL);
 577       result = try_open (path, sysrooted);
 578       free (path);
 579       if (result)
 580         break;
 581     }
 582
 583   /* Restore the original path list.  */
 584   *search_tail_ptr = NULL;
 585
 586   return result;
 587 }
 588
 589 enum script_open_style {
 590   script_nonT,
 591   script_T,
 592   script_defaultT
 593 };
 594
 595 struct script_name_list
 596 {
 597   struct script_name_list *next;
 598   enum script_open_style open_how;
 599   char name[1];
 600 };
 601
 602 /* Open command file NAME.  */
 603
 604 static void
 605 ldfile_open_command_file_1 (const char *name, enum script_open_style open_how)
 606 {
 607   FILE *ldlex_input_stack;
 608   bfd_boolean sysrooted;
 609   static struct script_name_list *processed_scripts = NULL;
 610   struct script_name_list *script;
 611   size_t len;
 612
 613   /* PR 24576: Catch the case where the user has accidentally included
 614      the same linker script twice.  */
 615   for (script = processed_scripts; script != NULL; script = script->next)
 616     {
 617       if ((open_how != script_nonT || script->open_how != script_nonT)
 618           && strcmp (name, script->name) == 0)
 619         {
 620           einfo (_("%F%P: error: linker script file '%s'"
 621                    " appears multiple times\n"), name);
 622           return;
 623         }
 624     }
 625
 626   /* FIXME: This memory is never freed, but that should not really matter.
 627      It will be released when the linker exits, and it is unlikely to ever
 628      be more than a few tens of bytes.  */
 629   len = strlen (name);
 630   script = xmalloc (sizeof (*script) + len);
 631   script->next = processed_scripts;
 632   script->open_how = open_how;
 633   memcpy (script->name, name, len + 1);
 634   processed_scripts = script;
 635
 636   ldlex_input_stack = ldfile_find_command_file (name,
 637                                                 open_how == script_defaultT,
 638                                                 &sysrooted);
 639   if (ldlex_input_stack == NULL)
 640     {
 641       bfd_set_error (bfd_error_system_call);
 642       einfo (_("%F%P: cannot open linker script file %s: %E\n"), name);
 643       return;
 644     }
 645
 646   lex_push_file (ldlex_input_stack, name, sysrooted);
 647
 648   lineno = 1;
 649
 650   saved_script_handle = ldlex_input_stack;
 651 }
 652
 653 /* Open command file NAME in the current directory, -L directories,
 654    the default script location, in that order.  */
 655
 656 void
 657 ldfile_open_command_file (const char *name)
 658 {
 659   ldfile_open_command_file_1 (name, script_nonT);
 660 }
 661
 662 void
 663 ldfile_open_script_file (const char *name)
 664 {
 665   ldfile_open_command_file_1 (name, script_T);
 666 }
 667
 668 /* Open command file NAME at the default script location.  */
 669
 670 void
 671 ldfile_open_default_command_file (const char *name)
 672 {
 673   ldfile_open_command_file_1 (name, script_defaultT);
 674 }
 675
 676 void
 677 ldfile_add_arch (const char *in_name)
 678 {
 679   char *name = xstrdup (in_name);
 680   search_arch_type *new_arch
 681     = (search_arch_type *) xmalloc (sizeof (search_arch_type));
 682
 683   ldfile_output_machine_name = in_name;
 684
 685   new_arch->name = name;
 686   new_arch->next = NULL;
 687   while (*name)
 688     {
 689       *name = TOLOWER (*name);
 690       name++;
 691     }
 692   *search_arch_tail_ptr = new_arch;
 693   search_arch_tail_ptr = &new_arch->next;
 694
 695 }
 696
 697 /* Set the output architecture.  */
 698
 699 void
 700 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 701 {
 702   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 703
 704   if (arch)
 705     {
 706       ldfile_output_architecture = arch->arch;
 707       ldfile_output_machine = arch->mach;
 708       ldfile_output_machine_name = arch->printable_name;
 709     }
 710   else if (defarch != bfd_arch_unknown)
 711     ldfile_output_architecture = defarch;
 712   else
 713     einfo (_("%F%P: cannot represent machine `%s'\n"), string);
 714 }