ld/ldfile.c

   1 /* Linker file opening and searching.
   2    Copyright (C) 1991, 92, 93, 94, 95, 98, 99, 2000
   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 "ld.h"
  28 #include "ldmisc.h"
  29 #include "ldexp.h"
  30 #include "ldlang.h"
  31 #include "ldfile.h"
  32 #include "ldmain.h"
  33 #include "ldgram.h"
  34 #include "ldlex.h"
  35 #include "ldemul.h"
  36
  37 #include <ctype.h>
  38
  39 const char *ldfile_input_filename;
  40 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      boolean cmdline;
  79 {
  80   search_dirs_type *new;
  81
  82   new = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
  83   new->next = NULL;
  84   new->name = name;
  85   new->cmdline = cmdline;
  86   *search_tail_ptr = new;
  87   search_tail_ptr = &new->next;
  88 }
  89
  90 /* Try to open a BFD for a lang_input_statement.  */
  91
  92 boolean
  93 ldfile_try_open_bfd (attempt, entry)
  94      const char *attempt;
  95      lang_input_statement_type *entry;
  96 {
  97   entry->the_bfd = bfd_openr (attempt, entry->target);
  98
  99   if (trace_file_tries)
 100     {
 101       if (entry->the_bfd == NULL)
 102         info_msg (_("attempt to open %s failed\n"), attempt);
 103       else
 104         info_msg (_("attempt to open %s succeeded\n"), attempt);
 105     }
 106
 107   if (entry->the_bfd == NULL)
 108     {
 109       if (bfd_get_error () == bfd_error_invalid_target)
 110         einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
 111       return false;
 112     }
 113
 114   /* If we are searching for this file, see if the architecture is
 115      compatible with the output file.  If it isn't, keep searching.
 116      If we can't open the file as an object file, stop the search
 117      here.  */
 118
 119   if (entry->search_dirs_flag)
 120     {
 121       bfd *check;
 122
 123       if (bfd_check_format (entry->the_bfd, bfd_archive))
 124         check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
 125       else
 126         check = entry->the_bfd;
 127
 128       if (check != NULL)
 129         {
 130           if (! bfd_check_format (check, bfd_object))
 131             return true;
 132           if (bfd_arch_get_compatible (check, output_bfd) == NULL)
 133             {
 134               einfo (_("%P: skipping incompatible %s when searching for %s\n"),
 135                      attempt, entry->local_sym_name);
 136               bfd_close (entry->the_bfd);
 137               entry->the_bfd = NULL;
 138               return false;
 139             }
 140         }
 141     }
 142
 143   return true;
 144 }
 145
 146 /* Search for and open the file specified by ENTRY.  If it is an
 147    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 148
 149 boolean
 150 ldfile_open_file_search (arch, entry, lib, suffix)
 151      const char *arch;
 152      lang_input_statement_type *entry;
 153      const char *lib;
 154      const char *suffix;
 155 {
 156   search_dirs_type *search;
 157
 158   /* If this is not an archive, try to open it in the current
 159      directory first.  */
 160   if (! entry->is_archive)
 161     {
 162       if (ldfile_try_open_bfd (entry->filename, entry))
 163         return true;
 164     }
 165
 166   for (search = search_head;
 167        search != (search_dirs_type *) NULL;
 168        search = search->next)
 169     {
 170       char *string;
 171
 172       if (entry->dynamic && ! link_info.relocateable)
 173         {
 174           if (ldemul_open_dynamic_archive (arch, search, entry))
 175             return true;
 176         }
 177
 178       string = (char *) xmalloc (strlen (search->name)
 179                                  + strlen (slash)
 180                                  + strlen (lib)
 181                                  + strlen (entry->filename)
 182                                  + strlen (arch)
 183                                  + strlen (suffix)
 184                                  + 1);
 185
 186       if (entry->is_archive)
 187         sprintf (string, "%s%s%s%s%s%s", search->name, slash,
 188                  lib, entry->filename, arch, suffix);
 189       else if (entry->filename[0] == '/' || entry->filename[0] == '.'
 190 #if defined (__MSDOS__) || defined (_WIN32)
 191                || entry->filename[0] == '\\'
 192                || (isalpha (entry->filename[0])
 193                    && entry->filename[1] == ':')
 194 #endif
 195           )
 196         strcpy (string, entry->filename);
 197       else
 198         sprintf (string, "%s%s%s", search->name, slash, entry->filename);
 199
 200       if (ldfile_try_open_bfd (string, entry))
 201         {
 202           entry->filename = string;
 203           return true;
 204         }
 205
 206       free (string);
 207     }
 208
 209   return false;
 210 }
 211
 212 /* Open the input file specified by ENTRY.  */
 213
 214 void
 215 ldfile_open_file (entry)
 216      lang_input_statement_type *entry;
 217 {
 218   if (entry->the_bfd != NULL)
 219     return;
 220
 221   if (! entry->search_dirs_flag)
 222     {
 223       if (ldfile_try_open_bfd (entry->filename, entry))
 224         return;
 225       if (strcmp (entry->filename, entry->local_sym_name) != 0)
 226         einfo (_("%F%P: cannot open %s for %s: %E\n"),
 227                entry->filename, entry->local_sym_name);
 228       else
 229         einfo (_("%F%P: cannot open %s: %E\n"), entry->local_sym_name);
 230     }
 231   else
 232     {
 233       search_arch_type *arch;
 234
 235       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 236       for (arch = search_arch_head;
 237            arch != (search_arch_type *) NULL;
 238            arch = arch->next)
 239         {
 240           if (ldfile_open_file_search (arch->name, entry, "lib", ".a"))
 241             return;
 242 #ifdef VMS
 243           if (ldfile_open_file_search (arch->name, entry, ":lib", ".a"))
 244             return;
 245 #endif
 246           if (ldemul_find_potential_libraries (arch->name, entry))
 247             return;
 248         }
 249
 250       einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
 251     }
 252 }
 253
 254 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 255
 256 static FILE *
 257 try_open (name, exten)
 258      const char *name;
 259      const char *exten;
 260 {
 261   FILE *result;
 262   char buff[1000];
 263
 264   result = fopen (name, "r");
 265
 266   if (trace_file_tries)
 267     {
 268       if (result == NULL)
 269         info_msg (_("cannot find script file %s\n"), name);
 270       else
 271         info_msg (_("opened script file %s\n"), name);
 272     }
 273
 274   if (result != NULL)
 275     return result;
 276
 277   if (*exten)
 278     {
 279       sprintf (buff, "%s%s", name, exten);
 280       result = fopen (buff, "r");
 281
 282       if (trace_file_tries)
 283         {
 284           if (result == NULL)
 285             info_msg (_("cannot find script file %s\n"), buff);
 286           else
 287             info_msg (_("opened script file %s\n"), buff);
 288         }
 289     }
 290
 291   return result;
 292 }
 293
 294 /* Try to open NAME; if that fails, look for it in any directories
 295    specified with -L, without and with EXTEND apppended.  */
 296
 297 FILE *
 298 ldfile_find_command_file (name, extend)
 299      const char *name;
 300      const char *extend;
 301 {
 302   search_dirs_type *search;
 303   FILE *result;
 304   char buffer[1000];
 305
 306   /* First try raw name.  */
 307   result = try_open (name, "");
 308   if (result == (FILE *) NULL)
 309     {
 310       /* Try now prefixes.  */
 311       for (search = search_head;
 312            search != (search_dirs_type *) NULL;
 313            search = search->next)
 314         {
 315           sprintf (buffer, "%s%s%s", search->name, slash, name);
 316
 317           result = try_open (buffer, extend);
 318           if (result)
 319             break;
 320         }
 321     }
 322
 323   return result;
 324 }
 325
 326 void
 327 ldfile_open_command_file (name)
 328      const char *name;
 329 {
 330   FILE *ldlex_input_stack;
 331   ldlex_input_stack = ldfile_find_command_file (name, "");
 332
 333   if (ldlex_input_stack == (FILE *) NULL)
 334     {
 335       bfd_set_error (bfd_error_system_call);
 336       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 337     }
 338
 339   lex_push_file (ldlex_input_stack, name);
 340
 341   ldfile_input_filename = name;
 342   lineno = 1;
 343   had_script = true;
 344 }
 345
 346 #ifdef GNU960
 347 static char *
 348 gnu960_map_archname (name)
 349      char *name;
 350 {
 351   struct tabentry { char *cmd_switch; char *arch; };
 352   static struct tabentry arch_tab[] =
 353   {
 354         "",   "",
 355         "KA", "ka",
 356         "KB", "kb",
 357         "KC", "mc",     /* Synonym for MC */
 358         "MC", "mc",
 359         "CA", "ca",
 360         "SA", "ka",     /* Functionally equivalent to KA */
 361         "SB", "kb",     /* Functionally equivalent to KB */
 362         NULL, ""
 363   };
 364   struct tabentry *tp;
 365
 366   for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
 367     {
 368       if (! strcmp (name,tp->cmd_switch))
 369         break;
 370     }
 371
 372   if (tp->cmd_switch == NULL)
 373     einfo (_("%P%F: unknown architecture: %s\n"), name);
 374
 375   return tp->arch;
 376 }
 377
 378 void
 379 ldfile_add_arch (name)
 380      char *name;
 381 {
 382   search_arch_type *new =
 383     (search_arch_type *) xmalloc ((bfd_size_type) (sizeof (search_arch_type)));
 384
 385   if (*name != '\0')
 386     {
 387       if (ldfile_output_machine_name[0] != '\0')
 388         {
 389           einfo (_("%P%F: target architecture respecified\n"));
 390           return;
 391         }
 392
 393       ldfile_output_machine_name = name;
 394     }
 395
 396   new->next = (search_arch_type *) NULL;
 397   new->name = gnu960_map_archname (name);
 398   *search_arch_tail_ptr = new;
 399   search_arch_tail_ptr = &new->next;
 400 }
 401
 402 #else /* not GNU960 */
 403
 404 void
 405 ldfile_add_arch (in_name)
 406      CONST char *in_name;
 407 {
 408   char *name = buystring (in_name);
 409   search_arch_type *new =
 410     (search_arch_type *) xmalloc (sizeof (search_arch_type));
 411
 412   ldfile_output_machine_name = in_name;
 413
 414   new->name = name;
 415   new->next = (search_arch_type *) NULL;
 416   while (*name)
 417     {
 418       if (isupper ((unsigned char) *name))
 419         *name = tolower ((unsigned char) *name);
 420       name++;
 421     }
 422   *search_arch_tail_ptr = new;
 423   search_arch_tail_ptr = &new->next;
 424
 425 }
 426 #endif
 427
 428 /* Set the output architecture.  */
 429
 430 void
 431 ldfile_set_output_arch (string)
 432      CONST char *string;
 433 {
 434   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 435
 436   if (arch)
 437     {
 438       ldfile_output_architecture = arch->arch;
 439       ldfile_output_machine = arch->mach;
 440       ldfile_output_machine_name = arch->printable_name;
 441     }
 442   else
 443     {
 444       einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 445     }
 446 }