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 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   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 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             return true;
 135
 136           if ((bfd_arch_get_compatible (check, output_bfd) == NULL)
 137               /* XCOFF archives can have 32 and 64 bit objects */
 138               && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
 139                     && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
 140                     && bfd_check_format (entry->the_bfd, bfd_archive)))
 141             {
 142               einfo (_("%P: skipping incompatible %s when searching for %s\n"),
 143                      attempt, entry->local_sym_name);
 144               bfd_close (entry->the_bfd);
 145               entry->the_bfd = NULL;
 146               return false;
 147             }
 148         }
 149     }
 150
 151   return true;
 152 }
 153
 154 /* Search for and open the file specified by ENTRY.  If it is an
 155    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 156
 157 boolean
 158 ldfile_open_file_search (arch, entry, lib, suffix)
 159      const char *arch;
 160      lang_input_statement_type *entry;
 161      const char *lib;
 162      const char *suffix;
 163 {
 164   search_dirs_type *search;
 165
 166   /* If this is not an archive, try to open it in the current
 167      directory first.  */
 168   if (! entry->is_archive)
 169     {
 170       if (ldfile_try_open_bfd (entry->filename, entry))
 171         return true;
 172     }
 173
 174   for (search = search_head;
 175        search != (search_dirs_type *) NULL;
 176        search = search->next)
 177     {
 178       char *string;
 179
 180       if (entry->dynamic && ! link_info.relocateable)
 181         {
 182           if (ldemul_open_dynamic_archive (arch, search, entry))
 183             return true;
 184         }
 185
 186       string = (char *) xmalloc (strlen (search->name)
 187                                  + strlen (slash)
 188                                  + strlen (lib)
 189                                  + strlen (entry->filename)
 190                                  + strlen (arch)
 191                                  + strlen (suffix)
 192                                  + 1);
 193
 194       if (entry->is_archive)
 195         sprintf (string, "%s%s%s%s%s%s", search->name, slash,
 196                  lib, entry->filename, arch, suffix);
 197       else if (entry->filename[0] == '/' || entry->filename[0] == '.'
 198 #if defined (__MSDOS__) || defined (_WIN32)
 199                || entry->filename[0] == '\\'
 200                || (ISALPHA (entry->filename[0])
 201                    && entry->filename[1] == ':')
 202 #endif
 203           )
 204         strcpy (string, entry->filename);
 205       else
 206         sprintf (string, "%s%s%s", search->name, slash, entry->filename);
 207
 208       if (ldfile_try_open_bfd (string, entry))
 209         {
 210           entry->filename = string;
 211           return true;
 212         }
 213
 214       free (string);
 215     }
 216
 217   return false;
 218 }
 219
 220 /* Open the input file specified by ENTRY.  */
 221
 222 void
 223 ldfile_open_file (entry)
 224      lang_input_statement_type *entry;
 225 {
 226   if (entry->the_bfd != NULL)
 227     return;
 228
 229   if (! entry->search_dirs_flag)
 230     {
 231       if (ldfile_try_open_bfd (entry->filename, entry))
 232         return;
 233       if (strcmp (entry->filename, entry->local_sym_name) != 0)
 234         einfo (_("%F%P: cannot open %s for %s: %E\n"),
 235                entry->filename, entry->local_sym_name);
 236       else
 237         einfo (_("%F%P: cannot open %s: %E\n"), entry->local_sym_name);
 238     }
 239   else
 240     {
 241       search_arch_type *arch;
 242       boolean found = false;
 243
 244       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 245       for (arch = search_arch_head;
 246            arch != (search_arch_type *) NULL;
 247            arch = arch->next)
 248         {
 249           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 250           if (found)
 251             break;
 252 #ifdef VMS
 253           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 254           if (found)
 255             break;
 256 #endif
 257           found = ldemul_find_potential_libraries (arch->name, entry);
 258           if (found)
 259             break;
 260         }
 261
 262       /* If we have found the file, we don't need to search directories
 263          again.  */
 264       if (found)
 265         entry->search_dirs_flag = false;
 266       else
 267         einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
 268     }
 269 }
 270
 271 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 272
 273 static FILE *
 274 try_open (name, exten)
 275      const char *name;
 276      const char *exten;
 277 {
 278   FILE *result;
 279   char buff[1000];
 280
 281   result = fopen (name, "r");
 282
 283   if (trace_file_tries)
 284     {
 285       if (result == NULL)
 286         info_msg (_("cannot find script file %s\n"), name);
 287       else
 288         info_msg (_("opened script file %s\n"), name);
 289     }
 290
 291   if (result != NULL)
 292     return result;
 293
 294   if (*exten)
 295     {
 296       sprintf (buff, "%s%s", name, exten);
 297       result = fopen (buff, "r");
 298
 299       if (trace_file_tries)
 300         {
 301           if (result == NULL)
 302             info_msg (_("cannot find script file %s\n"), buff);
 303           else
 304             info_msg (_("opened script file %s\n"), buff);
 305         }
 306     }
 307
 308   return result;
 309 }
 310
 311 /* Try to open NAME; if that fails, look for it in any directories
 312    specified with -L, without and with EXTEND apppended.  */
 313
 314 FILE *
 315 ldfile_find_command_file (name, extend)
 316      const char *name;
 317      const char *extend;
 318 {
 319   search_dirs_type *search;
 320   FILE *result;
 321   char buffer[1000];
 322
 323   /* First try raw name.  */
 324   result = try_open (name, "");
 325   if (result == (FILE *) NULL)
 326     {
 327       /* Try now prefixes.  */
 328       for (search = search_head;
 329            search != (search_dirs_type *) NULL;
 330            search = search->next)
 331         {
 332           sprintf (buffer, "%s%s%s", search->name, slash, name);
 333
 334           result = try_open (buffer, extend);
 335           if (result)
 336             break;
 337         }
 338     }
 339
 340   return result;
 341 }
 342
 343 void
 344 ldfile_open_command_file (name)
 345      const char *name;
 346 {
 347   FILE *ldlex_input_stack;
 348   ldlex_input_stack = ldfile_find_command_file (name, "");
 349
 350   if (ldlex_input_stack == (FILE *) NULL)
 351     {
 352       bfd_set_error (bfd_error_system_call);
 353       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 354     }
 355
 356   lex_push_file (ldlex_input_stack, name);
 357
 358   ldfile_input_filename = name;
 359   lineno = 1;
 360
 361   saved_script_handle = ldlex_input_stack;
 362 }
 363
 364 #ifdef GNU960
 365 static char *
 366 gnu960_map_archname (name)
 367      char *name;
 368 {
 369   struct tabentry { char *cmd_switch; char *arch; };
 370   static struct tabentry arch_tab[] =
 371   {
 372         "",   "",
 373         "KA", "ka",
 374         "KB", "kb",
 375         "KC", "mc",     /* Synonym for MC */
 376         "MC", "mc",
 377         "CA", "ca",
 378         "SA", "ka",     /* Functionally equivalent to KA */
 379         "SB", "kb",     /* Functionally equivalent to KB */
 380         NULL, ""
 381   };
 382   struct tabentry *tp;
 383
 384   for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
 385     {
 386       if (! strcmp (name,tp->cmd_switch))
 387         break;
 388     }
 389
 390   if (tp->cmd_switch == NULL)
 391     einfo (_("%P%F: unknown architecture: %s\n"), name);
 392
 393   return tp->arch;
 394 }
 395
 396 void
 397 ldfile_add_arch (name)
 398      char *name;
 399 {
 400   search_arch_type *new =
 401     (search_arch_type *) xmalloc ((bfd_size_type) (sizeof (search_arch_type)));
 402
 403   if (*name != '\0')
 404     {
 405       if (ldfile_output_machine_name[0] != '\0')
 406         {
 407           einfo (_("%P%F: target architecture respecified\n"));
 408           return;
 409         }
 410
 411       ldfile_output_machine_name = name;
 412     }
 413
 414   new->next = (search_arch_type *) NULL;
 415   new->name = gnu960_map_archname (name);
 416   *search_arch_tail_ptr = new;
 417   search_arch_tail_ptr = &new->next;
 418 }
 419
 420 #else /* not GNU960 */
 421
 422 void
 423 ldfile_add_arch (in_name)
 424      const char *in_name;
 425 {
 426   char *name = xstrdup (in_name);
 427   search_arch_type *new =
 428     (search_arch_type *) xmalloc (sizeof (search_arch_type));
 429
 430   ldfile_output_machine_name = in_name;
 431
 432   new->name = name;
 433   new->next = (search_arch_type *) NULL;
 434   while (*name)
 435     {
 436       *name = TOLOWER (*name);
 437       name++;
 438     }
 439   *search_arch_tail_ptr = new;
 440   search_arch_tail_ptr = &new->next;
 441
 442 }
 443 #endif
 444
 445 /* Set the output architecture.  */
 446
 447 void
 448 ldfile_set_output_arch (string)
 449      const char *string;
 450 {
 451   const bfd_arch_info_type *arch = bfd_scan_arch (string);
 452
 453   if (arch)
 454     {
 455       ldfile_output_architecture = arch->arch;
 456       ldfile_output_machine = arch->mach;
 457       ldfile_output_machine_name = arch->printable_name;
 458     }
 459   else
 460     {
 461       einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 462     }
 463 }