ld/ldfile.c

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