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