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
  38 const char * ldfile_input_filename;
  39 bfd_boolean  ldfile_assumed_script = FALSE;
  40 const char * ldfile_output_machine_name = "";
  41 unsigned long ldfile_output_machine;
  42 enum bfd_architecture ldfile_output_architecture;
  43 search_dirs_type * search_head;
  44
  45 #ifdef VMS
  46 static char * slash = "";
  47 #else
  48 #if defined (_WIN32) && ! defined (__CYGWIN32__)
  49 static char * slash = "\\";
  50 #else
  51 static char * slash = "/";
  52 #endif
  53 #endif
  54
  55 typedef struct search_arch
  56 {
  57   char *name;
  58   struct search_arch *next;
  59 } search_arch_type;
  60
  61 static search_dirs_type **search_tail_ptr = &search_head;
  62 static search_arch_type *search_arch_head;
  63 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
  64
  65 /* Test whether a pathname, after canonicalization, is the same or a
  66    sub-directory of the sysroot directory.  */
  67
  68 static bfd_boolean
  69 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
  70 {
  71   char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
  72   int len;
  73   bfd_boolean result;
  74
  75   if (! realname)
  76     return FALSE;
  77
  78   len = strlen (realname);
  79
  80   if (((! notsame && len == ld_canon_sysroot_len)
  81        || (len >= ld_canon_sysroot_len
  82            && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
  83            && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
  84       && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
  85     result = TRUE;
  86   else
  87     result = FALSE;
  88
  89   if (realname)
  90     free (realname);
  91
  92   return result;
  93 }
  94
  95 /* Adds NAME to the library search path.
  96    Makes a copy of NAME using xmalloc().  */
  97
  98 void
  99 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
 100 {
 101   search_dirs_type *new_dirs;
 102
 103   if (!cmdline && config.only_cmd_line_lib_dirs)
 104     return;
 105
 106   new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
 107   new_dirs->next = NULL;
 108   new_dirs->cmdline = cmdline;
 109   *search_tail_ptr = new_dirs;
 110   search_tail_ptr = &new_dirs->next;
 111
 112   /* If a directory is marked as honoring sysroot, prepend the sysroot path
 113      now.  */
 114   if (name[0] == '=')
 115     {
 116       new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
 117       new_dirs->sysrooted = TRUE;
 118     }
 119   else
 120     {
 121       new_dirs->name = xstrdup (name);
 122       new_dirs->sysrooted = is_sysrooted_pathname (name, FALSE);
 123     }
 124 }
 125
 126 /* Try to open a BFD for a lang_input_statement.  */
 127
 128 bfd_boolean
 129 ldfile_try_open_bfd (const char *attempt,
 130                      lang_input_statement_type *entry)
 131 {
 132   entry->the_bfd = bfd_openr (attempt, entry->target);
 133
 134   if (trace_file_tries)
 135     {
 136       if (entry->the_bfd == NULL)
 137         info_msg (_("attempt to open %s failed\n"), attempt);
 138       else
 139         info_msg (_("attempt to open %s succeeded\n"), attempt);
 140     }
 141
 142   if (entry->the_bfd == NULL)
 143     {
 144       if (bfd_get_error () == bfd_error_invalid_target)
 145         einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
 146       return FALSE;
 147     }
 148
 149   /* If we are searching for this file, see if the architecture is
 150      compatible with the output file.  If it isn't, keep searching.
 151      If we can't open the file as an object file, stop the search
 152      here.  If we are statically linking, ensure that we don't link
 153      a dynamic object.  */
 154
 155   if (entry->search_dirs_flag || !entry->dynamic)
 156     {
 157       bfd *check;
 158
 159       if (bfd_check_format (entry->the_bfd, bfd_archive))
 160         check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
 161       else
 162         check = entry->the_bfd;
 163
 164       if (check != NULL)
 165         {
 166           if (! bfd_check_format (check, bfd_object))
 167             {
 168               if (check == entry->the_bfd
 169                   && entry->search_dirs_flag
 170                   && bfd_get_error () == bfd_error_file_not_recognized
 171                   && ! ldemul_unrecognized_file (entry))
 172                 {
 173                   int token, skip = 0;
 174                   char *arg, *arg1, *arg2, *arg3;
 175                   extern FILE *yyin;
 176
 177                   /* Try to interpret the file as a linker script.  */
 178                   ldfile_open_command_file (attempt);
 179
 180                   ldfile_assumed_script = TRUE;
 181                   parser_input = input_selected;
 182                   ldlex_both ();
 183                   token = INPUT_SCRIPT;
 184                   while (token != 0)
 185                     {
 186                       switch (token)
 187                         {
 188                         case OUTPUT_FORMAT:
 189                           if ((token = yylex ()) != '(')
 190                             continue;
 191                           if ((token = yylex ()) != NAME)
 192                             continue;
 193                           arg1 = yylval.name;
 194                           arg2 = NULL;
 195                           arg3 = NULL;
 196                           token = yylex ();
 197                           if (token == ',')
 198                             {
 199                               if ((token = yylex ()) != NAME)
 200                                 {
 201                                   free (arg1);
 202                                   continue;
 203                                 }
 204                               arg2 = yylval.name;
 205                               if ((token = yylex ()) != ','
 206                                   || (token = yylex ()) != NAME)
 207                                 {
 208                                   free (arg1);
 209                                   free (arg2);
 210                                   continue;
 211                                 }
 212                               arg3 = yylval.name;
 213                               token = yylex ();
 214                             }
 215                           if (token == ')')
 216                             {
 217                               switch (command_line.endian)
 218                                 {
 219                                 default:
 220                                 case ENDIAN_UNSET:
 221                                   arg = arg1; break;
 222                                 case ENDIAN_BIG:
 223                                   arg = arg2 ? arg2 : arg1; break;
 224                                 case ENDIAN_LITTLE:
 225                                   arg = arg3 ? arg3 : arg1; break;
 226                                 }
 227                               if (strcmp (arg, lang_get_output_target ()) != 0)
 228                                 skip = 1;
 229                             }
 230                           free (arg1);
 231                           if (arg2) free (arg2);
 232                           if (arg3) free (arg3);
 233                           break;
 234                         case NAME:
 235                         case LNAME:
 236                         case VERS_IDENTIFIER:
 237                         case VERS_TAG:
 238                           free (yylval.name);
 239                           break;
 240                         case INT:
 241                           if (yylval.bigint.str)
 242                             free (yylval.bigint.str);
 243                           break;
 244                         }
 245                       token = yylex ();
 246                     }
 247                   ldlex_popstate ();
 248                   ldfile_assumed_script = FALSE;
 249                   fclose (yyin);
 250                   yyin = NULL;
 251                   if (skip)
 252                     {
 253                       if (command_line.warn_search_mismatch)
 254                         einfo (_("%P: skipping incompatible %s "
 255                                  "when searching for %s\n"),
 256                                attempt, entry->local_sym_name);
 257                       bfd_close (entry->the_bfd);
 258                       entry->the_bfd = NULL;
 259                       return FALSE;
 260                     }
 261                 }
 262               return TRUE;
 263             }
 264
 265           if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
 266             {
 267               einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
 268                      attempt);
 269               bfd_close (entry->the_bfd);
 270               entry->the_bfd = NULL;
 271               return FALSE;
 272             }
 273
 274           if (entry->search_dirs_flag
 275               && !bfd_arch_get_compatible (check, link_info.output_bfd,
 276                                            command_line.accept_unknown_input_arch)
 277               /* XCOFF archives can have 32 and 64 bit objects.  */
 278               && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
 279                     && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
 280                     && bfd_check_format (entry->the_bfd, bfd_archive)))
 281             {
 282               if (command_line.warn_search_mismatch)
 283                 einfo (_("%P: skipping incompatible %s "
 284                          "when searching for %s\n"),
 285                        attempt, entry->local_sym_name);
 286               bfd_close (entry->the_bfd);
 287               entry->the_bfd = NULL;
 288               return FALSE;
 289             }
 290         }
 291     }
 292
 293   return TRUE;
 294 }
 295
 296 /* Search for and open the file specified by ENTRY.  If it is an
 297    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 298
 299 bfd_boolean
 300 ldfile_open_file_search (const char *arch,
 301                          lang_input_statement_type *entry,
 302                          const char *lib,
 303                          const char *suffix)
 304 {
 305   search_dirs_type *search;
 306
 307   /* If this is not an archive, try to open it in the current
 308      directory first.  */
 309   if (! entry->is_archive)
 310     {
 311       if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 312         {
 313           char *name = concat (ld_sysroot, entry->filename,
 314                                (const char *) NULL);
 315           if (ldfile_try_open_bfd (name, entry))
 316             {
 317               entry->filename = name;
 318               return TRUE;
 319             }
 320           free (name);
 321         }
 322       else if (ldfile_try_open_bfd (entry->filename, entry))
 323         {
 324           entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
 325             && is_sysrooted_pathname (entry->filename, TRUE);
 326           return TRUE;
 327         }
 328
 329       if (IS_ABSOLUTE_PATH (entry->filename))
 330         return FALSE;
 331     }
 332
 333   for (search = search_head; search != NULL; search = search->next)
 334     {
 335       char *string;
 336
 337       if (entry->dynamic && ! link_info.relocatable)
 338         {
 339           if (ldemul_open_dynamic_archive (arch, search, entry))
 340             {
 341               entry->sysrooted = search->sysrooted;
 342               return TRUE;
 343             }
 344         }
 345
 346       if (entry->is_archive)
 347         string = concat (search->name, slash, lib, entry->filename,
 348                          arch, suffix, (const char *) NULL);
 349       else
 350         string = concat (search->name, slash, entry->filename,
 351                          (const char *) 0);
 352
 353       if (ldfile_try_open_bfd (string, entry))
 354         {
 355           entry->filename = string;
 356           entry->sysrooted = search->sysrooted;
 357           return TRUE;
 358         }
 359
 360       free (string);
 361     }
 362
 363   return FALSE;
 364 }
 365
 366 /* Open the input file specified by ENTRY.
 367    PR 4437: Do not stop on the first missing file, but
 368    continue processing other input files in case there
 369    are more errors to report.  */
 370
 371 void
 372 ldfile_open_file (lang_input_statement_type *entry)
 373 {
 374   if (entry->the_bfd != NULL)
 375     return;
 376
 377   if (! entry->search_dirs_flag)
 378     {
 379       if (ldfile_try_open_bfd (entry->filename, entry))
 380         return;
 381
 382       if (strcmp (entry->filename, entry->local_sym_name) != 0)
 383         einfo (_("%P: cannot find %s (%s): %E\n"),
 384                entry->filename, entry->local_sym_name);
 385       else
 386         einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 387
 388       entry->missing_file = TRUE;
 389       missing_file = TRUE;
 390     }
 391   else
 392     {
 393       search_arch_type *arch;
 394       bfd_boolean found = FALSE;
 395
 396       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 397       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 398         {
 399           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 400           if (found)
 401             break;
 402 #ifdef VMS
 403           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 404           if (found)
 405             break;
 406 #endif
 407           found = ldemul_find_potential_libraries (arch->name, entry);
 408           if (found)
 409             break;
 410         }
 411
 412       /* If we have found the file, we don't need to search directories
 413          again.  */
 414       if (found)
 415         entry->search_dirs_flag = FALSE;
 416       else
 417         {
 418           if (entry->sysrooted
 419                && ld_sysroot
 420                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 421             einfo (_("%P: cannot find %s inside %s\n"),
 422                    entry->local_sym_name, ld_sysroot);
 423           else
 424             einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 425           entry->missing_file = TRUE;
 426           missing_file = TRUE;
 427         }
 428     }
 429 }
 430
 431 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 432
 433 static FILE *
 434 try_open (const char *name, const char *exten)
 435 {
 436   FILE *result;
 437
 438   result = fopen (name, "r");
 439
 440   if (trace_file_tries)
 441     {
 442       if (result == NULL)
 443         info_msg (_("cannot find script file %s\n"), name);
 444       else
 445         info_msg (_("opened script file %s\n"), name);
 446     }
 447
 448   if (result != NULL)
 449     return result;
 450
 451   if (*exten)
 452     {
 453       char *buff;
 454
 455       buff = concat (name, exten, (const char *) NULL);
 456       result = fopen (buff, "r");
 457
 458       if (trace_file_tries)
 459         {
 460           if (result == NULL)
 461             info_msg (_("cannot find script file %s\n"), buff);
 462           else
 463             info_msg (_("opened script file %s\n"), buff);
 464         }
 465       free (buff);
 466     }
 467
 468   return result;
 469 }
 470
 471 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 472
 473 static bfd_boolean
 474 check_for_scripts_dir (char *dir)
 475 {
 476   char *buf;
 477   struct stat s;
 478   bfd_boolean res;
 479
 480   buf = concat (dir, "/ldscripts", (const char *) NULL);
 481   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 482   free (buf);
 483   return res;
 484 }
 485
 486 /* Return the default directory for finding script files.
 487    We look for the "ldscripts" directory in:
 488
 489    SCRIPTDIR (passed from Makefile)
 490              (adjusted according to the current location of the binary)
 491    SCRIPTDIR (passed from Makefile)
 492    the dir where this program is (for using it from the build tree).  */
 493
 494 static char *
 495 find_scripts_dir (void)
 496 {
 497   char *dir;
 498
 499   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 500   if (dir)
 501     {
 502       if (check_for_scripts_dir (dir))
 503         return dir;
 504       free (dir);
 505     }
 506
 507   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 508   if (dir)
 509     {
 510       if (check_for_scripts_dir (dir))
 511         return dir;
 512       free (dir);
 513     }
 514
 515   if (check_for_scripts_dir (SCRIPTDIR))
 516     /* We've been installed normally.  */
 517     return SCRIPTDIR;
 518
 519   /* Look for "ldscripts" in the dir where our binary is.  */
 520   dir = make_relative_prefix (program_name, ".", ".");
 521   if (dir)
 522     {
 523       if (check_for_scripts_dir (dir))
 524         return dir;
 525       free (dir);
 526     }
 527
 528   return NULL;
 529 }
 530
 531 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
 532    it in directories specified with -L, then in the default script
 533    directory, without and with EXTEND appended.  If DEFAULT_ONLY is
 534    true, the search is restricted to the default script location.  */
 535
 536 static FILE *
 537 ldfile_find_command_file (const char *name, const char *extend,
 538                           bfd_boolean default_only)
 539 {
 540   search_dirs_type *search;
 541   FILE *result = NULL;
 542   char *buffer;
 543   static search_dirs_type *script_search;
 544
 545   if (!default_only)
 546     {
 547       /* First try raw name.  */
 548       result = try_open (name, "");
 549       if (result != NULL)
 550         return result;
 551     }
 552
 553   if (!script_search)
 554     {
 555       char *script_dir = find_scripts_dir ();
 556       if (script_dir)
 557         {
 558           search_dirs_type **save_tail_ptr = search_tail_ptr;
 559           search_tail_ptr = &script_search;
 560           ldfile_add_library_path (script_dir, TRUE);
 561           search_tail_ptr = save_tail_ptr;
 562         }
 563     }
 564
 565   /* Temporarily append script_search to the path list so that the
 566      paths specified with -L will be searched first.  */
 567   *search_tail_ptr = script_search;
 568
 569   /* Try now prefixes.  */
 570   for (search = default_only ? script_search : search_head;
 571        search != NULL;
 572        search = search->next)
 573     {
 574       buffer = concat (search->name, slash, name, (const char *) NULL);
 575       result = try_open (buffer, extend);
 576       free (buffer);
 577       if (result)
 578         break;
 579     }
 580
 581   /* Restore the original path list.  */
 582   *search_tail_ptr = NULL;
 583
 584   return result;
 585 }
 586
 587 /* Open command file NAME.  */
 588
 589 static void
 590 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
 591 {
 592   FILE *ldlex_input_stack;
 593   ldlex_input_stack = ldfile_find_command_file (name, "", default_only);
 594
 595   if (ldlex_input_stack == NULL)
 596     {
 597       bfd_set_error (bfd_error_system_call);
 598       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 599     }
 600
 601   lex_push_file (ldlex_input_stack, name);
 602
 603   ldfile_input_filename = name;
 604   lineno = 1;
 605
 606   saved_script_handle = ldlex_input_stack;
 607 }
 608
 609 /* Open command file NAME in the current directory, -L directories,
 610    the default script location, in that order.  */
 611
 612 void
 613 ldfile_open_command_file (const char *name)
 614 {
 615   ldfile_open_command_file_1 (name, FALSE);
 616 }
 617
 618 /* Open command file NAME at the default script location.  */
 619
 620 void
 621 ldfile_open_default_command_file (const char *name)
 622 {
 623   ldfile_open_command_file_1 (name, TRUE);
 624 }
 625
 626 void
 627 ldfile_add_arch (const char *in_name)
 628 {
 629   char *name = xstrdup (in_name);
 630   search_arch_type *new_arch = (search_arch_type *)
 631       xmalloc (sizeof (search_arch_type));
 632
 633   ldfile_output_machine_name = in_name;
 634
 635   new_arch->name = name;
 636   new_arch->next = NULL;
 637   while (*name)
 638     {
 639       *name = TOLOWER (*name);
 640       name++;
 641     }
 642   *search_arch_tail_ptr = new_arch;
 643   search_arch_tail_ptr = &new_arch->next;
 644
 645 }
 646
 647 /* Set the output architecture.  */
 648
 649 void
 650 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 651 {
 652   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 653
 654   if (arch)
 655     {
 656       ldfile_output_architecture = arch->arch;
 657       ldfile_output_machine = arch->mach;
 658       ldfile_output_machine_name = arch->printable_name;
 659     }
 660   else if (defarch != bfd_arch_unknown)
 661     ldfile_output_architecture = defarch;
 662   else
 663     einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 664 }