ld/ldfile.c

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