ld/ldfile.c

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