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 Free Software Foundation, Inc.
   4
   5    This file is part of GLD, the Gnu Linker.
   6
   7    GLD 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 2, or (at your option)
  10    any later version.
  11
  12    GLD 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 GLD; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 /* ldfile.c:  look after all the file stuff.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "bfdlink.h"
  27 #include "safe-ctype.h"
  28 #include "ld.h"
  29 #include "ldmisc.h"
  30 #include "ldexp.h"
  31 #include "ldlang.h"
  32 #include "ldfile.h"
  33 #include "ldmain.h"
  34 #include <ldgram.h>
  35 #include "ldlex.h"
  36 #include "ldemul.h"
  37 #include "libiberty.h"
  38 #include "filenames.h"
  39
  40 const char * ldfile_input_filename;
  41 bfd_boolean  ldfile_assumed_script = FALSE;
  42 const char * ldfile_output_machine_name = "";
  43 unsigned long ldfile_output_machine;
  44 enum bfd_architecture ldfile_output_architecture;
  45 search_dirs_type * search_head;
  46
  47 #ifdef VMS
  48 static char * slash = "";
  49 #else
  50 #if defined (_WIN32) && ! defined (__CYGWIN32__)
  51 static char * slash = "\\";
  52 #else
  53 static char * slash = "/";
  54 #endif
  55 #endif
  56
  57 typedef struct search_arch
  58 {
  59   char *name;
  60   struct search_arch *next;
  61 } search_arch_type;
  62
  63 static search_dirs_type **search_tail_ptr = &search_head;
  64 static search_arch_type *search_arch_head;
  65 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
  66
  67 /* Test whether a pathname, after canonicalization, is the same or a
  68    sub-directory of the sysroot directory.  */
  69
  70 static bfd_boolean
  71 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
  72 {
  73   char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
  74   int len;
  75   bfd_boolean result;
  76
  77   if (! realname)
  78     return FALSE;
  79
  80   len = strlen (realname);
  81
  82   if (((! notsame && len == ld_canon_sysroot_len)
  83        || (len >= ld_canon_sysroot_len
  84            && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
  85            && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
  86       && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
  87     result = TRUE;
  88   else
  89     result = FALSE;
  90
  91   if (realname)
  92     free (realname);
  93
  94   return result;
  95 }
  96
  97 /* Adds NAME to the library search path.
  98    Makes a copy of NAME using xmalloc().  */
  99
 100 void
 101 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
 102 {
 103   search_dirs_type *new;
 104
 105   if (!cmdline && config.only_cmd_line_lib_dirs)
 106     return;
 107
 108   new = xmalloc (sizeof (search_dirs_type));
 109   new->next = NULL;
 110   new->cmdline = cmdline;
 111   *search_tail_ptr = new;
 112   search_tail_ptr = &new->next;
 113
 114   /* If a directory is marked as honoring sysroot, prepend the sysroot path
 115      now.  */
 116   if (name[0] == '=')
 117     {
 118       new->name = concat (ld_sysroot, name + 1, NULL);
 119       new->sysrooted = TRUE;
 120     }
 121   else
 122     {
 123       new->name = xstrdup (name);
 124       new->sysrooted = is_sysrooted_pathname (name, FALSE);
 125     }
 126 }
 127
 128 /* Try to open a BFD for a lang_input_statement.  */
 129
 130 bfd_boolean
 131 ldfile_try_open_bfd (const char *attempt,
 132                      lang_input_statement_type *entry)
 133 {
 134   entry->the_bfd = bfd_openr (attempt, entry->target);
 135
 136   if (trace_file_tries)
 137     {
 138       if (entry->the_bfd == NULL)
 139         info_msg (_("attempt to open %s failed\n"), attempt);
 140       else
 141         info_msg (_("attempt to open %s succeeded\n"), attempt);
 142     }
 143
 144   if (entry->the_bfd == NULL)
 145     {
 146       if (bfd_get_error () == bfd_error_invalid_target)
 147         einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
 148       return FALSE;
 149     }
 150
 151   /* If we are searching for this file, see if the architecture is
 152      compatible with the output file.  If it isn't, keep searching.
 153      If we can't open the file as an object file, stop the search
 154      here.  If we are statically linking, ensure that we don't link
 155      a dynamic object.  */
 156
 157   if (entry->search_dirs_flag || !entry->dynamic)
 158     {
 159       bfd *check;
 160
 161       if (bfd_check_format (entry->the_bfd, bfd_archive))
 162         check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
 163       else
 164         check = entry->the_bfd;
 165
 166       if (check != NULL)
 167         {
 168           if (! bfd_check_format (check, bfd_object))
 169             {
 170               if (check == entry->the_bfd
 171                   && entry->search_dirs_flag
 172                   && bfd_get_error () == bfd_error_file_not_recognized
 173                   && ! ldemul_unrecognized_file (entry))
 174                 {
 175                   int token, skip = 0;
 176                   char *arg, *arg1, *arg2, *arg3;
 177                   extern FILE *yyin;
 178
 179                   /* Try to interpret the file as a linker script.  */
 180                   ldfile_open_command_file (attempt);
 181
 182                   ldfile_assumed_script = TRUE;
 183                   parser_input = input_selected;
 184                   ldlex_both ();
 185                   token = INPUT_SCRIPT;
 186                   while (token != 0)
 187                     {
 188                       switch (token)
 189                         {
 190                         case OUTPUT_FORMAT:
 191                           if ((token = yylex ()) != '(')
 192                             continue;
 193                           if ((token = yylex ()) != NAME)
 194                             continue;
 195                           arg1 = yylval.name;
 196                           arg2 = NULL;
 197                           arg3 = NULL;
 198                           token = yylex ();
 199                           if (token == ',')
 200                             {
 201                               if ((token = yylex ()) != NAME)
 202                                 {
 203                                   free (arg1);
 204                                   continue;
 205                                 }
 206                               arg2 = yylval.name;
 207                               if ((token = yylex ()) != ','
 208                                   || (token = yylex ()) != NAME)
 209                                 {
 210                                   free (arg1);
 211                                   free (arg2);
 212                                   continue;
 213                                 }
 214                               arg3 = yylval.name;
 215                               token = yylex ();
 216                             }
 217                           if (token == ')')
 218                             {
 219                               switch (command_line.endian)
 220                                 {
 221                                 default:
 222                                 case ENDIAN_UNSET:
 223                                   arg = arg1; break;
 224                                 case ENDIAN_BIG:
 225                                   arg = arg2 ? arg2 : arg1; break;
 226                                 case ENDIAN_LITTLE:
 227                                   arg = arg3 ? arg3 : arg1; break;
 228                                 }
 229                               if (strcmp (arg, lang_get_output_target ()) != 0)
 230                                 skip = 1;
 231                             }
 232                           free (arg1);
 233                           if (arg2) free (arg2);
 234                           if (arg3) free (arg3);
 235                           break;
 236                         case NAME:
 237                         case LNAME:
 238                         case VERS_IDENTIFIER:
 239                         case VERS_TAG:
 240                           free (yylval.name);
 241                           break;
 242                         case INT:
 243                           if (yylval.bigint.str)
 244                             free (yylval.bigint.str);
 245                           break;
 246                         }
 247                       token = yylex ();
 248                     }
 249                   ldlex_popstate ();
 250                   ldfile_assumed_script = FALSE;
 251                   fclose (yyin);
 252                   yyin = NULL;
 253                   if (skip)
 254                     {
 255                       if (command_line.warn_search_mismatch)
 256                         einfo (_("%P: skipping incompatible %s "
 257                                  "when searching for %s\n"),
 258                                attempt, entry->local_sym_name);
 259                       bfd_close (entry->the_bfd);
 260                       entry->the_bfd = NULL;
 261                       return FALSE;
 262                     }
 263                 }
 264               return TRUE;
 265             }
 266
 267           if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
 268             {
 269               einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
 270                      attempt);
 271               bfd_close (entry->the_bfd);
 272               entry->the_bfd = NULL;
 273               return FALSE;
 274             }
 275
 276           if (entry->search_dirs_flag
 277               && !bfd_arch_get_compatible (check, output_bfd,
 278                                            command_line.accept_unknown_input_arch)
 279               /* XCOFF archives can have 32 and 64 bit objects.  */
 280               && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
 281                     && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
 282                     && bfd_check_format (entry->the_bfd, bfd_archive)))
 283             {
 284               if (command_line.warn_search_mismatch)
 285                 einfo (_("%P: skipping incompatible %s "
 286                          "when searching for %s\n"),
 287                        attempt, entry->local_sym_name);
 288               bfd_close (entry->the_bfd);
 289               entry->the_bfd = NULL;
 290               return FALSE;
 291             }
 292         }
 293     }
 294
 295   return TRUE;
 296 }
 297
 298 /* Search for and open the file specified by ENTRY.  If it is an
 299    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 300
 301 bfd_boolean
 302 ldfile_open_file_search (const char *arch,
 303                          lang_input_statement_type *entry,
 304                          const char *lib,
 305                          const char *suffix)
 306 {
 307   search_dirs_type *search;
 308
 309   /* If this is not an archive, try to open it in the current
 310      directory first.  */
 311   if (! entry->is_archive)
 312     {
 313       if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 314         {
 315           char *name = concat (ld_sysroot, entry->filename,
 316                                (const char *) NULL);
 317           if (ldfile_try_open_bfd (name, entry))
 318             {
 319               entry->filename = name;
 320               return TRUE;
 321             }
 322           free (name);
 323         }
 324       else if (ldfile_try_open_bfd (entry->filename, entry))
 325         {
 326           entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
 327             && is_sysrooted_pathname (entry->filename, TRUE);
 328           return TRUE;
 329         }
 330
 331       if (IS_ABSOLUTE_PATH (entry->filename))
 332         return FALSE;
 333     }
 334
 335   for (search = search_head; search != NULL; search = search->next)
 336     {
 337       char *string;
 338
 339       if (entry->dynamic && ! link_info.relocatable)
 340         {
 341           if (ldemul_open_dynamic_archive (arch, search, entry))
 342             {
 343               entry->sysrooted = search->sysrooted;
 344               return TRUE;
 345             }
 346         }
 347
 348       string = xmalloc (strlen (search->name)
 349                         + strlen (slash)
 350                         + strlen (lib)
 351                         + strlen (entry->filename)
 352                         + strlen (arch)
 353                         + strlen (suffix)
 354                         + 1);
 355
 356       if (entry->is_archive)
 357         sprintf (string, "%s%s%s%s%s%s", search->name, slash,
 358                  lib, entry->filename, arch, suffix);
 359       else
 360         sprintf (string, "%s%s%s", search->name, slash, entry->filename);
 361
 362       if (ldfile_try_open_bfd (string, entry))
 363         {
 364           entry->filename = string;
 365           entry->sysrooted = search->sysrooted;
 366           return TRUE;
 367         }
 368
 369       free (string);
 370     }
 371
 372   return FALSE;
 373 }
 374
 375 /* Open the input file specified by ENTRY.  */
 376
 377 void
 378 ldfile_open_file (lang_input_statement_type *entry)
 379 {
 380   if (entry->the_bfd != NULL)
 381     return;
 382
 383   if (! entry->search_dirs_flag)
 384     {
 385       if (ldfile_try_open_bfd (entry->filename, entry))
 386         return;
 387       if (strcmp (entry->filename, entry->local_sym_name) != 0)
 388         einfo (_("%F%P: %s (%s): No such file: %E\n"),
 389                entry->filename, entry->local_sym_name);
 390       else
 391         einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
 392     }
 393   else
 394     {
 395       search_arch_type *arch;
 396       bfd_boolean found = FALSE;
 397
 398       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 399       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 400         {
 401           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 402           if (found)
 403             break;
 404 #ifdef VMS
 405           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 406           if (found)
 407             break;
 408 #endif
 409           found = ldemul_find_potential_libraries (arch->name, entry);
 410           if (found)
 411             break;
 412         }
 413
 414       /* If we have found the file, we don't need to search directories
 415          again.  */
 416       if (found)
 417         entry->search_dirs_flag = FALSE;
 418       else if (entry->sysrooted
 419                && ld_sysroot
 420                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 421         einfo (_("%F%P: cannot find %s inside %s\n"),
 422                entry->local_sym_name, ld_sysroot);
 423       else
 424         einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
 425     }
 426 }
 427
 428 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 429
 430 static FILE *
 431 try_open (const char *name, const char *exten)
 432 {
 433   FILE *result;
 434   char buff[1000];
 435
 436   result = fopen (name, "r");
 437
 438   if (trace_file_tries)
 439     {
 440       if (result == NULL)
 441         info_msg (_("cannot find script file %s\n"), name);
 442       else
 443         info_msg (_("opened script file %s\n"), name);
 444     }
 445
 446   if (result != NULL)
 447     return result;
 448
 449   if (*exten)
 450     {
 451       sprintf (buff, "%s%s", name, exten);
 452       result = fopen (buff, "r");
 453
 454       if (trace_file_tries)
 455         {
 456           if (result == NULL)
 457             info_msg (_("cannot find script file %s\n"), buff);
 458           else
 459             info_msg (_("opened script file %s\n"), buff);
 460         }
 461     }
 462
 463   return result;
 464 }
 465
 466 /* Try to open NAME; if that fails, look for it in any directories
 467    specified with -L, without and with EXTEND appended.  */
 468
 469 static FILE *
 470 ldfile_find_command_file (const char *name, const char *extend)
 471 {
 472   search_dirs_type *search;
 473   FILE *result;
 474   char buffer[1000];
 475
 476   /* First try raw name.  */
 477   result = try_open (name, "");
 478   if (result == NULL)
 479     {
 480       /* Try now prefixes.  */
 481       for (search = search_head; search != NULL; search = search->next)
 482         {
 483           sprintf (buffer, "%s%s%s", search->name, slash, name);
 484
 485           result = try_open (buffer, extend);
 486           if (result)
 487             break;
 488         }
 489     }
 490
 491   return result;
 492 }
 493
 494 void
 495 ldfile_open_command_file (const char *name)
 496 {
 497   FILE *ldlex_input_stack;
 498   ldlex_input_stack = ldfile_find_command_file (name, "");
 499
 500   if (ldlex_input_stack == NULL)
 501     {
 502       bfd_set_error (bfd_error_system_call);
 503       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 504     }
 505
 506   lex_push_file (ldlex_input_stack, name);
 507
 508   ldfile_input_filename = name;
 509   lineno = 1;
 510
 511   saved_script_handle = ldlex_input_stack;
 512 }
 513
 514 void
 515 ldfile_add_arch (const char *in_name)
 516 {
 517   char *name = xstrdup (in_name);
 518   search_arch_type *new = xmalloc (sizeof (search_arch_type));
 519
 520   ldfile_output_machine_name = in_name;
 521
 522   new->name = name;
 523   new->next = NULL;
 524   while (*name)
 525     {
 526       *name = TOLOWER (*name);
 527       name++;
 528     }
 529   *search_arch_tail_ptr = new;
 530   search_arch_tail_ptr = &new->next;
 531
 532 }
 533
 534 /* Set the output architecture.  */
 535
 536 void
 537 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 538 {
 539   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 540
 541   if (arch)
 542     {
 543       ldfile_output_architecture = arch->arch;
 544       ldfile_output_machine = arch->mach;
 545       ldfile_output_machine_name = arch->printable_name;
 546     }
 547   else if (defarch != bfd_arch_unknown)
 548     ldfile_output_architecture = defarch;
 549   else
 550     einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 551 }