2009-04-11 H.J. Lu <hongjiu.lu@intel.com>
[external/binutils.git] / ld / ldfile.c
1 /* Linker file opening and searching.
2    Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
3    2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
4
5    This file is part of the GNU Binutils.
6
7    This program 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 3 of the License, or
10    (at your option) any later version.
11
12    This program 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 this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "safe-ctype.h"
26 #include "ld.h"
27 #include "ldmisc.h"
28 #include "ldexp.h"
29 #include "ldlang.h"
30 #include "ldfile.h"
31 #include "ldmain.h"
32 #include <ldgram.h>
33 #include "ldlex.h"
34 #include "ldemul.h"
35 #include "libiberty.h"
36 #include "filenames.h"
37
38 const char * ldfile_input_filename;
39 bfd_boolean  ldfile_assumed_script = FALSE;
40 const char * ldfile_output_machine_name = "";
41 unsigned long ldfile_output_machine;
42 enum bfd_architecture ldfile_output_architecture;
43 search_dirs_type * search_head;
44
45 #ifdef VMS
46 static char * slash = "";
47 #else
48 #if defined (_WIN32) && ! defined (__CYGWIN32__)
49 static char * slash = "\\";
50 #else
51 static char * slash = "/";
52 #endif
53 #endif
54
55 typedef struct search_arch
56 {
57   char *name;
58   struct search_arch *next;
59 } search_arch_type;
60
61 static search_dirs_type **search_tail_ptr = &search_head;
62 static search_arch_type *search_arch_head;
63 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
64
65 /* Test whether a pathname, after canonicalization, is the same or a
66    sub-directory of the sysroot directory.  */
67
68 static bfd_boolean
69 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
70 {
71   char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
72   int len;
73   bfd_boolean result;
74
75   if (! realname)
76     return FALSE;
77
78   len = strlen (realname);
79
80   if (((! notsame && len == ld_canon_sysroot_len)
81        || (len >= ld_canon_sysroot_len
82            && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
83            && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
84       && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
85     result = TRUE;
86   else
87     result = FALSE;
88
89   if (realname)
90     free (realname);
91
92   return result;
93 }
94
95 /* Adds NAME to the library search path.
96    Makes a copy of NAME using xmalloc().  */
97
98 void
99 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
100 {
101   search_dirs_type *new;
102
103   if (!cmdline && config.only_cmd_line_lib_dirs)
104     return;
105
106   new = xmalloc (sizeof (search_dirs_type));
107   new->next = NULL;
108   new->cmdline = cmdline;
109   *search_tail_ptr = new;
110   search_tail_ptr = &new->next;
111
112   /* If a directory is marked as honoring sysroot, prepend the sysroot path
113      now.  */
114   if (name[0] == '=')
115     {
116       new->name = concat (ld_sysroot, name + 1, (const char *) NULL);
117       new->sysrooted = TRUE;
118     }
119   else
120     {
121       new->name = xstrdup (name);
122       new->sysrooted = is_sysrooted_pathname (name, FALSE);
123     }
124 }
125
126 /* Try to open a BFD for a lang_input_statement.  */
127
128 bfd_boolean
129 ldfile_try_open_bfd (const char *attempt,
130                      lang_input_statement_type *entry)
131 {
132   entry->the_bfd = bfd_openr (attempt, entry->target);
133
134   if (trace_file_tries)
135     {
136       if (entry->the_bfd == NULL)
137         info_msg (_("attempt to open %s failed\n"), attempt);
138       else
139         info_msg (_("attempt to open %s succeeded\n"), attempt);
140     }
141
142   if (entry->the_bfd == NULL)
143     {
144       if (bfd_get_error () == bfd_error_invalid_target)
145         einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
146       return FALSE;
147     }
148
149   /* If we are searching for this file, see if the architecture is
150      compatible with the output file.  If it isn't, keep searching.
151      If we can't open the file as an object file, stop the search
152      here.  If we are statically linking, ensure that we don't link
153      a dynamic object.  */
154
155   if (entry->search_dirs_flag || !entry->dynamic)
156     {
157       bfd *check;
158
159       if (bfd_check_format (entry->the_bfd, bfd_archive))
160         check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
161       else
162         check = entry->the_bfd;
163
164       if (check != NULL)
165         {
166           if (! bfd_check_format (check, bfd_object))
167             {
168               if (check == entry->the_bfd
169                   && entry->search_dirs_flag
170                   && bfd_get_error () == bfd_error_file_not_recognized
171                   && ! ldemul_unrecognized_file (entry))
172                 {
173                   int token, skip = 0;
174                   char *arg, *arg1, *arg2, *arg3;
175                   extern FILE *yyin;
176
177                   /* Try to interpret the file as a linker script.  */
178                   ldfile_open_command_file (attempt);
179
180                   ldfile_assumed_script = TRUE;
181                   parser_input = input_selected;
182                   ldlex_both ();
183                   token = INPUT_SCRIPT;
184                   while (token != 0)
185                     {
186                       switch (token)
187                         {
188                         case OUTPUT_FORMAT:
189                           if ((token = yylex ()) != '(')
190                             continue;
191                           if ((token = yylex ()) != NAME)
192                             continue;
193                           arg1 = yylval.name;
194                           arg2 = NULL;
195                           arg3 = NULL;
196                           token = yylex ();
197                           if (token == ',')
198                             {
199                               if ((token = yylex ()) != NAME)
200                                 {
201                                   free (arg1);
202                                   continue;
203                                 }
204                               arg2 = yylval.name;
205                               if ((token = yylex ()) != ','
206                                   || (token = yylex ()) != NAME)
207                                 {
208                                   free (arg1);
209                                   free (arg2);
210                                   continue;
211                                 }
212                               arg3 = yylval.name;
213                               token = yylex ();
214                             }
215                           if (token == ')')
216                             {
217                               switch (command_line.endian)
218                                 {
219                                 default:
220                                 case ENDIAN_UNSET:
221                                   arg = arg1; break;
222                                 case ENDIAN_BIG:
223                                   arg = arg2 ? arg2 : arg1; break;
224                                 case ENDIAN_LITTLE:
225                                   arg = arg3 ? arg3 : arg1; break;
226                                 }
227                               if (strcmp (arg, lang_get_output_target ()) != 0)
228                                 skip = 1;
229                             }
230                           free (arg1);
231                           if (arg2) free (arg2);
232                           if (arg3) free (arg3);
233                           break;
234                         case NAME:
235                         case LNAME:
236                         case VERS_IDENTIFIER:
237                         case VERS_TAG:
238                           free (yylval.name);
239                           break;
240                         case INT:
241                           if (yylval.bigint.str)
242                             free (yylval.bigint.str);
243                           break;
244                         }
245                       token = yylex ();
246                     }
247                   ldlex_popstate ();
248                   ldfile_assumed_script = FALSE;
249                   fclose (yyin);
250                   yyin = NULL;
251                   if (skip)
252                     {
253                       if (command_line.warn_search_mismatch)
254                         einfo (_("%P: skipping incompatible %s "
255                                  "when searching for %s\n"),
256                                attempt, entry->local_sym_name);
257                       bfd_close (entry->the_bfd);
258                       entry->the_bfd = NULL;
259                       return FALSE;
260                     }
261                 }
262               return TRUE;
263             }
264
265           if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
266             {
267               einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
268                      attempt);
269               bfd_close (entry->the_bfd);
270               entry->the_bfd = NULL;
271               return FALSE;
272             }
273
274           if (entry->search_dirs_flag
275               && !bfd_arch_get_compatible (check, link_info.output_bfd,
276                                            command_line.accept_unknown_input_arch)
277               /* XCOFF archives can have 32 and 64 bit objects.  */
278               && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
279                     && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
280                     && bfd_check_format (entry->the_bfd, bfd_archive)))
281             {
282               if (command_line.warn_search_mismatch)
283                 einfo (_("%P: skipping incompatible %s "
284                          "when searching for %s\n"),
285                        attempt, entry->local_sym_name);
286               bfd_close (entry->the_bfd);
287               entry->the_bfd = NULL;
288               return FALSE;
289             }
290         }
291     }
292
293   return TRUE;
294 }
295
296 /* Search for and open the file specified by ENTRY.  If it is an
297    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
298
299 bfd_boolean
300 ldfile_open_file_search (const char *arch,
301                          lang_input_statement_type *entry,
302                          const char *lib,
303                          const char *suffix)
304 {
305   search_dirs_type *search;
306
307   /* If this is not an archive, try to open it in the current
308      directory first.  */
309   if (! entry->is_archive)
310     {
311       if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
312         {
313           char *name = concat (ld_sysroot, entry->filename,
314                                (const char *) NULL);
315           if (ldfile_try_open_bfd (name, entry))
316             {
317               entry->filename = name;
318               return TRUE;
319             }
320           free (name);
321         }
322       else if (ldfile_try_open_bfd (entry->filename, entry))
323         {
324           entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
325             && is_sysrooted_pathname (entry->filename, TRUE);
326           return TRUE;
327         }
328
329       if (IS_ABSOLUTE_PATH (entry->filename))
330         return FALSE;
331     }
332
333   for (search = search_head; search != NULL; search = search->next)
334     {
335       char *string;
336
337       if (entry->dynamic && ! link_info.relocatable)
338         {
339           if (ldemul_open_dynamic_archive (arch, search, entry))
340             {
341               entry->sysrooted = search->sysrooted;
342               return TRUE;
343             }
344         }
345
346       if (entry->is_archive)
347         string = concat (search->name, slash, lib, entry->filename,
348                          arch, suffix, (const char *) NULL);
349       else
350         string = concat (search->name, slash, entry->filename,
351                          (const char *) 0);
352
353       if (ldfile_try_open_bfd (string, entry))
354         {
355           entry->filename = string;
356           entry->sysrooted = search->sysrooted;
357           return TRUE;
358         }
359
360       free (string);
361     }
362
363   return FALSE;
364 }
365
366 /* Open the input file specified by ENTRY.  */
367
368 void
369 ldfile_open_file (lang_input_statement_type *entry)
370 {
371   if (entry->the_bfd != NULL)
372     return;
373
374   if (! entry->search_dirs_flag)
375     {
376       if (ldfile_try_open_bfd (entry->filename, entry))
377         return;
378       if (strcmp (entry->filename, entry->local_sym_name) != 0)
379         einfo (_("%F%P: %s (%s): No such file: %E\n"),
380                entry->filename, entry->local_sym_name);
381       else
382         einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
383     }
384   else
385     {
386       search_arch_type *arch;
387       bfd_boolean found = FALSE;
388
389       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
390       for (arch = search_arch_head; arch != NULL; arch = arch->next)
391         {
392           found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
393           if (found)
394             break;
395 #ifdef VMS
396           found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
397           if (found)
398             break;
399 #endif
400           found = ldemul_find_potential_libraries (arch->name, entry);
401           if (found)
402             break;
403         }
404
405       /* If we have found the file, we don't need to search directories
406          again.  */
407       if (found)
408         entry->search_dirs_flag = FALSE;
409       else if (entry->sysrooted
410                && ld_sysroot
411                && IS_ABSOLUTE_PATH (entry->local_sym_name))
412         einfo (_("%F%P: cannot find %s inside %s\n"),
413                entry->local_sym_name, ld_sysroot);
414       else
415         einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
416     }
417 }
418
419 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
420
421 static FILE *
422 try_open (const char *name, const char *exten)
423 {
424   FILE *result;
425
426   result = fopen (name, "r");
427
428   if (trace_file_tries)
429     {
430       if (result == NULL)
431         info_msg (_("cannot find script file %s\n"), name);
432       else
433         info_msg (_("opened script file %s\n"), name);
434     }
435
436   if (result != NULL)
437     return result;
438
439   if (*exten)
440     {
441       char *buff;
442
443       buff = concat (name, exten, (const char *) NULL);
444       result = fopen (buff, "r");
445
446       if (trace_file_tries)
447         {
448           if (result == NULL)
449             info_msg (_("cannot find script file %s\n"), buff);
450           else
451             info_msg (_("opened script file %s\n"), buff);
452         }
453       free (buff);
454     }
455
456   return result;
457 }
458
459 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
460
461 static bfd_boolean
462 check_for_scripts_dir (char *dir)
463 {
464   char *buf;
465   struct stat s;
466   bfd_boolean res;
467
468   buf = concat (dir, "/ldscripts", (const char *) NULL);
469   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
470   free (buf);
471   return res;
472 }
473
474 /* Return the default directory for finding script files.
475    We look for the "ldscripts" directory in:
476
477    SCRIPTDIR (passed from Makefile)
478              (adjusted according to the current location of the binary)
479    SCRIPTDIR (passed from Makefile)
480    the dir where this program is (for using it from the build tree)
481    the dir where this program is/../lib
482              (for installing the tool suite elsewhere).  */
483
484 static char *
485 find_scripts_dir (void)
486 {
487   char *end, *dir;
488   size_t dirlen;
489
490   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
491   if (dir)
492     {
493       if (check_for_scripts_dir (dir))
494         return dir;
495       free (dir);
496     }
497
498   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
499   if (dir)
500     {
501       if (check_for_scripts_dir (dir))
502         return dir;
503       free (dir);
504     }
505
506   if (check_for_scripts_dir (SCRIPTDIR))
507     /* We've been installed normally.  */
508     return SCRIPTDIR;
509
510   /* Look for "ldscripts" in the dir where our binary is.  */
511   end = strrchr (program_name, '/');
512 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
513   {
514     /* We could have \foo\bar, or /foo\bar.  */
515     char *bslash = strrchr (program_name, '\\');
516
517     if (end == NULL || (bslash != NULL && bslash > end))
518       end = bslash;
519   }
520 #endif
521
522   if (end == NULL)
523     /* Don't look for ldscripts in the current directory.  There is
524        too much potential for confusion.  */
525     return NULL;
526
527   dirlen = end - program_name;
528   /* Make a copy of program_name in dir.
529      Leave room for later "/../lib".  */
530   dir = xmalloc (dirlen + sizeof ("/../lib"));
531   strncpy (dir, program_name, dirlen);
532   dir[dirlen] = '\0';
533
534   if (check_for_scripts_dir (dir))
535     return dir;
536
537   /* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
538   strcpy (dir + dirlen, "/../lib");
539   if (check_for_scripts_dir (dir))
540     return dir;
541   free (dir);
542   return NULL;
543 }
544
545 /* Try to open NAME; if that fails, look for it in directories specified
546    with -L, then in the default script directory, without and with EXTEND
547    appended.  If DEFAULT_ONLY is true, the search is restricted to the
548    default script location.  */
549
550 static FILE *
551 ldfile_find_command_file (const char *name, const char *extend,
552                           bfd_boolean default_only)
553 {
554   search_dirs_type *search;
555   FILE *result = NULL;
556   char *buffer;
557   static search_dirs_type *script_search;
558
559   /* First try raw name for uninstalled linker.  */
560   result = try_open (name, "");
561   if (result != NULL)
562     return result;
563
564   if (!script_search)
565     {
566       char *script_dir = find_scripts_dir ();
567       if (script_dir)
568         {
569           search_dirs_type **save_tail_ptr = search_tail_ptr;
570           search_tail_ptr = &script_search;
571           ldfile_add_library_path (script_dir, TRUE);
572           search_tail_ptr = save_tail_ptr;
573         }
574     }
575
576   /* Temporarily append script_search to the path list so that the
577      paths specified with -L will be searched first.  */
578   *search_tail_ptr = script_search;
579
580   /* Try now prefixes.  */
581   for (search = default_only ? script_search : search_head;
582        search != NULL;
583        search = search->next)
584     {
585       buffer = concat (search->name, slash, name, (const char *) NULL);
586       result = try_open (buffer, extend);
587       free (buffer);
588       if (result)
589         break;
590     }
591
592   /* Restore the original path list.  */
593   *search_tail_ptr = NULL;
594
595   return result;
596 }
597
598 /* Open command file NAME.  */
599
600 static void
601 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
602 {
603   FILE *ldlex_input_stack;
604   ldlex_input_stack = ldfile_find_command_file (name, "", default_only);
605
606   if (ldlex_input_stack == NULL)
607     {
608       bfd_set_error (bfd_error_system_call);
609       einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
610     }
611
612   lex_push_file (ldlex_input_stack, name);
613
614   ldfile_input_filename = name;
615   lineno = 1;
616
617   saved_script_handle = ldlex_input_stack;
618 }
619
620 /* Open command file NAME in the current directory, -L directories,
621    the default script location, in that order.  */
622
623 void
624 ldfile_open_command_file (const char *name)
625 {
626   ldfile_open_command_file_1 (name, FALSE);
627 }
628
629 /* Open command file NAME at the default script location.  */
630
631 void
632 ldfile_open_default_command_file (const char *name)
633 {
634   ldfile_open_command_file_1 (name, TRUE);
635 }
636
637 void
638 ldfile_add_arch (const char *in_name)
639 {
640   char *name = xstrdup (in_name);
641   search_arch_type *new = xmalloc (sizeof (search_arch_type));
642
643   ldfile_output_machine_name = in_name;
644
645   new->name = name;
646   new->next = NULL;
647   while (*name)
648     {
649       *name = TOLOWER (*name);
650       name++;
651     }
652   *search_arch_tail_ptr = new;
653   search_arch_tail_ptr = &new->next;
654
655 }
656
657 /* Set the output architecture.  */
658
659 void
660 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
661 {
662   const bfd_arch_info_type *arch = bfd_scan_arch (string);
663
664   if (arch)
665     {
666       ldfile_output_architecture = arch->arch;
667       ldfile_output_machine = arch->mach;
668       ldfile_output_machine_name = arch->printable_name;
669     }
670   else if (defarch != bfd_arch_unknown)
671     ldfile_output_architecture = defarch;
672   else
673     einfo (_("%P%F: cannot represent machine `%s'\n"), string);
674 }