ld/ldfile.c

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