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