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 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 "bfd.h"
  25 #include "sysdep.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                       einfo (_("%P: skipping incompatible %s 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, 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 (output_bfd) == bfd_target_xcoff_flavour
 280                     && bfd_check_format (entry->the_bfd, bfd_archive)))
 281             {
 282               einfo (_("%P: skipping incompatible %s when searching for %s\n"),
 283                      attempt, entry->local_sym_name);
 284               bfd_close (entry->the_bfd);
 285               entry->the_bfd = NULL;
 286               return FALSE;
 287             }
 288         }
 289     }
 290
 291   return TRUE;
 292 }
 293
 294 /* Search for and open the file specified by ENTRY.  If it is an
 295    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 296
 297 bfd_boolean
 298 ldfile_open_file_search (const char *arch,
 299                          lang_input_statement_type *entry,
 300                          const char *lib,
 301                          const char *suffix)
 302 {
 303   search_dirs_type *search;
 304
 305   /* If this is not an archive, try to open it in the current
 306      directory first.  */
 307   if (! entry->is_archive)
 308     {
 309       if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 310         {
 311           char *name = concat (ld_sysroot, entry->filename,
 312                                (const char *) NULL);
 313           if (ldfile_try_open_bfd (name, entry))
 314             {
 315               entry->filename = name;
 316               return TRUE;
 317             }
 318           free (name);
 319         }
 320       else if (ldfile_try_open_bfd (entry->filename, entry))
 321         {
 322           entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
 323             && is_sysrooted_pathname (entry->filename, TRUE);
 324           return TRUE;
 325         }
 326
 327       if (IS_ABSOLUTE_PATH (entry->filename))
 328         return FALSE;
 329     }
 330
 331   for (search = search_head; search != NULL; search = search->next)
 332     {
 333       char *string;
 334
 335       if (entry->dynamic && ! link_info.relocatable)
 336         {
 337           if (ldemul_open_dynamic_archive (arch, search, entry))
 338             {
 339               entry->sysrooted = search->sysrooted;
 340               return TRUE;
 341             }
 342         }
 343
 344       string = xmalloc (strlen (search->name)
 345                         + strlen (slash)
 346                         + strlen (lib)
 347                         + strlen (entry->filename)
 348                         + strlen (arch)
 349                         + strlen (suffix)
 350                         + 1);
 351
 352       if (entry->is_archive)
 353         sprintf (string, "%s%s%s%s%s%s", search->name, slash,
 354                  lib, entry->filename, arch, suffix);
 355       else
 356         sprintf (string, "%s%s%s", search->name, slash, entry->filename);
 357
 358       if (ldfile_try_open_bfd (string, entry))
 359         {
 360           entry->filename = string;
 361           entry->sysrooted = search->sysrooted;
 362           return TRUE;
 363         }
 364
 365       free (string);
 366     }
 367
 368   return FALSE;
 369 }
 370
 371 /* Open the input file specified by ENTRY.  */
 372
 373 void
 374 ldfile_open_file (lang_input_statement_type *entry)
 375 {
 376   if (entry->the_bfd != NULL)
 377     return;
 378
 379   if (! entry->search_dirs_flag)
 380     {
 381       if (ldfile_try_open_bfd (entry->filename, entry))
 382         return;
 383       if (strcmp (entry->filename, entry->local_sym_name) != 0)
 384         einfo (_("%F%P: %s (%s): No such file: %E\n"),
 385                entry->filename, entry->local_sym_name);
 386       else
 387         einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
 388     }
 389   else
 390     {
 391       search_arch_type *arch;
 392       bfd_boolean found = FALSE;
 393
 394       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 395       for (arch = search_arch_head; arch != NULL; arch = arch->next)
 396         {
 397           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 398           if (found)
 399             break;
 400 #ifdef VMS
 401           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 402           if (found)
 403             break;
 404 #endif
 405           found = ldemul_find_potential_libraries (arch->name, entry);
 406           if (found)
 407             break;
 408         }
 409
 410       /* If we have found the file, we don't need to search directories
 411          again.  */
 412       if (found)
 413         entry->search_dirs_flag = FALSE;
 414       else if (entry->sysrooted
 415                && ld_sysroot
 416                && IS_ABSOLUTE_PATH (entry->local_sym_name))
 417         einfo (_("%F%P: cannot find %s inside %s\n"),
 418                entry->local_sym_name, ld_sysroot);
 419       else
 420         einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
 421     }
 422 }
 423
 424 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 425
 426 static FILE *
 427 try_open (const char *name, const char *exten)
 428 {
 429   FILE *result;
 430   char buff[1000];
 431
 432   result = fopen (name, "r");
 433
 434   if (trace_file_tries)
 435     {
 436       if (result == NULL)
 437         info_msg (_("cannot find script file %s\n"), name);
 438       else
 439         info_msg (_("opened script file %s\n"), name);
 440     }
 441
 442   if (result != NULL)
 443     return result;
 444
 445   if (*exten)
 446     {
 447       sprintf (buff, "%s%s", name, exten);
 448       result = fopen (buff, "r");
 449
 450       if (trace_file_tries)
 451         {
 452           if (result == NULL)
 453             info_msg (_("cannot find script file %s\n"), buff);
 454           else
 455             info_msg (_("opened script file %s\n"), buff);
 456         }
 457     }
 458
 459   return result;
 460 }
 461
 462 /* Try to open NAME; if that fails, look for it in any directories
 463    specified with -L, without and with EXTEND appended.  */
 464
 465 static FILE *
 466 ldfile_find_command_file (const char *name, const char *extend)
 467 {
 468   search_dirs_type *search;
 469   FILE *result;
 470   char buffer[1000];
 471
 472   /* First try raw name.  */
 473   result = try_open (name, "");
 474   if (result == NULL)
 475     {
 476       /* Try now prefixes.  */
 477       for (search = search_head; search != NULL; search = search->next)
 478         {
 479           sprintf (buffer, "%s%s%s", search->name, slash, name);
 480
 481           result = try_open (buffer, extend);
 482           if (result)
 483             break;
 484         }
 485     }
 486
 487   return result;
 488 }
 489
 490 void
 491 ldfile_open_command_file (const char *name)
 492 {
 493   FILE *ldlex_input_stack;
 494   ldlex_input_stack = ldfile_find_command_file (name, "");
 495
 496   if (ldlex_input_stack == NULL)
 497     {
 498       bfd_set_error (bfd_error_system_call);
 499       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 500     }
 501
 502   lex_push_file (ldlex_input_stack, name);
 503
 504   ldfile_input_filename = name;
 505   lineno = 1;
 506
 507   saved_script_handle = ldlex_input_stack;
 508 }
 509
 510 void
 511 ldfile_add_arch (const char *in_name)
 512 {
 513   char *name = xstrdup (in_name);
 514   search_arch_type *new = xmalloc (sizeof (search_arch_type));
 515
 516   ldfile_output_machine_name = in_name;
 517
 518   new->name = name;
 519   new->next = NULL;
 520   while (*name)
 521     {
 522       *name = TOLOWER (*name);
 523       name++;
 524     }
 525   *search_arch_tail_ptr = new;
 526   search_arch_tail_ptr = &new->next;
 527
 528 }
 529
 530 /* Set the output architecture.  */
 531
 532 void
 533 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 534 {
 535   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 536
 537   if (arch)
 538     {
 539       ldfile_output_architecture = arch->arch;
 540       ldfile_output_machine = arch->mach;
 541       ldfile_output_machine_name = arch->printable_name;
 542     }
 543   else if (defarch != bfd_arch_unknown)
 544     ldfile_output_architecture = defarch;
 545   else
 546     einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 547 }