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, bfd_boolean notsame)
  74 {
  75   char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
  76   int len;
  77   bfd_boolean result;
  78
  79   if (! realname)
  80     return FALSE;
  81
  82   len = strlen (realname);
  83
  84   if (((! notsame && len == ld_canon_sysroot_len)
  85        || (len >= ld_canon_sysroot_len
  86            && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
  87            && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
  88       && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
  89     result = TRUE;
  90   else
  91     result = FALSE;
  92
  93   if (realname)
  94     free (realname);
  95
  96   return result;
  97 }
  98
  99 /* Adds NAME to the library search path.
 100    Makes a copy of NAME using xmalloc().  */
 101
 102 void
 103 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
 104 {
 105   search_dirs_type *new_dirs;
 106
 107   if (!cmdline && config.only_cmd_line_lib_dirs)
 108     return;
 109
 110   new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
 111   new_dirs->next = NULL;
 112   new_dirs->cmdline = cmdline;
 113   *search_tail_ptr = new_dirs;
 114   search_tail_ptr = &new_dirs->next;
 115
 116   /* If a directory is marked as honoring sysroot, prepend the sysroot path
 117      now.  */
 118   if (name[0] == '=')
 119     {
 120       new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
 121       new_dirs->sysrooted = TRUE;
 122     }
 123   else
 124     {
 125       new_dirs->name = xstrdup (name);
 126       new_dirs->sysrooted = is_sysrooted_pathname (name, FALSE);
 127     }
 128 }
 129
 130 /* Try to open a BFD for a lang_input_statement.  */
 131
 132 bfd_boolean
 133 ldfile_try_open_bfd (const char *attempt,
 134                      lang_input_statement_type *entry)
 135 {
 136   entry->the_bfd = bfd_openr (attempt, entry->target);
 137
 138   if (trace_file_tries)
 139     {
 140       if (entry->the_bfd == NULL)
 141         info_msg (_("attempt to open %s failed\n"), attempt);
 142       else
 143         info_msg (_("attempt to open %s succeeded\n"), attempt);
 144     }
 145
 146   if (entry->the_bfd == NULL)
 147     {
 148       if (bfd_get_error () == bfd_error_invalid_target)
 149         einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
 150       return FALSE;
 151     }
 152
 153   /* Linker needs to decompress sections.  */
 154   entry->the_bfd->flags |= BFD_DECOMPRESS;
 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->search_dirs_flag || !entry->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->search_dirs_flag
 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->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->search_dirs_flag
 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) == bfd_target_xcoff_flavour
 292                     && bfd_check_format (entry->the_bfd, bfd_archive)))
 293             {
 294               if (command_line.warn_search_mismatch)
 295                 einfo (_("%P: skipping incompatible %s "
 296                          "when searching for %s\n"),
 297                        attempt, entry->local_sym_name);
 298               bfd_close (entry->the_bfd);
 299               entry->the_bfd = NULL;
 300               return FALSE;
 301             }
 302         }
 303     }
 304 success:
 305 #ifdef ENABLE_PLUGINS
 306   /* If plugins are active, they get first chance to claim
 307      any successfully-opened input file.  We skip archives
 308      here; the plugin wants us to offer it the individual
 309      members when we enumerate them, not the whole file.  We
 310      also ignore corefiles, because that's just weird.  It is
 311      a needed side-effect of calling  bfd_check_format with
 312      bfd_object that it sets the bfd's arch and mach, which
 313      will be needed when and if we want to bfd_create a new
 314      one using this one as a template.  */
 315   if (bfd_check_format (entry->the_bfd, bfd_object)
 316       && plugin_active_plugins_p ()
 317       && !no_more_claiming)
 318     {
 319       int fd = open (attempt, O_RDONLY | O_BINARY);
 320       if (fd >= 0)
 321         {
 322           struct ld_plugin_input_file file;
 323
 324           file.name = attempt;
 325           file.offset = 0;
 326           file.filesize = lseek (fd, 0, SEEK_END);
 327           file.fd = fd;
 328           plugin_maybe_claim (&file, entry);
 329         }
 330     }
 331 #endif /* ENABLE_PLUGINS */
 332
 333   /* It opened OK, the format checked out, and the plugins have had
 334      their chance to claim it, so this is success.  */
 335   return TRUE;
 336 }
 337
 338 /* Search for and open the file specified by ENTRY.  If it is an
 339    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 340
 341 bfd_boolean
 342 ldfile_open_file_search (const char *arch,
 343                          lang_input_statement_type *entry,
 344                          const char *lib,
 345                          const char *suffix)
 346 {
 347   search_dirs_type *search;
 348
 349   /* If this is not an archive, try to open it in the current
 350      directory first.  */
 351   if (! entry->maybe_archive)
 352     {
 353       if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 354         {
 355           char *name = concat (ld_sysroot, entry->filename,
 356                                (const char *) NULL);
 357           if (ldfile_try_open_bfd (name, entry))
 358             {
 359               entry->filename = name;
 360               return TRUE;
 361             }
 362           free (name);
 363         }
 364       else if (ldfile_try_open_bfd (entry->filename, entry))
 365         {
 366           entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
 367             && is_sysrooted_pathname (entry->filename, TRUE);
 368           return TRUE;
 369         }
 370
 371       if (IS_ABSOLUTE_PATH (entry->filename))
 372         return FALSE;
 373     }
 374
 375   for (search = search_head; search != NULL; search = search->next)
 376     {
 377       char *string;
 378
 379       if (entry->dynamic && ! link_info.relocatable)
 380         {
 381           if (ldemul_open_dynamic_archive (arch, search, entry))
 382             {
 383               entry->sysrooted = search->sysrooted;
 384               return TRUE;
 385             }
 386         }
 387
 388       if (entry->maybe_archive)
 389         string = concat (search->name, slash, lib, entry->filename,
 390                          arch, suffix, (const char *) NULL);
 391       else
 392         string = concat (search->name, slash, entry->filename,
 393                          (const char *) 0);
 394
 395       if (ldfile_try_open_bfd (string, entry))
 396         {
 397           entry->filename = string;
 398           entry->sysrooted = search->sysrooted;
 399           return TRUE;
 400         }
 401
 402       free (string);
 403     }
 404
 405   return FALSE;
 406 }
 407
 408 /* Open the input file specified by ENTRY.
 409    PR 4437: Do not stop on the first missing file, but
 410    continue processing other input files in case there
 411    are more errors to report.  */
 412
 413 void
 414 ldfile_open_file (lang_input_statement_type *entry)
 415 {
 416   if (entry->the_bfd != NULL)
 417     return;
 418
 419   if (! entry->search_dirs_flag)
 420     {
 421       if (ldfile_try_open_bfd (entry->filename, entry))
 422         return;
 423
 424       if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
 425         einfo (_("%P: cannot find %s (%s): %E\n"),
 426                entry->filename, entry->local_sym_name);
 427       else
 428         einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 429
 430       entry->missing_file = TRUE;
 431       missing_file = TRUE;
 432     }
 433   else
 434     {
 435       search_arch_type *arch;
 436       bfd_boolean found = FALSE;
 437
 438       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 439       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 440         {
 441           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 442           if (found)
 443             break;
 444 #ifdef VMS
 445           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 446           if (found)
 447             break;
 448 #endif
 449           found = ldemul_find_potential_libraries (arch->name, entry);
 450           if (found)
 451             break;
 452         }
 453
 454       /* If we have found the file, we don't need to search directories
 455          again.  */
 456       if (found)
 457         entry->search_dirs_flag = FALSE;
 458       else
 459         {
 460           if (entry->sysrooted
 461                && ld_sysroot
 462                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 463             einfo (_("%P: cannot find %s inside %s\n"),
 464                    entry->local_sym_name, ld_sysroot);
 465           else
 466             einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 467           entry->missing_file = TRUE;
 468           missing_file = TRUE;
 469         }
 470     }
 471 }
 472
 473 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 474
 475 static FILE *
 476 try_open (const char *name, const char *exten)
 477 {
 478   FILE *result;
 479
 480   result = fopen (name, "r");
 481
 482   if (trace_file_tries)
 483     {
 484       if (result == NULL)
 485         info_msg (_("cannot find script file %s\n"), name);
 486       else
 487         info_msg (_("opened script file %s\n"), name);
 488     }
 489
 490   if (result != NULL)
 491     return result;
 492
 493   if (*exten)
 494     {
 495       char *buff;
 496
 497       buff = concat (name, exten, (const char *) NULL);
 498       result = fopen (buff, "r");
 499
 500       if (trace_file_tries)
 501         {
 502           if (result == NULL)
 503             info_msg (_("cannot find script file %s\n"), buff);
 504           else
 505             info_msg (_("opened script file %s\n"), buff);
 506         }
 507       free (buff);
 508     }
 509
 510   return result;
 511 }
 512
 513 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 514
 515 static bfd_boolean
 516 check_for_scripts_dir (char *dir)
 517 {
 518   char *buf;
 519   struct stat s;
 520   bfd_boolean res;
 521
 522   buf = concat (dir, "/ldscripts", (const char *) NULL);
 523   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 524   free (buf);
 525   return res;
 526 }
 527
 528 /* Return the default directory for finding script files.
 529    We look for the "ldscripts" directory in:
 530
 531    SCRIPTDIR (passed from Makefile)
 532              (adjusted according to the current location of the binary)
 533    the dir where this program is (for using it from the build tree).  */
 534
 535 static char *
 536 find_scripts_dir (void)
 537 {
 538   char *dir;
 539
 540   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 541   if (dir)
 542     {
 543       if (check_for_scripts_dir (dir))
 544         return dir;
 545       free (dir);
 546     }
 547
 548   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 549   if (dir)
 550     {
 551       if (check_for_scripts_dir (dir))
 552         return dir;
 553       free (dir);
 554     }
 555
 556   /* Look for "ldscripts" in the dir where our binary is.  */
 557   dir = make_relative_prefix (program_name, ".", ".");
 558   if (dir)
 559     {
 560       if (check_for_scripts_dir (dir))
 561         return dir;
 562       free (dir);
 563     }
 564
 565   return NULL;
 566 }
 567
 568 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
 569    it in directories specified with -L, then in the default script
 570    directory, without and with EXTEND appended.  If DEFAULT_ONLY is
 571    true, the search is restricted to the default script location.  */
 572
 573 static FILE *
 574 ldfile_find_command_file (const char *name, const char *extend,
 575                           bfd_boolean default_only)
 576 {
 577   search_dirs_type *search;
 578   FILE *result = NULL;
 579   char *buffer;
 580   static search_dirs_type *script_search;
 581
 582   if (!default_only)
 583     {
 584       /* First try raw name.  */
 585       result = try_open (name, "");
 586       if (result != NULL)
 587         return result;
 588     }
 589
 590   if (!script_search)
 591     {
 592       char *script_dir = find_scripts_dir ();
 593       if (script_dir)
 594         {
 595           search_dirs_type **save_tail_ptr = search_tail_ptr;
 596           search_tail_ptr = &script_search;
 597           ldfile_add_library_path (script_dir, TRUE);
 598           search_tail_ptr = save_tail_ptr;
 599         }
 600     }
 601
 602   /* Temporarily append script_search to the path list so that the
 603      paths specified with -L will be searched first.  */
 604   *search_tail_ptr = script_search;
 605
 606   /* Try now prefixes.  */
 607   for (search = default_only ? script_search : search_head;
 608        search != NULL;
 609        search = search->next)
 610     {
 611       buffer = concat (search->name, slash, name, (const char *) NULL);
 612       result = try_open (buffer, extend);
 613       free (buffer);
 614       if (result)
 615         break;
 616     }
 617
 618   /* Restore the original path list.  */
 619   *search_tail_ptr = NULL;
 620
 621   return result;
 622 }
 623
 624 /* Open command file NAME.  */
 625
 626 static void
 627 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
 628 {
 629   FILE *ldlex_input_stack;
 630   ldlex_input_stack = ldfile_find_command_file (name, "", default_only);
 631
 632   if (ldlex_input_stack == NULL)
 633     {
 634       bfd_set_error (bfd_error_system_call);
 635       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 636     }
 637
 638   lex_push_file (ldlex_input_stack, name);
 639
 640   lineno = 1;
 641
 642   saved_script_handle = ldlex_input_stack;
 643 }
 644
 645 /* Open command file NAME in the current directory, -L directories,
 646    the default script location, in that order.  */
 647
 648 void
 649 ldfile_open_command_file (const char *name)
 650 {
 651   ldfile_open_command_file_1 (name, FALSE);
 652 }
 653
 654 /* Open command file NAME at the default script location.  */
 655
 656 void
 657 ldfile_open_default_command_file (const char *name)
 658 {
 659   ldfile_open_command_file_1 (name, TRUE);
 660 }
 661
 662 void
 663 ldfile_add_arch (const char *in_name)
 664 {
 665   char *name = xstrdup (in_name);
 666   search_arch_type *new_arch = (search_arch_type *)
 667       xmalloc (sizeof (search_arch_type));
 668
 669   ldfile_output_machine_name = in_name;
 670
 671   new_arch->name = name;
 672   new_arch->next = NULL;
 673   while (*name)
 674     {
 675       *name = TOLOWER (*name);
 676       name++;
 677     }
 678   *search_arch_tail_ptr = new_arch;
 679   search_arch_tail_ptr = &new_arch->next;
 680
 681 }
 682
 683 /* Set the output architecture.  */
 684
 685 void
 686 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 687 {
 688   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 689
 690   if (arch)
 691     {
 692       ldfile_output_architecture = arch->arch;
 693       ldfile_output_machine = arch->mach;
 694       ldfile_output_machine_name = arch->printable_name;
 695     }
 696   else if (defarch != bfd_arch_unknown)
 697     ldfile_output_architecture = defarch;
 698   else
 699     einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 700 }