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