ld/ldfile.c

   1 /* Linker file opening and searching.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001
   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 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       boolean found = false;
 235
 236       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 237       for (arch = search_arch_head;
 238            arch != (search_arch_type *) NULL;
 239            arch = arch->next)
 240         {
 241           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 242           if (found)
 243             break;
 244 #ifdef VMS
 245           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 246           if (found)
 247             break;
 248 #endif
 249           found = ldemul_find_potential_libraries (arch->name, entry);
 250           if (found)
 251             break;
 252         }
 253
 254       /* If we have found the file, we don't need to search directories
 255          again.  */
 256       if (found)
 257         entry->search_dirs_flag = false;
 258       else
 259         einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
 260     }
 261 }
 262
 263 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 264
 265 static FILE *
 266 try_open (name, exten)
 267      const char *name;
 268      const char *exten;
 269 {
 270   FILE *result;
 271   char buff[1000];
 272
 273   result = fopen (name, "r");
 274
 275   if (trace_file_tries)
 276     {
 277       if (result == NULL)
 278         info_msg (_("cannot find script file %s\n"), name);
 279       else
 280         info_msg (_("opened script file %s\n"), name);
 281     }
 282
 283   if (result != NULL)
 284     return result;
 285
 286   if (*exten)
 287     {
 288       sprintf (buff, "%s%s", name, exten);
 289       result = fopen (buff, "r");
 290
 291       if (trace_file_tries)
 292         {
 293           if (result == NULL)
 294             info_msg (_("cannot find script file %s\n"), buff);
 295           else
 296             info_msg (_("opened script file %s\n"), buff);
 297         }
 298     }
 299
 300   return result;
 301 }
 302
 303 /* Try to open NAME; if that fails, look for it in any directories
 304    specified with -L, without and with EXTEND apppended.  */
 305
 306 FILE *
 307 ldfile_find_command_file (name, extend)
 308      const char *name;
 309      const char *extend;
 310 {
 311   search_dirs_type *search;
 312   FILE *result;
 313   char buffer[1000];
 314
 315   /* First try raw name.  */
 316   result = try_open (name, "");
 317   if (result == (FILE *) NULL)
 318     {
 319       /* Try now prefixes.  */
 320       for (search = search_head;
 321            search != (search_dirs_type *) NULL;
 322            search = search->next)
 323         {
 324           sprintf (buffer, "%s%s%s", search->name, slash, name);
 325
 326           result = try_open (buffer, extend);
 327           if (result)
 328             break;
 329         }
 330     }
 331
 332   return result;
 333 }
 334
 335 void
 336 ldfile_open_command_file (name)
 337      const char *name;
 338 {
 339   FILE *ldlex_input_stack;
 340   ldlex_input_stack = ldfile_find_command_file (name, "");
 341
 342   if (ldlex_input_stack == (FILE *) NULL)
 343     {
 344       bfd_set_error (bfd_error_system_call);
 345       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 346     }
 347
 348   lex_push_file (ldlex_input_stack, name);
 349
 350   ldfile_input_filename = name;
 351   lineno = 1;
 352
 353   saved_script_handle = ldlex_input_stack;
 354 }
 355
 356 #ifdef GNU960
 357 static char *
 358 gnu960_map_archname (name)
 359      char *name;
 360 {
 361   struct tabentry { char *cmd_switch; char *arch; };
 362   static struct tabentry arch_tab[] =
 363   {
 364         "",   "",
 365         "KA", "ka",
 366         "KB", "kb",
 367         "KC", "mc",     /* Synonym for MC */
 368         "MC", "mc",
 369         "CA", "ca",
 370         "SA", "ka",     /* Functionally equivalent to KA */
 371         "SB", "kb",     /* Functionally equivalent to KB */
 372         NULL, ""
 373   };
 374   struct tabentry *tp;
 375
 376   for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
 377     {
 378       if (! strcmp (name,tp->cmd_switch))
 379         break;
 380     }
 381
 382   if (tp->cmd_switch == NULL)
 383     einfo (_("%P%F: unknown architecture: %s\n"), name);
 384
 385   return tp->arch;
 386 }
 387
 388 void
 389 ldfile_add_arch (name)
 390      char *name;
 391 {
 392   search_arch_type *new =
 393     (search_arch_type *) xmalloc ((bfd_size_type) (sizeof (search_arch_type)));
 394
 395   if (*name != '\0')
 396     {
 397       if (ldfile_output_machine_name[0] != '\0')
 398         {
 399           einfo (_("%P%F: target architecture respecified\n"));
 400           return;
 401         }
 402
 403       ldfile_output_machine_name = name;
 404     }
 405
 406   new->next = (search_arch_type *) NULL;
 407   new->name = gnu960_map_archname (name);
 408   *search_arch_tail_ptr = new;
 409   search_arch_tail_ptr = &new->next;
 410 }
 411
 412 #else /* not GNU960 */
 413
 414 void
 415 ldfile_add_arch (in_name)
 416      CONST char *in_name;
 417 {
 418   char *name = xstrdup (in_name);
 419   search_arch_type *new =
 420     (search_arch_type *) xmalloc (sizeof (search_arch_type));
 421
 422   ldfile_output_machine_name = in_name;
 423
 424   new->name = name;
 425   new->next = (search_arch_type *) NULL;
 426   while (*name)
 427     {
 428       *name = TOLOWER (*name);
 429       name++;
 430     }
 431   *search_arch_tail_ptr = new;
 432   search_arch_tail_ptr = &new->next;
 433
 434 }
 435 #endif
 436
 437 /* Set the output architecture.  */
 438
 439 void
 440 ldfile_set_output_arch (string)
 441      CONST char *string;
 442 {
 443   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 444
 445   if (arch)
 446     {
 447       ldfile_output_architecture = arch->arch;
 448       ldfile_output_machine = arch->mach;
 449       ldfile_output_machine_name = arch->printable_name;
 450     }
 451   else
 452     {
 453       einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 454     }
 455 }