contrib/binutils-2.21/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 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "safe-ctype.h"
  26 #include "ld.h"
  27 #include "ldmisc.h"
  28 #include "ldexp.h"
  29 #include "ldlang.h"
  30 #include "ldfile.h"
  31 #include "ldmain.h"
  32 #include <ldgram.h>
  33 #include "ldlex.h"
  34 #include "ldemul.h"
  35 #include "libiberty.h"
  36 #include "filenames.h"
  37 #ifdef ENABLE_PLUGINS
  38 #include "plugin-api.h"
  39 #include "plugin.h"
  40 #endif /* ENABLE_PLUGINS */
  41
  42 const char * ldfile_input_filename;
  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     {
 318       int fd = open (attempt, O_RDONLY | O_BINARY);
 319       if (fd >= 0)
 320         {
 321           struct ld_plugin_input_file file;
 322           int claimed = 0;
 323
 324           file.name = attempt;
 325           file.offset = 0;
 326           file.filesize = lseek (fd, 0, SEEK_END);
 327           file.fd = fd;
 328           /* We create a dummy BFD, initially empty, to house
 329              whatever symbols the plugin may want to add.  */
 330           file.handle = plugin_get_ir_dummy_bfd (attempt, entry->the_bfd);
 331           if (plugin_call_claim_file (&file, &claimed))
 332             einfo (_("%P%F: %s: plugin reported error claiming file\n"),
 333                    plugin_error_plugin ());
 334           /* fd belongs to us, not the plugin; but we don't need it.  */
 335           close (fd);
 336           if (claimed)
 337             {
 338               /* Discard the real file's BFD and substitute the dummy one.  */
 339               bfd_close (entry->the_bfd);
 340               entry->the_bfd = file.handle;
 341               entry->claimed = TRUE;
 342               bfd_make_readable (entry->the_bfd);
 343             }
 344           else
 345             {
 346               /* If plugin didn't claim the file, we don't need the dummy
 347                  bfd.  Can't avoid speculatively creating it, alas.  */
 348               bfd_close_all_done (file.handle);
 349               entry->claimed = FALSE;
 350             }
 351         }
 352     }
 353 #endif /* ENABLE_PLUGINS */
 354
 355   /* It opened OK, the format checked out, and the plugins have had
 356      their chance to claim it, so this is success.  */
 357   return TRUE;
 358 }
 359
 360 /* Search for and open the file specified by ENTRY.  If it is an
 361    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 362
 363 bfd_boolean
 364 ldfile_open_file_search (const char *arch,
 365                          lang_input_statement_type *entry,
 366                          const char *lib,
 367                          const char *suffix)
 368 {
 369   search_dirs_type *search;
 370
 371   /* If this is not an archive, try to open it in the current
 372      directory first.  */
 373   if (! entry->maybe_archive)
 374     {
 375       if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 376         {
 377           char *name = concat (ld_sysroot, entry->filename,
 378                                (const char *) NULL);
 379           if (ldfile_try_open_bfd (name, entry))
 380             {
 381               entry->filename = name;
 382               return TRUE;
 383             }
 384           free (name);
 385         }
 386       else if (ldfile_try_open_bfd (entry->filename, entry))
 387         {
 388           entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
 389             && is_sysrooted_pathname (entry->filename, TRUE);
 390           return TRUE;
 391         }
 392
 393       if (IS_ABSOLUTE_PATH (entry->filename))
 394         return FALSE;
 395     }
 396
 397   for (search = search_head; search != NULL; search = search->next)
 398     {
 399       char *string;
 400
 401       if (entry->dynamic && ! link_info.relocatable)
 402         {
 403           if (ldemul_open_dynamic_archive (arch, search, entry))
 404             {
 405               entry->sysrooted = search->sysrooted;
 406               return TRUE;
 407             }
 408         }
 409
 410       if (entry->maybe_archive)
 411         string = concat (search->name, slash, lib, entry->filename,
 412                          arch, suffix, (const char *) NULL);
 413       else
 414         string = concat (search->name, slash, entry->filename,
 415                          (const char *) 0);
 416
 417       if (ldfile_try_open_bfd (string, entry))
 418         {
 419           entry->filename = string;
 420           entry->sysrooted = search->sysrooted;
 421           return TRUE;
 422         }
 423
 424       free (string);
 425     }
 426
 427   return FALSE;
 428 }
 429
 430 /* Open the input file specified by ENTRY.
 431    PR 4437: Do not stop on the first missing file, but
 432    continue processing other input files in case there
 433    are more errors to report.  */
 434
 435 void
 436 ldfile_open_file (lang_input_statement_type *entry)
 437 {
 438   if (entry->the_bfd != NULL)
 439     return;
 440
 441   if (! entry->search_dirs_flag)
 442     {
 443       if (ldfile_try_open_bfd (entry->filename, entry))
 444         return;
 445
 446       if (strcmp (entry->filename, entry->local_sym_name) != 0)
 447         einfo (_("%P: cannot find %s (%s): %E\n"),
 448                entry->filename, entry->local_sym_name);
 449       else
 450         einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 451
 452       entry->missing_file = TRUE;
 453       missing_file = TRUE;
 454     }
 455   else
 456     {
 457       search_arch_type *arch;
 458       bfd_boolean found = FALSE;
 459
 460       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 461       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 462         {
 463           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 464           if (found)
 465             break;
 466 #ifdef VMS
 467           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 468           if (found)
 469             break;
 470 #endif
 471           found = ldemul_find_potential_libraries (arch->name, entry);
 472           if (found)
 473             break;
 474         }
 475
 476       /* If we have found the file, we don't need to search directories
 477          again.  */
 478       if (found)
 479         entry->search_dirs_flag = FALSE;
 480       else
 481         {
 482           if (entry->sysrooted
 483                && ld_sysroot
 484                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 485             einfo (_("%P: cannot find %s inside %s\n"),
 486                    entry->local_sym_name, ld_sysroot);
 487           else
 488             einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 489           entry->missing_file = TRUE;
 490           missing_file = TRUE;
 491         }
 492     }
 493 }
 494
 495 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 496
 497 static FILE *
 498 try_open (const char *name, const char *exten)
 499 {
 500   FILE *result;
 501
 502   result = fopen (name, "r");
 503
 504   if (trace_file_tries)
 505     {
 506       if (result == NULL)
 507         info_msg (_("cannot find script file %s\n"), name);
 508       else
 509         info_msg (_("opened script file %s\n"), name);
 510     }
 511
 512   if (result != NULL)
 513     return result;
 514
 515   if (*exten)
 516     {
 517       char *buff;
 518
 519       buff = concat (name, exten, (const char *) NULL);
 520       result = fopen (buff, "r");
 521
 522       if (trace_file_tries)
 523         {
 524           if (result == NULL)
 525             info_msg (_("cannot find script file %s\n"), buff);
 526           else
 527             info_msg (_("opened script file %s\n"), buff);
 528         }
 529       free (buff);
 530     }
 531
 532   return result;
 533 }
 534
 535 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 536
 537 static bfd_boolean
 538 check_for_scripts_dir (char *dir)
 539 {
 540   char *buf;
 541   struct stat s;
 542   bfd_boolean res;
 543
 544   buf = concat (dir, "/ldscripts", (const char *) NULL);
 545   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 546   free (buf);
 547   return res;
 548 }
 549
 550 /* Return the default directory for finding script files.
 551    We look for the "ldscripts" directory in:
 552
 553    SCRIPTDIR (passed from Makefile)
 554              (adjusted according to the current location of the binary)
 555    the dir where this program is (for using it from the build tree).  */
 556
 557 static char *
 558 find_scripts_dir (void)
 559 {
 560   char *dir;
 561
 562   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 563   if (dir)
 564     {
 565       if (check_for_scripts_dir (dir))
 566         return dir;
 567       free (dir);
 568     }
 569
 570   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 571   if (dir)
 572     {
 573       if (check_for_scripts_dir (dir))
 574         return dir;
 575       free (dir);
 576     }
 577
 578   /* Look for "ldscripts" in the dir where our binary is.  */
 579   dir = make_relative_prefix (program_name, ".", ".");
 580   if (dir)
 581     {
 582       if (check_for_scripts_dir (dir))
 583         return dir;
 584       free (dir);
 585     }
 586
 587   return NULL;
 588 }
 589
 590 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
 591    it in directories specified with -L, then in the default script
 592    directory, without and with EXTEND appended.  If DEFAULT_ONLY is
 593    true, the search is restricted to the default script location.  */
 594
 595 static FILE *
 596 ldfile_find_command_file (const char *name, const char *extend,
 597                           bfd_boolean default_only)
 598 {
 599   search_dirs_type *search;
 600   FILE *result = NULL;
 601   char *buffer;
 602   static search_dirs_type *script_search;
 603
 604   if (!default_only)
 605     {
 606       /* First try raw name.  */
 607       result = try_open (name, "");
 608       if (result != NULL)
 609         return result;
 610     }
 611
 612   if (!script_search)
 613     {
 614       char *script_dir = find_scripts_dir ();
 615       if (script_dir)
 616         {
 617           search_dirs_type **save_tail_ptr = search_tail_ptr;
 618           search_tail_ptr = &script_search;
 619           ldfile_add_library_path (script_dir, TRUE);
 620           search_tail_ptr = save_tail_ptr;
 621         }
 622     }
 623
 624   /* Temporarily append script_search to the path list so that the
 625      paths specified with -L will be searched first.  */
 626   *search_tail_ptr = script_search;
 627
 628   /* Try now prefixes.  */
 629   for (search = default_only ? script_search : search_head;
 630        search != NULL;
 631        search = search->next)
 632     {
 633       buffer = concat (search->name, slash, name, (const char *) NULL);
 634       result = try_open (buffer, extend);
 635       free (buffer);
 636       if (result)
 637         break;
 638     }
 639
 640   /* Restore the original path list.  */
 641   *search_tail_ptr = NULL;
 642
 643   return result;
 644 }
 645
 646 /* Open command file NAME.  */
 647
 648 static void
 649 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
 650 {
 651   FILE *ldlex_input_stack;
 652   ldlex_input_stack = ldfile_find_command_file (name, "", default_only);
 653
 654   if (ldlex_input_stack == NULL)
 655     {
 656       bfd_set_error (bfd_error_system_call);
 657       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 658     }
 659
 660   lex_push_file (ldlex_input_stack, name);
 661
 662   ldfile_input_filename = name;
 663   lineno = 1;
 664
 665   saved_script_handle = ldlex_input_stack;
 666 }
 667
 668 /* Open command file NAME in the current directory, -L directories,
 669    the default script location, in that order.  */
 670
 671 void
 672 ldfile_open_command_file (const char *name)
 673 {
 674   ldfile_open_command_file_1 (name, FALSE);
 675 }
 676
 677 /* Open command file NAME at the default script location.  */
 678
 679 void
 680 ldfile_open_default_command_file (const char *name)
 681 {
 682   ldfile_open_command_file_1 (name, TRUE);
 683 }
 684
 685 void
 686 ldfile_add_arch (const char *in_name)
 687 {
 688   char *name = xstrdup (in_name);
 689   search_arch_type *new_arch = (search_arch_type *)
 690       xmalloc (sizeof (search_arch_type));
 691
 692   ldfile_output_machine_name = in_name;
 693
 694   new_arch->name = name;
 695   new_arch->next = NULL;
 696   while (*name)
 697     {
 698       *name = TOLOWER (*name);
 699       name++;
 700     }
 701   *search_arch_tail_ptr = new_arch;
 702   search_arch_tail_ptr = &new_arch->next;
 703
 704 }
 705
 706 /* Set the output architecture.  */
 707
 708 void
 709 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 710 {
 711   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 712
 713   if (arch)
 714     {
 715       ldfile_output_architecture = arch->arch;
 716       ldfile_output_machine = arch->mach;
 717       ldfile_output_machine_name = arch->printable_name;
 718     }
 719   else if (defarch != bfd_arch_unknown)
 720     ldfile_output_architecture = defarch;
 721   else
 722     einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 723 }