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