ld: Restore file offset after a plugin fails to claim a file
[external/binutils.git] / ld / plugin.c
1 /* Plugin control for the GNU linker.
2    Copyright (C) 2010-2016 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 "libiberty.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "bfdver.h"
26 #include "ld.h"
27 #include "ldmain.h"
28 #include "ldmisc.h"
29 #include "ldexp.h"
30 #include "ldlang.h"
31 #include "ldfile.h"
32 #include "plugin-api.h"
33 #include "../bfd/plugin.h"
34 #include "plugin.h"
35 #include "elf-bfd.h"
36 #if HAVE_MMAP
37 # include <sys/mman.h>
38 # ifndef MAP_FAILED
39 #  define MAP_FAILED ((void *) -1)
40 # endif
41 # ifndef PROT_READ
42 #  define PROT_READ 0
43 # endif
44 # ifndef MAP_PRIVATE
45 #  define MAP_PRIVATE 0
46 # endif
47 #endif
48 #include <errno.h>
49 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO))
50 extern int errno;
51 #endif
52 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
53 #include <windows.h>
54 #endif
55
56 /* Report plugin symbols.  */
57 bfd_boolean report_plugin_symbols;
58
59 /* The suffix to append to the name of the real (claimed) object file
60    when generating a dummy BFD to hold the IR symbols sent from the
61    plugin.  For cosmetic use only; appears in maps, crefs etc.  */
62 #define IRONLY_SUFFIX " (symbol from plugin)"
63
64 /* Stores a single argument passed to a plugin.  */
65 typedef struct plugin_arg
66 {
67   struct plugin_arg *next;
68   const char *arg;
69 } plugin_arg_t;
70
71 /* Holds all details of a single plugin.  */
72 typedef struct plugin
73 {
74   /* Next on the list of plugins, or NULL at end of chain.  */
75   struct plugin *next;
76   /* The argument string given to --plugin.  */
77   const char *name;
78   /* The shared library handle returned by dlopen.  */
79   void *dlhandle;
80   /* The list of argument string given to --plugin-opt.  */
81   plugin_arg_t *args;
82   /* Number of args in the list, for convenience.  */
83   size_t n_args;
84   /* The plugin's event handlers.  */
85   ld_plugin_claim_file_handler claim_file_handler;
86   ld_plugin_all_symbols_read_handler all_symbols_read_handler;
87   ld_plugin_cleanup_handler cleanup_handler;
88   /* TRUE if the cleanup handlers have been called.  */
89   bfd_boolean cleanup_done;
90 } plugin_t;
91
92 typedef struct view_buffer
93 {
94   char *addr;
95   size_t filesize;
96   off_t offset;
97 } view_buffer_t;
98
99 /* The internal version of struct ld_plugin_input_file with a BFD
100    pointer.  */
101 typedef struct plugin_input_file
102 {
103   bfd *abfd;
104   view_buffer_t view_buffer;
105   char *name;
106   int fd;
107   bfd_boolean use_mmap;
108   off_t offset;
109   off_t filesize;
110 } plugin_input_file_t;
111
112 /* The master list of all plugins.  */
113 static plugin_t *plugins_list = NULL;
114
115 /* We keep a tail pointer for easy linking on the end.  */
116 static plugin_t **plugins_tail_chain_ptr = &plugins_list;
117
118 /* The last plugin added to the list, for receiving args.  */
119 static plugin_t *last_plugin = NULL;
120
121 /* The tail of the arg chain of the last plugin added to the list.  */
122 static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
123
124 /* The plugin which is currently having a callback executed.  */
125 static plugin_t *called_plugin = NULL;
126
127 /* Last plugin to cause an error, if any.  */
128 static const char *error_plugin = NULL;
129
130 /* State of linker "notice" interface before we poked at it.  */
131 static bfd_boolean orig_notice_all;
132
133 /* Original linker callbacks, and the plugin version.  */
134 static const struct bfd_link_callbacks *orig_callbacks;
135 static struct bfd_link_callbacks plugin_callbacks;
136
137 /* Set at all symbols read time, to avoid recursively offering the plugin
138    its own newly-added input files and libs to claim.  */
139 bfd_boolean no_more_claiming = FALSE;
140
141 #if HAVE_MMAP && HAVE_GETPAGESIZE
142 /* Page size used by mmap.  */
143 static off_t plugin_pagesize;
144 #endif
145
146 /* List of tags to set in the constant leading part of the tv array. */
147 static const enum ld_plugin_tag tv_header_tags[] =
148 {
149   LDPT_MESSAGE,
150   LDPT_API_VERSION,
151   LDPT_GNU_LD_VERSION,
152   LDPT_LINKER_OUTPUT,
153   LDPT_OUTPUT_NAME,
154   LDPT_REGISTER_CLAIM_FILE_HOOK,
155   LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
156   LDPT_REGISTER_CLEANUP_HOOK,
157   LDPT_ADD_SYMBOLS,
158   LDPT_GET_INPUT_FILE,
159   LDPT_GET_VIEW,
160   LDPT_RELEASE_INPUT_FILE,
161   LDPT_GET_SYMBOLS,
162   LDPT_GET_SYMBOLS_V2,
163   LDPT_ADD_INPUT_FILE,
164   LDPT_ADD_INPUT_LIBRARY,
165   LDPT_SET_EXTRA_LIBRARY_PATH
166 };
167
168 /* How many entries in the constant leading part of the tv array.  */
169 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
170
171 /* Forward references.  */
172 static bfd_boolean plugin_notice (struct bfd_link_info *,
173                                   struct bfd_link_hash_entry *,
174                                   struct bfd_link_hash_entry *,
175                                   bfd *, asection *, bfd_vma, flagword);
176
177 static const bfd_target * plugin_object_p (bfd *);
178
179 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
180
181 #define RTLD_NOW 0      /* Dummy value.  */
182
183 static void *
184 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
185 {
186   return LoadLibrary (file);
187 }
188
189 static void *
190 dlsym (void *handle, const char *name)
191 {
192   return GetProcAddress (handle, name);
193 }
194
195 static int
196 dlclose (void *handle)
197 {
198   FreeLibrary (handle);
199   return 0;
200 }
201
202 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)  */
203
204 #ifndef HAVE_DLFCN_H
205 static const char *
206 dlerror (void)
207 {
208   return "";
209 }
210 #endif
211
212 /* Helper function for exiting with error status.  */
213 static int
214 set_plugin_error (const char *plugin)
215 {
216   error_plugin = plugin;
217   return -1;
218 }
219
220 /* Test if an error occurred.  */
221 static bfd_boolean
222 plugin_error_p (void)
223 {
224   return error_plugin != NULL;
225 }
226
227 /* Return name of plugin which caused an error if any.  */
228 const char *
229 plugin_error_plugin (void)
230 {
231   return error_plugin ? error_plugin : _("<no plugin>");
232 }
233
234 /* Handle -plugin arg: find and load plugin, or return error.  */
235 void
236 plugin_opt_plugin (const char *plugin)
237 {
238   plugin_t *newplug;
239   plugin_t *curplug = plugins_list;
240
241   newplug = xmalloc (sizeof *newplug);
242   memset (newplug, 0, sizeof *newplug);
243   newplug->name = plugin;
244   newplug->dlhandle = dlopen (plugin, RTLD_NOW);
245   if (!newplug->dlhandle)
246     einfo (_("%P%F: %s: error loading plugin: %s\n"), plugin, dlerror ());
247
248   /* Check if plugin has been loaded already.  */
249   while (curplug)
250     {
251       if (newplug->dlhandle == curplug->dlhandle)
252         {
253           einfo (_("%P: %s: duplicated plugin\n"), plugin);
254           free (newplug);
255           return;
256         }
257       curplug = curplug->next;
258     }
259
260   /* Chain on end, so when we run list it is in command-line order.  */
261   *plugins_tail_chain_ptr = newplug;
262   plugins_tail_chain_ptr = &newplug->next;
263
264   /* Record it as current plugin for receiving args.  */
265   last_plugin = newplug;
266   last_plugin_args_tail_chain_ptr = &newplug->args;
267 }
268
269 /* Accumulate option arguments for last-loaded plugin, or return
270    error if none.  */
271 int
272 plugin_opt_plugin_arg (const char *arg)
273 {
274   plugin_arg_t *newarg;
275
276   if (!last_plugin)
277     return set_plugin_error (_("<no plugin>"));
278
279   /* Ignore -pass-through= from GCC driver.  */
280   if (*arg == '-')
281     {
282       const char *p = arg + 1;
283
284       if (*p == '-')
285         ++p;
286       if (strncmp (p, "pass-through=", 13) == 0)
287         return 0;
288     }
289
290   newarg = xmalloc (sizeof *newarg);
291   newarg->arg = arg;
292   newarg->next = NULL;
293
294   /* Chain on end to preserve command-line order.  */
295   *last_plugin_args_tail_chain_ptr = newarg;
296   last_plugin_args_tail_chain_ptr = &newarg->next;
297   last_plugin->n_args++;
298   return 0;
299 }
300
301 /* Generate a dummy BFD to represent an IR file, for any callers of
302    plugin_call_claim_file to use as the handle in the ld_plugin_input_file
303    struct that they build to pass in.  The BFD is initially writable, so
304    that symbols can be added to it; it must be made readable after the
305    add_symbols hook has been called so that it can be read when linking.  */
306 static bfd *
307 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
308 {
309   bfd *abfd;
310   bfd_boolean bfd_plugin_target;
311
312   bfd_use_reserved_id = 1;
313   bfd_plugin_target = bfd_plugin_target_p (srctemplate->xvec);
314   abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
315                      bfd_plugin_target ? link_info.output_bfd : srctemplate);
316   if (abfd != NULL)
317     {
318       abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
319       if (!bfd_make_writable (abfd))
320         goto report_error;
321       if (!bfd_plugin_target)
322         {
323           bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
324           bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
325           if (!bfd_copy_private_bfd_data (srctemplate, abfd))
326             goto report_error;
327         }
328         {
329           flagword flags;
330
331           /* Create section to own the symbols.  */
332           flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
333                    | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
334           if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
335             return abfd;
336         }
337     }
338 report_error:
339   einfo (_("could not create dummy IR bfd: %F%E\n"));
340   return NULL;
341 }
342
343 /* Check if the BFD passed in is an IR dummy object file.  */
344 static inline bfd_boolean
345 is_ir_dummy_bfd (const bfd *abfd)
346 {
347   /* ABFD can sometimes legitimately be NULL, e.g. when called from one
348      of the linker callbacks for a symbol in the *ABS* or *UND* sections.  */
349   return abfd != NULL && (abfd->flags & BFD_PLUGIN) != 0;
350 }
351
352 /* Helpers to convert between BFD and GOLD symbol formats.  */
353 static enum ld_plugin_status
354 asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
355                             const struct ld_plugin_symbol *ldsym)
356 {
357   flagword flags = BSF_NO_FLAGS;
358   struct bfd_section *section;
359
360   asym->the_bfd = abfd;
361   asym->name = (ldsym->version
362                 ? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
363                 : ldsym->name);
364   asym->value = 0;
365   switch (ldsym->def)
366     {
367     case LDPK_WEAKDEF:
368       flags = BSF_WEAK;
369       /* FALLTHRU */
370     case LDPK_DEF:
371       flags |= BSF_GLOBAL;
372       if (ldsym->comdat_key)
373         {
374           char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key,
375                                (const char *) NULL);
376           section = bfd_get_section_by_name (abfd, name);
377           if (section != NULL)
378             free (name);
379           else
380             {
381               flagword sflags;
382
383               sflags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
384                         | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE
385                         | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD);
386               section = bfd_make_section_anyway_with_flags (abfd, name, sflags);
387               if (section == NULL)
388                 return LDPS_ERR;
389             }
390         }
391       else
392         section = bfd_get_section_by_name (abfd, ".text");
393       break;
394
395     case LDPK_WEAKUNDEF:
396       flags = BSF_WEAK;
397       /* FALLTHRU */
398     case LDPK_UNDEF:
399       section = bfd_und_section_ptr;
400       break;
401
402     case LDPK_COMMON:
403       flags = BSF_GLOBAL;
404       section = bfd_com_section_ptr;
405       asym->value = ldsym->size;
406       /* For ELF targets, set alignment of common symbol to 1.  */
407       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
408         {
409           ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON;
410           ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
411         }
412       break;
413
414     default:
415       return LDPS_ERR;
416     }
417   asym->flags = flags;
418   asym->section = section;
419
420   /* Visibility only applies on ELF targets.  */
421   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
422     {
423       elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
424       unsigned char visibility;
425
426       if (!elfsym)
427         einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
428       switch (ldsym->visibility)
429         {
430         default:
431           einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
432                  ldsym->visibility);
433         case LDPV_DEFAULT:
434           visibility = STV_DEFAULT;
435           break;
436         case LDPV_PROTECTED:
437           visibility = STV_PROTECTED;
438           break;
439         case LDPV_INTERNAL:
440           visibility = STV_INTERNAL;
441           break;
442         case LDPV_HIDDEN:
443           visibility = STV_HIDDEN;
444           break;
445         }
446       elfsym->internal_elf_sym.st_other
447         = (visibility | (elfsym->internal_elf_sym.st_other
448                          & ~ELF_ST_VISIBILITY (-1)));
449     }
450
451   return LDPS_OK;
452 }
453
454 /* Register a claim-file handler.  */
455 static enum ld_plugin_status
456 register_claim_file (ld_plugin_claim_file_handler handler)
457 {
458   ASSERT (called_plugin);
459   called_plugin->claim_file_handler = handler;
460   return LDPS_OK;
461 }
462
463 /* Register an all-symbols-read handler.  */
464 static enum ld_plugin_status
465 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
466 {
467   ASSERT (called_plugin);
468   called_plugin->all_symbols_read_handler = handler;
469   return LDPS_OK;
470 }
471
472 /* Register a cleanup handler.  */
473 static enum ld_plugin_status
474 register_cleanup (ld_plugin_cleanup_handler handler)
475 {
476   ASSERT (called_plugin);
477   called_plugin->cleanup_handler = handler;
478   return LDPS_OK;
479 }
480
481 /* Add symbols from a plugin-claimed input file.  */
482 static enum ld_plugin_status
483 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
484 {
485   asymbol **symptrs;
486   plugin_input_file_t *input = handle;
487   bfd *abfd = input->abfd;
488   int n;
489
490   ASSERT (called_plugin);
491   symptrs = xmalloc (nsyms * sizeof *symptrs);
492   for (n = 0; n < nsyms; n++)
493     {
494       enum ld_plugin_status rv;
495       asymbol *bfdsym;
496
497       bfdsym = bfd_make_empty_symbol (abfd);
498       symptrs[n] = bfdsym;
499       rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
500       if (rv != LDPS_OK)
501         return rv;
502     }
503   bfd_set_symtab (abfd, symptrs, nsyms);
504   return LDPS_OK;
505 }
506
507 /* Get the input file information with an open (possibly re-opened)
508    file descriptor.  */
509 static enum ld_plugin_status
510 get_input_file (const void *handle, struct ld_plugin_input_file *file)
511 {
512   const plugin_input_file_t *input = handle;
513
514   ASSERT (called_plugin);
515
516   file->name = input->name;
517   file->offset = input->offset;
518   file->filesize = input->filesize;
519   file->handle = (void *) handle;
520
521   return LDPS_OK;
522 }
523
524 /* Get view of the input file.  */
525 static enum ld_plugin_status
526 get_view (const void *handle, const void **viewp)
527 {
528   plugin_input_file_t *input = (plugin_input_file_t *) handle;
529   char *buffer;
530   size_t size = input->filesize;
531   off_t offset = input->offset;
532 #if HAVE_MMAP && HAVE_GETPAGESIZE
533   off_t bias;
534 #endif
535
536   ASSERT (called_plugin);
537
538   /* FIXME: einfo should support %lld.  */
539   if ((off_t) size != input->filesize)
540     einfo (_("%P%F: unsupported input file size: %s (%ld bytes)\n"),
541            input->name, (long) input->filesize);
542
543   /* Check the cached view buffer.  */
544   if (input->view_buffer.addr != NULL
545       && input->view_buffer.filesize == size
546       && input->view_buffer.offset == offset)
547     {
548       *viewp = input->view_buffer.addr;
549       return LDPS_OK;
550     }
551
552   input->view_buffer.filesize = size;
553   input->view_buffer.offset = offset;
554
555 #if HAVE_MMAP
556 # if HAVE_GETPAGESIZE
557   bias = offset % plugin_pagesize;
558   offset -= bias;
559   size += bias;
560 # endif
561   buffer = mmap (NULL, size, PROT_READ, MAP_PRIVATE, input->fd, offset);
562   if (buffer != MAP_FAILED)
563     {
564       input->use_mmap = TRUE;
565 # if HAVE_GETPAGESIZE
566       buffer += bias;
567 # endif
568     }
569   else
570 #endif
571     {
572       char *p;
573
574       input->use_mmap = FALSE;
575
576       if (lseek (input->fd, offset, SEEK_SET) < 0)
577         return LDPS_ERR;
578
579       buffer = bfd_alloc (input->abfd, size);
580       if (buffer == NULL)
581         return LDPS_ERR;
582
583       p = buffer;
584       do
585         {
586           ssize_t got = read (input->fd, p, size);
587           if (got == 0)
588             break;
589           else if (got > 0)
590             {
591               p += got;
592               size -= got;
593             }
594           else if (errno != EINTR)
595             return LDPS_ERR;
596         }
597       while (size > 0);
598     }
599
600   input->view_buffer.addr = buffer;
601   *viewp = buffer;
602
603   return LDPS_OK;
604 }
605
606 /* Release the input file.  */
607 static enum ld_plugin_status
608 release_input_file (const void *handle)
609 {
610   plugin_input_file_t *input = (plugin_input_file_t *) handle;
611   ASSERT (called_plugin);
612   if (input->fd != -1)
613     {
614       close (input->fd);
615       input->fd = -1;
616     }
617   return LDPS_OK;
618 }
619
620 /* Return TRUE if a defined symbol might be reachable from outside the
621    universe of claimed objects.  */
622 static inline bfd_boolean
623 is_visible_from_outside (struct ld_plugin_symbol *lsym,
624                          struct bfd_link_hash_entry *blhe)
625 {
626   struct bfd_sym_chain *sym;
627
628   if (bfd_link_relocatable (&link_info))
629     return TRUE;
630   if (link_info.export_dynamic || bfd_link_dll (&link_info))
631     {
632       /* Check if symbol is hidden by version script.  */
633       if (bfd_hide_sym_by_version (link_info.version_info,
634                                    blhe->root.string))
635         return FALSE;
636       /* Only ELF symbols really have visibility.  */
637       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
638         {
639           struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
640           int vis = ELF_ST_VISIBILITY (el->other);
641           return vis == STV_DEFAULT || vis == STV_PROTECTED;
642         }
643       /* On non-ELF targets, we can safely make inferences by considering
644          what visibility the plugin would have liked to apply when it first
645          sent us the symbol.  During ELF symbol processing, visibility only
646          ever becomes more restrictive, not less, when symbols are merged,
647          so this is a conservative estimate; it may give false positives,
648          declaring something visible from outside when it in fact would
649          not have been, but this will only lead to missed optimisation
650          opportunities during LTRANS at worst; it will not give false
651          negatives, which can lead to the disastrous conclusion that the
652          related symbol is IRONLY.  (See GCC PR46319 for an example.)  */
653       return (lsym->visibility == LDPV_DEFAULT
654               || lsym->visibility == LDPV_PROTECTED);
655     }
656
657   for (sym = &entry_symbol; sym != NULL; sym = sym->next)
658     if (sym->name
659         && strcmp (sym->name, blhe->root.string) == 0)
660       return TRUE;
661
662   return FALSE;
663 }
664
665 /* Get the symbol resolution info for a plugin-claimed input file.  */
666 static enum ld_plugin_status
667 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms,
668              int def_ironly_exp)
669 {
670   const plugin_input_file_t *input = handle;
671   const bfd *abfd = (const bfd *) input->abfd;
672   int n;
673
674   ASSERT (called_plugin);
675   for (n = 0; n < nsyms; n++)
676     {
677       struct bfd_link_hash_entry *blhe;
678       asection *owner_sec;
679       int res;
680
681       if (syms[n].def != LDPK_UNDEF)
682         blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
683                                      FALSE, FALSE, TRUE);
684       else
685         blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
686                                              syms[n].name, FALSE, FALSE, TRUE);
687       if (!blhe)
688         {
689           /* The plugin is called to claim symbols in an archive element
690              from plugin_object_p.  But those symbols aren't needed to
691              create output.  They are defined and referenced only within
692              IR.  */
693           switch (syms[n].def)
694             {
695             default:
696               abort ();
697             case LDPK_UNDEF:
698             case LDPK_WEAKUNDEF:
699               res = LDPR_UNDEF;
700               break;
701             case LDPK_DEF:
702             case LDPK_WEAKDEF:
703             case LDPK_COMMON:
704               res = LDPR_PREVAILING_DEF_IRONLY;
705               break;
706             }
707           goto report_symbol;
708         }
709
710       /* Determine resolution from blhe type and symbol's original type.  */
711       if (blhe->type == bfd_link_hash_undefined
712           || blhe->type == bfd_link_hash_undefweak)
713         {
714           res = LDPR_UNDEF;
715           goto report_symbol;
716         }
717       if (blhe->type != bfd_link_hash_defined
718           && blhe->type != bfd_link_hash_defweak
719           && blhe->type != bfd_link_hash_common)
720         {
721           /* We should not have a new, indirect or warning symbol here.  */
722           einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
723                  called_plugin->name, blhe->type);
724         }
725
726       /* Find out which section owns the symbol.  Since it's not undef,
727          it must have an owner; if it's not a common symbol, both defs
728          and weakdefs keep it in the same place. */
729       owner_sec = (blhe->type == bfd_link_hash_common
730                    ? blhe->u.c.p->section
731                    : blhe->u.def.section);
732
733
734       /* If it was originally undefined or common, then it has been
735          resolved; determine how.  */
736       if (syms[n].def == LDPK_UNDEF
737           || syms[n].def == LDPK_WEAKUNDEF
738           || syms[n].def == LDPK_COMMON)
739         {
740           if (owner_sec->owner == link_info.output_bfd)
741             res = LDPR_RESOLVED_EXEC;
742           else if (owner_sec->owner == abfd)
743             res = LDPR_PREVAILING_DEF_IRONLY;
744           else if (is_ir_dummy_bfd (owner_sec->owner))
745             res = LDPR_RESOLVED_IR;
746           else if (owner_sec->owner != NULL
747                    && (owner_sec->owner->flags & DYNAMIC) != 0)
748             res = LDPR_RESOLVED_DYN;
749           else
750             res = LDPR_RESOLVED_EXEC;
751         }
752
753       /* Was originally def, or weakdef.  Does it prevail?  If the
754          owner is the original dummy bfd that supplied it, then this
755          is the definition that has prevailed.  */
756       else if (owner_sec->owner == link_info.output_bfd)
757         res = LDPR_PREEMPTED_REG;
758       else if (owner_sec->owner == abfd)
759         res = LDPR_PREVAILING_DEF_IRONLY;
760
761       /* Was originally def, weakdef, or common, but has been pre-empted.  */
762       else if (is_ir_dummy_bfd (owner_sec->owner))
763         res = LDPR_PREEMPTED_IR;
764       else
765         res = LDPR_PREEMPTED_REG;
766
767       if (res == LDPR_PREVAILING_DEF_IRONLY)
768         {
769           /* We need to know if the sym is referenced from non-IR files.  Or
770              even potentially-referenced, perhaps in a future final link if
771              this is a partial one, perhaps dynamically at load-time if the
772              symbol is externally visible.  */
773           if (blhe->non_ir_ref)
774             res = LDPR_PREVAILING_DEF;
775           else if (is_visible_from_outside (&syms[n], blhe))
776             res = def_ironly_exp;
777         }
778
779     report_symbol:
780       syms[n].resolution = res;
781       if (report_plugin_symbols)
782         einfo (_("%P: %B: symbol `%s' "
783                  "definition: %d, visibility: %d, resolution: %d\n"),
784                abfd, syms[n].name,
785                syms[n].def, syms[n].visibility, res);
786     }
787   return LDPS_OK;
788 }
789
790 static enum ld_plugin_status
791 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
792 {
793   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
794 }
795
796 static enum ld_plugin_status
797 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
798 {
799   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
800 }
801
802 /* Add a new (real) input file generated by a plugin.  */
803 static enum ld_plugin_status
804 add_input_file (const char *pathname)
805 {
806   lang_input_statement_type *is;
807
808   ASSERT (called_plugin);
809   is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
810                             NULL);
811   if (!is)
812     return LDPS_ERR;
813   is->flags.lto_output = 1;
814   return LDPS_OK;
815 }
816
817 /* Add a new (real) library required by a plugin.  */
818 static enum ld_plugin_status
819 add_input_library (const char *pathname)
820 {
821   lang_input_statement_type *is;
822
823   ASSERT (called_plugin);
824   is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
825                             NULL);
826   if (!is)
827     return LDPS_ERR;
828   is->flags.lto_output = 1;
829   return LDPS_OK;
830 }
831
832 /* Set the extra library path to be used by libraries added via
833    add_input_library.  */
834 static enum ld_plugin_status
835 set_extra_library_path (const char *path)
836 {
837   ASSERT (called_plugin);
838   ldfile_add_library_path (xstrdup (path), FALSE);
839   return LDPS_OK;
840 }
841
842 /* Issue a diagnostic message from a plugin.  */
843 static enum ld_plugin_status
844 message (int level, const char *format, ...)
845 {
846   va_list args;
847   va_start (args, format);
848
849   switch (level)
850     {
851     case LDPL_INFO:
852       vfinfo (stdout, format, args, FALSE);
853       putchar ('\n');
854       break;
855     case LDPL_WARNING:
856       {
857         char *newfmt = concat ("%P: warning: ", format, "\n",
858                                (const char *) NULL);
859         vfinfo (stdout, newfmt, args, TRUE);
860         free (newfmt);
861       }
862       break;
863     case LDPL_FATAL:
864     case LDPL_ERROR:
865     default:
866       {
867         char *newfmt = concat (level == LDPL_FATAL ? "%P%F" : "%P%X",
868                                ": error: ", format, "\n",
869                                (const char *) NULL);
870         fflush (stdout);
871         vfinfo (stderr, newfmt, args, TRUE);
872         fflush (stderr);
873         free (newfmt);
874       }
875       break;
876     }
877
878   va_end (args);
879   return LDPS_OK;
880 }
881
882 /* Helper to size leading part of tv array and set it up. */
883 static void
884 set_tv_header (struct ld_plugin_tv *tv)
885 {
886   size_t i;
887
888   /* Version info.  */
889   static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
890   static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
891
892   for (i = 0; i < tv_header_size; i++)
893     {
894       tv[i].tv_tag = tv_header_tags[i];
895 #define TVU(x) tv[i].tv_u.tv_ ## x
896       switch (tv[i].tv_tag)
897         {
898         case LDPT_MESSAGE:
899           TVU(message) = message;
900           break;
901         case LDPT_API_VERSION:
902           TVU(val) = LD_PLUGIN_API_VERSION;
903           break;
904         case LDPT_GNU_LD_VERSION:
905           TVU(val) = major * 100 + minor;
906           break;
907         case LDPT_LINKER_OUTPUT:
908           TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL
909                       : bfd_link_pde (&link_info) ? LDPO_EXEC
910                       : bfd_link_pie (&link_info) ? LDPO_PIE
911                       : LDPO_DYN);
912           break;
913         case LDPT_OUTPUT_NAME:
914           TVU(string) = output_filename;
915           break;
916         case LDPT_REGISTER_CLAIM_FILE_HOOK:
917           TVU(register_claim_file) = register_claim_file;
918           break;
919         case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
920           TVU(register_all_symbols_read) = register_all_symbols_read;
921           break;
922         case LDPT_REGISTER_CLEANUP_HOOK:
923           TVU(register_cleanup) = register_cleanup;
924           break;
925         case LDPT_ADD_SYMBOLS:
926           TVU(add_symbols) = add_symbols;
927           break;
928         case LDPT_GET_INPUT_FILE:
929           TVU(get_input_file) = get_input_file;
930           break;
931         case LDPT_GET_VIEW:
932           TVU(get_view) = get_view;
933           break;
934         case LDPT_RELEASE_INPUT_FILE:
935           TVU(release_input_file) = release_input_file;
936           break;
937         case LDPT_GET_SYMBOLS:
938           TVU(get_symbols) = get_symbols_v1;
939           break;
940         case LDPT_GET_SYMBOLS_V2:
941           TVU(get_symbols) = get_symbols_v2;
942           break;
943         case LDPT_ADD_INPUT_FILE:
944           TVU(add_input_file) = add_input_file;
945           break;
946         case LDPT_ADD_INPUT_LIBRARY:
947           TVU(add_input_library) = add_input_library;
948           break;
949         case LDPT_SET_EXTRA_LIBRARY_PATH:
950           TVU(set_extra_library_path) = set_extra_library_path;
951           break;
952         default:
953           /* Added a new entry to the array without adding
954              a new case to set up its value is a bug.  */
955           FAIL ();
956         }
957 #undef TVU
958     }
959 }
960
961 /* Append the per-plugin args list and trailing LDPT_NULL to tv.  */
962 static void
963 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
964 {
965   plugin_arg_t *arg = plugin->args;
966   while (arg)
967     {
968       tv->tv_tag = LDPT_OPTION;
969       tv->tv_u.tv_string = arg->arg;
970       arg = arg->next;
971       tv++;
972     }
973   tv->tv_tag = LDPT_NULL;
974   tv->tv_u.tv_val = 0;
975 }
976
977 /* Load up and initialise all plugins after argument parsing.  */
978 void
979 plugin_load_plugins (void)
980 {
981   struct ld_plugin_tv *my_tv;
982   unsigned int max_args = 0;
983   plugin_t *curplug = plugins_list;
984
985   /* If there are no plugins, we need do nothing this run.  */
986   if (!curplug)
987     return;
988
989   /* First pass over plugins to find max # args needed so that we
990      can size and allocate the tv array.  */
991   while (curplug)
992     {
993       if (curplug->n_args > max_args)
994         max_args = curplug->n_args;
995       curplug = curplug->next;
996     }
997
998   /* Allocate tv array and initialise constant part.  */
999   my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
1000   set_tv_header (my_tv);
1001
1002   /* Pass over plugins again, activating them.  */
1003   curplug = plugins_list;
1004   while (curplug)
1005     {
1006       enum ld_plugin_status rv;
1007       ld_plugin_onload onloadfn;
1008
1009       onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
1010       if (!onloadfn)
1011         onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
1012       if (!onloadfn)
1013         einfo (_("%P%F: %s: error loading plugin: %s\n"),
1014                curplug->name, dlerror ());
1015       set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
1016       called_plugin = curplug;
1017       rv = (*onloadfn) (my_tv);
1018       called_plugin = NULL;
1019       if (rv != LDPS_OK)
1020         einfo (_("%P%F: %s: plugin error: %d\n"), curplug->name, rv);
1021       curplug = curplug->next;
1022     }
1023
1024   /* Since plugin(s) inited ok, assume they're going to want symbol
1025      resolutions, which needs us to track which symbols are referenced
1026      by non-IR files using the linker's notice callback.  */
1027   orig_notice_all = link_info.notice_all;
1028   orig_callbacks = link_info.callbacks;
1029   plugin_callbacks = *orig_callbacks;
1030   plugin_callbacks.notice = &plugin_notice;
1031   link_info.notice_all = TRUE;
1032   link_info.lto_plugin_active = TRUE;
1033   link_info.callbacks = &plugin_callbacks;
1034
1035   register_ld_plugin_object_p (plugin_object_p);
1036
1037 #if HAVE_MMAP && HAVE_GETPAGESIZE
1038   plugin_pagesize = getpagesize ();
1039 #endif
1040 }
1041
1042 /* Call 'claim file' hook for all plugins.  */
1043 static int
1044 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
1045 {
1046   plugin_t *curplug = plugins_list;
1047   *claimed = FALSE;
1048   while (curplug && !*claimed)
1049     {
1050       if (curplug->claim_file_handler)
1051         {
1052           off_t cur_offset;
1053           enum ld_plugin_status rv;
1054
1055           called_plugin = curplug;
1056           cur_offset = lseek (file->fd, 0, SEEK_CUR);
1057           rv = (*curplug->claim_file_handler) (file, claimed);
1058           if (!*claimed)
1059             lseek (file->fd, cur_offset, SEEK_SET);
1060           called_plugin = NULL;
1061           if (rv != LDPS_OK)
1062             set_plugin_error (curplug->name);
1063         }
1064       curplug = curplug->next;
1065     }
1066   return plugin_error_p () ? -1 : 0;
1067 }
1068
1069 /* Duplicates a character string with memory attached to ABFD.  */
1070
1071 static char *
1072 plugin_strdup (bfd *abfd, const char *str)
1073 {
1074   size_t strlength;
1075   char *copy;
1076   strlength = strlen (str) + 1;
1077   copy = bfd_alloc (abfd, strlength);
1078   if (copy == NULL)
1079     einfo (_("%P%F: plugin_strdup failed to allocate memory: %s\n"),
1080            bfd_get_error ());
1081   memcpy (copy, str, strlength);
1082   return copy;
1083 }
1084
1085 static const bfd_target *
1086 plugin_object_p (bfd *ibfd)
1087 {
1088   int claimed;
1089   plugin_input_file_t *input;
1090   struct ld_plugin_input_file file;
1091   bfd *abfd;
1092
1093   /* Don't try the dummy object file.  */
1094   if ((ibfd->flags & BFD_PLUGIN) != 0)
1095     return NULL;
1096
1097   if (ibfd->plugin_format != bfd_plugin_unknown)
1098     {
1099       if (ibfd->plugin_format == bfd_plugin_yes)
1100         return ibfd->plugin_dummy_bfd->xvec;
1101       else
1102         return NULL;
1103     }
1104
1105   /* We create a dummy BFD, initially empty, to house whatever symbols
1106      the plugin may want to add.  */
1107   abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd);
1108
1109   input = bfd_alloc (abfd, sizeof (*input));
1110   if (input == NULL)
1111     einfo (_("%P%F: plugin failed to allocate memory for input: %s\n"),
1112            bfd_get_error ());
1113
1114   if (!bfd_plugin_open_input (ibfd, &file))
1115     return NULL;
1116
1117   if (file.name == ibfd->filename)
1118     {
1119       /* We must copy filename attached to ibfd if it is not an archive
1120          member since it may be freed by bfd_close below.  */
1121       file.name = plugin_strdup (abfd, file.name);
1122     }
1123
1124   file.handle = input;
1125   /* The plugin API expects that the file descriptor won't be closed
1126      and reused as done by the bfd file cache.  So dup one.  */
1127   file.fd = dup (file.fd);
1128   if (file.fd < 0)
1129     return NULL;
1130
1131   input->abfd = abfd;
1132   input->view_buffer.addr = NULL;
1133   input->view_buffer.filesize = 0;
1134   input->view_buffer.offset = 0;
1135   input->fd = file.fd;
1136   input->use_mmap = FALSE;
1137   input->offset = file.offset;
1138   input->filesize = file.filesize;
1139   input->name = plugin_strdup (abfd, ibfd->filename);
1140
1141   claimed = 0;
1142
1143   if (plugin_call_claim_file (&file, &claimed))
1144     einfo (_("%P%F: %s: plugin reported error claiming file\n"),
1145            plugin_error_plugin ());
1146
1147   if (input->fd != -1 && !bfd_plugin_target_p (ibfd->xvec))
1148     {
1149       /* FIXME: fd belongs to us, not the plugin.  GCC plugin, which
1150          doesn't need fd after plugin_call_claim_file, doesn't use
1151          BFD plugin target vector.  Since GCC plugin doesn't call
1152          release_input_file, we close it here.  LLVM plugin, which
1153          needs fd after plugin_call_claim_file and calls
1154          release_input_file after it is done, uses BFD plugin target
1155          vector.  This scheme doesn't work when a plugin needs fd and
1156          doesn't use BFD plugin target vector neither.  */
1157       close (input->fd);
1158       input->fd = -1;
1159     }
1160
1161   if (claimed)
1162     {
1163       ibfd->plugin_format = bfd_plugin_yes;
1164       ibfd->plugin_dummy_bfd = abfd;
1165       bfd_make_readable (abfd);
1166       return abfd->xvec;
1167     }
1168   else
1169     {
1170 #if HAVE_MMAP
1171       if (input->use_mmap)
1172         {
1173           /* If plugin didn't claim the file, unmap the buffer.  */
1174           char *addr = input->view_buffer.addr;
1175           off_t size = input->view_buffer.filesize;
1176 # if HAVE_GETPAGESIZE
1177           off_t bias = input->view_buffer.offset % plugin_pagesize;
1178           size += bias;
1179           addr -= bias;
1180 # endif
1181           munmap (addr, size);
1182         }
1183 #endif
1184
1185       /* If plugin didn't claim the file, we don't need the dummy bfd.
1186          Can't avoid speculatively creating it, alas.  */
1187       ibfd->plugin_format = bfd_plugin_no;
1188       bfd_close_all_done (abfd);
1189       return NULL;
1190     }
1191 }
1192
1193 void
1194 plugin_maybe_claim (lang_input_statement_type *entry)
1195 {
1196   if (plugin_object_p (entry->the_bfd))
1197     {
1198       bfd *abfd = entry->the_bfd->plugin_dummy_bfd;
1199
1200       /* Discard the real file's BFD and substitute the dummy one.  */
1201
1202       /* We can't call bfd_close on archives.  BFD archive handling
1203          caches elements, and add_archive_element keeps pointers to
1204          the_bfd and the_bfd->filename in a lang_input_statement_type
1205          linker script statement.  */
1206       if (entry->the_bfd->my_archive == NULL)
1207         bfd_close (entry->the_bfd);
1208       entry->the_bfd = abfd;
1209       entry->flags.claimed = 1;
1210     }
1211 }
1212
1213 /* Call 'all symbols read' hook for all plugins.  */
1214 int
1215 plugin_call_all_symbols_read (void)
1216 {
1217   plugin_t *curplug = plugins_list;
1218
1219   /* Disable any further file-claiming.  */
1220   no_more_claiming = TRUE;
1221
1222   while (curplug)
1223     {
1224       if (curplug->all_symbols_read_handler)
1225         {
1226           enum ld_plugin_status rv;
1227           called_plugin = curplug;
1228           rv = (*curplug->all_symbols_read_handler) ();
1229           called_plugin = NULL;
1230           if (rv != LDPS_OK)
1231             set_plugin_error (curplug->name);
1232         }
1233       curplug = curplug->next;
1234     }
1235   return plugin_error_p () ? -1 : 0;
1236 }
1237
1238 /* Call 'cleanup' hook for all plugins at exit.  */
1239 void
1240 plugin_call_cleanup (void)
1241 {
1242   plugin_t *curplug = plugins_list;
1243   while (curplug)
1244     {
1245       if (curplug->cleanup_handler && !curplug->cleanup_done)
1246         {
1247           enum ld_plugin_status rv;
1248           curplug->cleanup_done = TRUE;
1249           called_plugin = curplug;
1250           rv = (*curplug->cleanup_handler) ();
1251           called_plugin = NULL;
1252           if (rv != LDPS_OK)
1253             info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1254                       curplug->name, rv);
1255           dlclose (curplug->dlhandle);
1256         }
1257       curplug = curplug->next;
1258     }
1259 }
1260
1261 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1262    and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1263    the linker adds them to the linker hash table.  Mark those
1264    referenced from a non-IR file with non_ir_ref.  We have to
1265    notice_all symbols, because we won't necessarily know until later
1266    which ones will be contributed by IR files.  */
1267 static bfd_boolean
1268 plugin_notice (struct bfd_link_info *info,
1269                struct bfd_link_hash_entry *h,
1270                struct bfd_link_hash_entry *inh,
1271                bfd *abfd,
1272                asection *section,
1273                bfd_vma value,
1274                flagword flags)
1275 {
1276   struct bfd_link_hash_entry *orig_h = h;
1277
1278   if (h != NULL)
1279     {
1280       bfd *sym_bfd;
1281
1282       if (h->type == bfd_link_hash_warning)
1283         h = h->u.i.link;
1284
1285       /* Nothing to do here if this def/ref is from an IR dummy BFD.  */
1286       if (is_ir_dummy_bfd (abfd))
1287         ;
1288
1289       /* Making an indirect symbol counts as a reference unless this
1290          is a brand new symbol.  */
1291       else if (bfd_is_ind_section (section)
1292                || (flags & BSF_INDIRECT) != 0)
1293         {
1294           /* ??? Some of this is questionable.  See comments in
1295              _bfd_generic_link_add_one_symbol for case IND.  */
1296           if (h->type != bfd_link_hash_new)
1297             {
1298               h->non_ir_ref = TRUE;
1299               inh->non_ir_ref = TRUE;
1300             }
1301           else if (inh->type == bfd_link_hash_new)
1302             inh->non_ir_ref = TRUE;
1303         }
1304
1305       /* Nothing to do here for warning symbols.  */
1306       else if ((flags & BSF_WARNING) != 0)
1307         ;
1308
1309       /* Nothing to do here for constructor symbols.  */
1310       else if ((flags & BSF_CONSTRUCTOR) != 0)
1311         ;
1312
1313       /* If this is a ref, set non_ir_ref.  */
1314       else if (bfd_is_und_section (section))
1315         {
1316           /* Replace the undefined dummy bfd with the real one.  */
1317           if ((h->type == bfd_link_hash_undefined
1318                || h->type == bfd_link_hash_undefweak)
1319               && (h->u.undef.abfd == NULL
1320                   || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
1321             h->u.undef.abfd = abfd;
1322           h->non_ir_ref = TRUE;
1323         }
1324
1325       /* Otherwise, it must be a new def.  */
1326       else
1327         {
1328           /* A common symbol should be merged with other commons or
1329              defs with the same name.  In particular, a common ought
1330              to be overridden by a def in a -flto object.  In that
1331              sense a common is also a ref.  */
1332           if (bfd_is_com_section (section))
1333             h->non_ir_ref = TRUE;
1334
1335           /* Ensure any symbol defined in an IR dummy BFD takes on a
1336              new value from a real BFD.  Weak symbols are not normally
1337              overridden by a new weak definition, and strong symbols
1338              will normally cause multiple definition errors.  Avoid
1339              this by making the symbol appear to be undefined.  */
1340           if (((h->type == bfd_link_hash_defweak
1341                 || h->type == bfd_link_hash_defined)
1342                && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
1343               || (h->type == bfd_link_hash_common
1344                   && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
1345             {
1346               h->type = bfd_link_hash_undefweak;
1347               h->u.undef.abfd = sym_bfd;
1348             }
1349         }
1350     }
1351
1352   /* Continue with cref/nocrossref/trace-sym processing.  */
1353   if (orig_h == NULL
1354       || orig_notice_all
1355       || (info->notice_hash != NULL
1356           && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
1357                               FALSE, FALSE) != NULL))
1358     return (*orig_callbacks->notice) (info, orig_h, inh,
1359                                       abfd, section, value, flags);
1360   return TRUE;
1361 }