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   /* If we are searching for this file, see if the architecture is
 154      compatible with the output file.  If it isn't, keep searching.
 155      If we can't open the file as an object file, stop the search
 156      here.  If we are statically linking, ensure that we don't link
 157      a dynamic object.
 158
 159      In the code below, it's OK to exit early if the check fails,
 160      closing the checked BFD and returning FALSE, but if the BFD
 161      checks out compatible, do not exit early returning TRUE, or
 162      the plugins will not get a chance to claim the file.  */
 163
 164   if (entry->search_dirs_flag || !entry->dynamic)
 165     {
 166       bfd *check;
 167
 168       if (bfd_check_format (entry->the_bfd, bfd_archive))
 169         check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
 170       else
 171         check = entry->the_bfd;
 172
 173       if (check != NULL)
 174         {
 175           if (! bfd_check_format (check, bfd_object))
 176             {
 177               if (check == entry->the_bfd
 178                   && entry->search_dirs_flag
 179                   && bfd_get_error () == bfd_error_file_not_recognized
 180                   && ! ldemul_unrecognized_file (entry))
 181                 {
 182                   int token, skip = 0;
 183                   char *arg, *arg1, *arg2, *arg3;
 184                   extern FILE *yyin;
 185
 186                   /* Try to interpret the file as a linker script.  */
 187                   ldfile_open_command_file (attempt);
 188
 189                   ldfile_assumed_script = TRUE;
 190                   parser_input = input_selected;
 191                   ldlex_both ();
 192                   token = INPUT_SCRIPT;
 193                   while (token != 0)
 194                     {
 195                       switch (token)
 196                         {
 197                         case OUTPUT_FORMAT:
 198                           if ((token = yylex ()) != '(')
 199                             continue;
 200                           if ((token = yylex ()) != NAME)
 201                             continue;
 202                           arg1 = yylval.name;
 203                           arg2 = NULL;
 204                           arg3 = NULL;
 205                           token = yylex ();
 206                           if (token == ',')
 207                             {
 208                               if ((token = yylex ()) != NAME)
 209                                 {
 210                                   free (arg1);
 211                                   continue;
 212                                 }
 213                               arg2 = yylval.name;
 214                               if ((token = yylex ()) != ','
 215                                   || (token = yylex ()) != NAME)
 216                                 {
 217                                   free (arg1);
 218                                   free (arg2);
 219                                   continue;
 220                                 }
 221                               arg3 = yylval.name;
 222                               token = yylex ();
 223                             }
 224                           if (token == ')')
 225                             {
 226                               switch (command_line.endian)
 227                                 {
 228                                 default:
 229                                 case ENDIAN_UNSET:
 230                                   arg = arg1; break;
 231                                 case ENDIAN_BIG:
 232                                   arg = arg2 ? arg2 : arg1; break;
 233                                 case ENDIAN_LITTLE:
 234                                   arg = arg3 ? arg3 : arg1; break;
 235                                 }
 236                               if (strcmp (arg, lang_get_output_target ()) != 0)
 237                                 skip = 1;
 238                             }
 239                           free (arg1);
 240                           if (arg2) free (arg2);
 241                           if (arg3) free (arg3);
 242                           break;
 243                         case NAME:
 244                         case LNAME:
 245                         case VERS_IDENTIFIER:
 246                         case VERS_TAG:
 247                           free (yylval.name);
 248                           break;
 249                         case INT:
 250                           if (yylval.bigint.str)
 251                             free (yylval.bigint.str);
 252                           break;
 253                         }
 254                       token = yylex ();
 255                     }
 256                   ldlex_popstate ();
 257                   ldfile_assumed_script = FALSE;
 258                   fclose (yyin);
 259                   yyin = NULL;
 260                   if (skip)
 261                     {
 262                       if (command_line.warn_search_mismatch)
 263                         einfo (_("%P: skipping incompatible %s "
 264                                  "when searching for %s\n"),
 265                                attempt, entry->local_sym_name);
 266                       bfd_close (entry->the_bfd);
 267                       entry->the_bfd = NULL;
 268                       return FALSE;
 269                     }
 270                 }
 271               goto success;
 272             }
 273
 274           if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
 275             {
 276               einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
 277                      attempt);
 278               bfd_close (entry->the_bfd);
 279               entry->the_bfd = NULL;
 280               return FALSE;
 281             }
 282
 283           if (entry->search_dirs_flag
 284               && !bfd_arch_get_compatible (check, link_info.output_bfd,
 285                                            command_line.accept_unknown_input_arch)
 286               /* XCOFF archives can have 32 and 64 bit objects.  */
 287               && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
 288                     && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
 289                     && bfd_check_format (entry->the_bfd, bfd_archive)))
 290             {
 291               if (command_line.warn_search_mismatch)
 292                 einfo (_("%P: skipping incompatible %s "
 293                          "when searching for %s\n"),
 294                        attempt, entry->local_sym_name);
 295               bfd_close (entry->the_bfd);
 296               entry->the_bfd = NULL;
 297               return FALSE;
 298             }
 299         }
 300     }
 301 success:
 302 #ifdef ENABLE_PLUGINS
 303   /* If plugins are active, they get first chance to claim
 304      any successfully-opened input file.  We skip archives
 305      here; the plugin wants us to offer it the individual
 306      members when we enumerate them, not the whole file.  We
 307      also ignore corefiles, because that's just weird.  It is
 308      a needed side-effect of calling  bfd_check_format with
 309      bfd_object that it sets the bfd's arch and mach, which
 310      will be needed when and if we want to bfd_create a new
 311      one using this one as a template.  */
 312   if (bfd_check_format (entry->the_bfd, bfd_object))
 313     {
 314       int fd = open (attempt, O_RDONLY | O_BINARY);
 315       if (fd >= 0)
 316         {
 317           struct ld_plugin_input_file file;
 318           int claimed = 0;
 319
 320           file.name = attempt;
 321           file.offset = 0;
 322           file.filesize = lseek (fd, 0, SEEK_END);
 323           file.fd = fd;
 324           /* We create a dummy BFD, initially empty, to house
 325              whatever symbols the plugin may want to add.  */
 326           file.handle = plugin_get_ir_dummy_bfd (attempt, entry->the_bfd);
 327           if (plugin_call_claim_file (&file, &claimed))
 328             einfo (_("%P%F: %s: plugin reported error claiming file\n"),
 329               plugin_error_plugin ());
 330           if (claimed)
 331             {
 332               /* Discard the real file's BFD and substitute the dummy one.  */
 333               bfd_close (entry->the_bfd);
 334               entry->the_bfd = file.handle;
 335               entry->claimed = TRUE;
 336               bfd_make_readable (entry->the_bfd);
 337             }
 338           else
 339             {
 340               /* If plugin didn't claim the file, we don't need the fd or the
 341                  dummy bfd.  Can't avoid speculatively creating it, alas.  */
 342               bfd_close_all_done (file.handle);
 343               close (fd);
 344               entry->claimed = FALSE;
 345             }
 346         }
 347     }
 348 #endif /* ENABLE_PLUGINS */
 349
 350   /* It opened OK, the format checked out, and the plugins have had
 351      their chance to claim it, so this is success.  */
 352   return TRUE;
 353 }
 354
 355 /* Search for and open the file specified by ENTRY.  If it is an
 356    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 357
 358 bfd_boolean
 359 ldfile_open_file_search (const char *arch,
 360                          lang_input_statement_type *entry,
 361                          const char *lib,
 362                          const char *suffix)
 363 {
 364   search_dirs_type *search;
 365
 366   /* If this is not an archive, try to open it in the current
 367      directory first.  */
 368   if (! entry->is_archive)
 369     {
 370       if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 371         {
 372           char *name = concat (ld_sysroot, entry->filename,
 373                                (const char *) NULL);
 374           if (ldfile_try_open_bfd (name, entry))
 375             {
 376               entry->filename = name;
 377               return TRUE;
 378             }
 379           free (name);
 380         }
 381       else if (ldfile_try_open_bfd (entry->filename, entry))
 382         {
 383           entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
 384             && is_sysrooted_pathname (entry->filename, TRUE);
 385           return TRUE;
 386         }
 387
 388       if (IS_ABSOLUTE_PATH (entry->filename))
 389         return FALSE;
 390     }
 391
 392   for (search = search_head; search != NULL; search = search->next)
 393     {
 394       char *string;
 395
 396       if (entry->dynamic && ! link_info.relocatable)
 397         {
 398           if (ldemul_open_dynamic_archive (arch, search, entry))
 399             {
 400               entry->sysrooted = search->sysrooted;
 401               return TRUE;
 402             }
 403         }
 404
 405       if (entry->is_archive)
 406         string = concat (search->name, slash, lib, entry->filename,
 407                          arch, suffix, (const char *) NULL);
 408       else
 409         string = concat (search->name, slash, entry->filename,
 410                          (const char *) 0);
 411
 412       if (ldfile_try_open_bfd (string, entry))
 413         {
 414           entry->filename = string;
 415           entry->sysrooted = search->sysrooted;
 416           return TRUE;
 417         }
 418
 419       free (string);
 420     }
 421
 422   return FALSE;
 423 }
 424
 425 /* Open the input file specified by ENTRY.
 426    PR 4437: Do not stop on the first missing file, but
 427    continue processing other input files in case there
 428    are more errors to report.  */
 429
 430 void
 431 ldfile_open_file (lang_input_statement_type *entry)
 432 {
 433   if (entry->the_bfd != NULL)
 434     return;
 435
 436   if (! entry->search_dirs_flag)
 437     {
 438       if (ldfile_try_open_bfd (entry->filename, entry))
 439         return;
 440
 441       if (strcmp (entry->filename, entry->local_sym_name) != 0)
 442         einfo (_("%P: cannot find %s (%s): %E\n"),
 443                entry->filename, entry->local_sym_name);
 444       else
 445         einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 446
 447       entry->missing_file = TRUE;
 448       missing_file = TRUE;
 449     }
 450   else
 451     {
 452       search_arch_type *arch;
 453       bfd_boolean found = FALSE;
 454
 455       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 456       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 457         {
 458           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 459           if (found)
 460             break;
 461 #ifdef VMS
 462           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 463           if (found)
 464             break;
 465 #endif
 466           found = ldemul_find_potential_libraries (arch->name, entry);
 467           if (found)
 468             break;
 469         }
 470
 471       /* If we have found the file, we don't need to search directories
 472          again.  */
 473       if (found)
 474         entry->search_dirs_flag = FALSE;
 475       else
 476         {
 477           if (entry->sysrooted
 478                && ld_sysroot
 479                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 480             einfo (_("%P: cannot find %s inside %s\n"),
 481                    entry->local_sym_name, ld_sysroot);
 482           else
 483             einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 484           entry->missing_file = TRUE;
 485           missing_file = TRUE;
 486         }
 487     }
 488 }
 489
 490 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 491
 492 static FILE *
 493 try_open (const char *name, const char *exten)
 494 {
 495   FILE *result;
 496
 497   result = fopen (name, "r");
 498
 499   if (trace_file_tries)
 500     {
 501       if (result == NULL)
 502         info_msg (_("cannot find script file %s\n"), name);
 503       else
 504         info_msg (_("opened script file %s\n"), name);
 505     }
 506
 507   if (result != NULL)
 508     return result;
 509
 510   if (*exten)
 511     {
 512       char *buff;
 513
 514       buff = concat (name, exten, (const char *) NULL);
 515       result = fopen (buff, "r");
 516
 517       if (trace_file_tries)
 518         {
 519           if (result == NULL)
 520             info_msg (_("cannot find script file %s\n"), buff);
 521           else
 522             info_msg (_("opened script file %s\n"), buff);
 523         }
 524       free (buff);
 525     }
 526
 527   return result;
 528 }
 529
 530 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 531
 532 static bfd_boolean
 533 check_for_scripts_dir (char *dir)
 534 {
 535   char *buf;
 536   struct stat s;
 537   bfd_boolean res;
 538
 539   buf = concat (dir, "/ldscripts", (const char *) NULL);
 540   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 541   free (buf);
 542   return res;
 543 }
 544
 545 /* Return the default directory for finding script files.
 546    We look for the "ldscripts" directory in:
 547
 548    SCRIPTDIR (passed from Makefile)
 549              (adjusted according to the current location of the binary)
 550    SCRIPTDIR (passed from Makefile)
 551    the dir where this program is (for using it from the build tree).  */
 552
 553 static char *
 554 find_scripts_dir (void)
 555 {
 556   char *dir;
 557
 558   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 559   if (dir)
 560     {
 561       if (check_for_scripts_dir (dir))
 562         return dir;
 563       free (dir);
 564     }
 565
 566   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 567   if (dir)
 568     {
 569       if (check_for_scripts_dir (dir))
 570         return dir;
 571       free (dir);
 572     }
 573
 574   if (check_for_scripts_dir (SCRIPTDIR))
 575     /* We've been installed normally.  */
 576     return SCRIPTDIR;
 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 }