ld/ldfile.c

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