1/* Plugin control for the GNU linker.
2   Copyright 2010, 2011 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.h"
33#include "plugin-api.h"
34#include "elf-bfd.h"
35#if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
36#include <Windows.h>
37#endif
38
39/* Report plugin symbols.  */
40bfd_boolean report_plugin_symbols;
41
42/* The suffix to append to the name of the real (claimed) object file
43   when generating a dummy BFD to hold the IR symbols sent from the
44   plugin.  For cosmetic use only; appears in maps, crefs etc.  */
45#define IRONLY_SUFFIX " (symbol from plugin)"
46
47/* Stores a single argument passed to a plugin.  */
48typedef struct plugin_arg
49{
50  struct plugin_arg *next;
51  const char *arg;
52} plugin_arg_t;
53
54/* Holds all details of a single plugin.  */
55typedef struct plugin
56{
57  /* Next on the list of plugins, or NULL at end of chain.  */
58  struct plugin *next;
59  /* The argument string given to --plugin.  */
60  const char *name;
61  /* The shared library handle returned by dlopen.  */
62  void *dlhandle;
63  /* The list of argument string given to --plugin-opt.  */
64  plugin_arg_t *args;
65  /* Number of args in the list, for convenience.  */
66  size_t n_args;
67  /* The plugin's event handlers.  */
68  ld_plugin_claim_file_handler claim_file_handler;
69  ld_plugin_all_symbols_read_handler all_symbols_read_handler;
70  ld_plugin_cleanup_handler cleanup_handler;
71  /* TRUE if the cleanup handlers have been called.  */
72  bfd_boolean cleanup_done;
73} plugin_t;
74
75/* The master list of all plugins.  */
76static plugin_t *plugins_list = NULL;
77
78/* We keep a tail pointer for easy linking on the end.  */
79static plugin_t **plugins_tail_chain_ptr = &plugins_list;
80
81/* The last plugin added to the list, for receiving args.  */
82static plugin_t *last_plugin = NULL;
83
84/* The tail of the arg chain of the last plugin added to the list.  */
85static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
86
87/* The plugin which is currently having a callback executed.  */
88static plugin_t *called_plugin = NULL;
89
90/* Last plugin to cause an error, if any.  */
91static const char *error_plugin = NULL;
92
93/* State of linker "notice" interface before we poked at it.  */
94static bfd_boolean orig_notice_all;
95
96/* Original linker callbacks, and the plugin version.  */
97static const struct bfd_link_callbacks *orig_callbacks;
98static struct bfd_link_callbacks plugin_callbacks;
99
100/* Set at all symbols read time, to avoid recursively offering the plugin
101   its own newly-added input files and libs to claim.  */
102bfd_boolean no_more_claiming = FALSE;
103
104/* List of tags to set in the constant leading part of the tv array. */
105static const enum ld_plugin_tag tv_header_tags[] =
106{
107  LDPT_MESSAGE,
108  LDPT_API_VERSION,
109  LDPT_GNU_LD_VERSION,
110  LDPT_LINKER_OUTPUT,
111  LDPT_OUTPUT_NAME,
112  LDPT_REGISTER_CLAIM_FILE_HOOK,
113  LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
114  LDPT_REGISTER_CLEANUP_HOOK,
115  LDPT_ADD_SYMBOLS,
116  LDPT_GET_INPUT_FILE,
117  LDPT_RELEASE_INPUT_FILE,
118  LDPT_GET_SYMBOLS,
119  LDPT_ADD_INPUT_FILE,
120  LDPT_ADD_INPUT_LIBRARY,
121  LDPT_SET_EXTRA_LIBRARY_PATH
122};
123
124/* How many entries in the constant leading part of the tv array.  */
125static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
126
127/* Forward references.  */
128static bfd_boolean plugin_notice (struct bfd_link_info *,
129				  struct bfd_link_hash_entry *, bfd *,
130				  asection *, bfd_vma, flagword, const char *);
131
132#if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
133
134#define RTLD_NOW 0	/* Dummy value.  */
135
136static void *
137dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
138{
139  return LoadLibrary (file);
140}
141
142static void *
143dlsym (void *handle, const char *name)
144{
145  return GetProcAddress (handle, name);
146}
147
148static int
149dlclose (void *handle)
150{
151  FreeLibrary (handle);
152  return 0;
153}
154
155#endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)  */
156
157/* Helper function for exiting with error status.  */
158static int
159set_plugin_error (const char *plugin)
160{
161  error_plugin = plugin;
162  return -1;
163}
164
165/* Test if an error occurred.  */
166static bfd_boolean
167plugin_error_p (void)
168{
169  return error_plugin != NULL;
170}
171
172/* Return name of plugin which caused an error if any.  */
173const char *
174plugin_error_plugin (void)
175{
176  return error_plugin ? error_plugin : _("<no plugin>");
177}
178
179/* Handle -plugin arg: find and load plugin, or return error.  */
180int
181plugin_opt_plugin (const char *plugin)
182{
183  plugin_t *newplug;
184
185  newplug = xmalloc (sizeof *newplug);
186  memset (newplug, 0, sizeof *newplug);
187  newplug->name = plugin;
188  newplug->dlhandle = dlopen (plugin, RTLD_NOW);
189  if (!newplug->dlhandle)
190    return set_plugin_error (plugin);
191
192  /* Chain on end, so when we run list it is in command-line order.  */
193  *plugins_tail_chain_ptr = newplug;
194  plugins_tail_chain_ptr = &newplug->next;
195
196  /* Record it as current plugin for receiving args.  */
197  last_plugin = newplug;
198  last_plugin_args_tail_chain_ptr = &newplug->args;
199  return 0;
200}
201
202/* Accumulate option arguments for last-loaded plugin, or return
203   error if none.  */
204int
205plugin_opt_plugin_arg (const char *arg)
206{
207  plugin_arg_t *newarg;
208
209  if (!last_plugin)
210    return set_plugin_error (_("<no plugin>"));
211
212  newarg = xmalloc (sizeof *newarg);
213  newarg->arg = arg;
214  newarg->next = NULL;
215
216  /* Chain on end to preserve command-line order.  */
217  *last_plugin_args_tail_chain_ptr = newarg;
218  last_plugin_args_tail_chain_ptr = &newarg->next;
219  last_plugin->n_args++;
220  return 0;
221}
222
223/* Create a dummy BFD.  */
224bfd *
225plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
226{
227  bfd *abfd;
228
229  bfd_use_reserved_id = 1;
230  abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
231		     srctemplate);
232  if (abfd != NULL)
233    {
234      abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
235      bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
236      bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
237      if (bfd_make_writable (abfd)
238	  && bfd_copy_private_bfd_data (srctemplate, abfd))
239	{
240	  flagword flags;
241
242	  /* Create sections to own the symbols.  */
243	  flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
244		   | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
245	  if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
246	    return abfd;
247	}
248    }
249  einfo (_("could not create dummy IR bfd: %F%E\n"));
250  return NULL;
251}
252
253/* Check if the BFD passed in is an IR dummy object file.  */
254static bfd_boolean
255is_ir_dummy_bfd (const bfd *abfd)
256{
257  /* ABFD can sometimes legitimately be NULL, e.g. when called from one
258     of the linker callbacks for a symbol in the *ABS* or *UND* sections.
259     Likewise, the usrdata field may be NULL if ABFD was added by the
260     backend without a corresponding input statement, as happens e.g.
261     when processing DT_NEEDED dependencies.  */
262  return (abfd
263	  && abfd->usrdata
264	  && ((lang_input_statement_type *)(abfd->usrdata))->claimed);
265}
266
267/* Helpers to convert between BFD and GOLD symbol formats.  */
268static enum ld_plugin_status
269asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
270			    const struct ld_plugin_symbol *ldsym)
271{
272  flagword flags = BSF_NO_FLAGS;
273  struct bfd_section *section;
274
275  asym->the_bfd = abfd;
276  asym->name = (ldsym->version
277		? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
278		: ldsym->name);
279  asym->value = 0;
280  switch (ldsym->def)
281    {
282    case LDPK_WEAKDEF:
283      flags = BSF_WEAK;
284      /* FALLTHRU */
285    case LDPK_DEF:
286      flags |= BSF_GLOBAL;
287      section = bfd_get_section_by_name (abfd, ".text");
288      break;
289
290    case LDPK_WEAKUNDEF:
291      flags = BSF_WEAK;
292      /* FALLTHRU */
293    case LDPK_UNDEF:
294      section = bfd_und_section_ptr;
295      break;
296
297    case LDPK_COMMON:
298      flags = BSF_GLOBAL;
299      section = bfd_com_section_ptr;
300      asym->value = ldsym->size;
301      /* For ELF targets, set alignment of common symbol to 1.  */
302      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
303	{
304	  ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON;
305	  ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
306	}
307      break;
308
309    default:
310      return LDPS_ERR;
311    }
312  asym->flags = flags;
313  asym->section = section;
314
315  /* Visibility only applies on ELF targets.  */
316  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
317    {
318      elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
319      unsigned char visibility;
320
321      if (!elfsym)
322	einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
323      switch (ldsym->visibility)
324	{
325	default:
326	  einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
327		 ldsym->visibility);
328	case LDPV_DEFAULT:
329	  visibility = STV_DEFAULT;
330	  break;
331	case LDPV_PROTECTED:
332	  visibility = STV_PROTECTED;
333	  break;
334	case LDPV_INTERNAL:
335	  visibility = STV_INTERNAL;
336	  break;
337	case LDPV_HIDDEN:
338	  visibility = STV_HIDDEN;
339	  break;
340	}
341      elfsym->internal_elf_sym.st_other
342	= (visibility | (elfsym->internal_elf_sym.st_other
343			 & ~ELF_ST_VISIBILITY (-1)));
344    }
345
346  return LDPS_OK;
347}
348
349/* Register a claim-file handler.  */
350static enum ld_plugin_status
351register_claim_file (ld_plugin_claim_file_handler handler)
352{
353  ASSERT (called_plugin);
354  called_plugin->claim_file_handler = handler;
355  return LDPS_OK;
356}
357
358/* Register an all-symbols-read handler.  */
359static enum ld_plugin_status
360register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
361{
362  ASSERT (called_plugin);
363  called_plugin->all_symbols_read_handler = handler;
364  return LDPS_OK;
365}
366
367/* Register a cleanup handler.  */
368static enum ld_plugin_status
369register_cleanup (ld_plugin_cleanup_handler handler)
370{
371  ASSERT (called_plugin);
372  called_plugin->cleanup_handler = handler;
373  return LDPS_OK;
374}
375
376/* Add symbols from a plugin-claimed input file.  */
377static enum ld_plugin_status
378add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
379{
380  asymbol **symptrs;
381  bfd *abfd = handle;
382  int n;
383  ASSERT (called_plugin);
384  symptrs = xmalloc (nsyms * sizeof *symptrs);
385  for (n = 0; n < nsyms; n++)
386    {
387      enum ld_plugin_status rv;
388      asymbol *bfdsym = bfd_make_empty_symbol (abfd);
389      symptrs[n] = bfdsym;
390      rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
391      if (rv != LDPS_OK)
392	return rv;
393    }
394  bfd_set_symtab (abfd, symptrs, nsyms);
395  return LDPS_OK;
396}
397
398/* Get the input file information with an open (possibly re-opened)
399   file descriptor.  */
400static enum ld_plugin_status
401get_input_file (const void *handle, struct ld_plugin_input_file *file)
402{
403  ASSERT (called_plugin);
404  handle = handle;
405  file = file;
406  return LDPS_ERR;
407}
408
409/* Release the input file.  */
410static enum ld_plugin_status
411release_input_file (const void *handle)
412{
413  ASSERT (called_plugin);
414  handle = handle;
415  return LDPS_ERR;
416}
417
418/* Return TRUE if a defined symbol might be reachable from outside the
419   universe of claimed objects.  */
420static inline bfd_boolean
421is_visible_from_outside (struct ld_plugin_symbol *lsym, asection *section,
422			 struct bfd_link_hash_entry *blhe)
423{
424  struct bfd_sym_chain *sym;
425
426  /* Section's owner may be NULL if it is the absolute
427     section, fortunately is_ir_dummy_bfd handles that.  */
428  if (!is_ir_dummy_bfd (section->owner))
429    return TRUE;
430  if (link_info.relocatable)
431    return TRUE;
432  if (link_info.export_dynamic || link_info.shared)
433    {
434      /* Only ELF symbols really have visibility.  */
435      if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
436	{
437	  struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
438	  int vis = ELF_ST_VISIBILITY (el->other);
439	  return vis == STV_DEFAULT || vis == STV_PROTECTED;
440	}
441      /* On non-ELF targets, we can safely make inferences by considering
442	 what visibility the plugin would have liked to apply when it first
443	 sent us the symbol.  During ELF symbol processing, visibility only
444	 ever becomes more restrictive, not less, when symbols are merged,
445	 so this is a conservative estimate; it may give false positives,
446	 declaring something visible from outside when it in fact would
447	 not have been, but this will only lead to missed optimisation
448	 opportunities during LTRANS at worst; it will not give false
449	 negatives, which can lead to the disastrous conclusion that the
450	 related symbol is IRONLY.  (See GCC PR46319 for an example.)  */
451      return (lsym->visibility == LDPV_DEFAULT
452	      || lsym->visibility == LDPV_PROTECTED);
453    }
454
455  for (sym = &entry_symbol; sym != NULL; sym = sym->next)
456    if (sym->name
457	&& strcmp (sym->name, blhe->root.string) == 0)
458      return TRUE;
459
460  return FALSE;
461}
462
463/* Get the symbol resolution info for a plugin-claimed input file.  */
464static enum ld_plugin_status
465get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
466{
467  const bfd *abfd = handle;
468  int n;
469  ASSERT (called_plugin);
470  for (n = 0; n < nsyms; n++)
471    {
472      struct bfd_link_hash_entry *blhe;
473      bfd_boolean ironly;
474      asection *owner_sec;
475      if (syms[n].def != LDPK_UNDEF)
476	blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
477				     FALSE, FALSE, TRUE);
478      else
479	blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
480					     syms[n].name, FALSE, FALSE, TRUE);
481      if (!blhe)
482	{
483	  syms[n].resolution = LDPR_UNKNOWN;
484	  goto report_symbol;
485	}
486
487      /* Determine resolution from blhe type and symbol's original type.  */
488      if (blhe->type == bfd_link_hash_undefined
489	  || blhe->type == bfd_link_hash_undefweak)
490	{
491	  syms[n].resolution = LDPR_UNDEF;
492	  goto report_symbol;
493	}
494      if (blhe->type != bfd_link_hash_defined
495	  && blhe->type != bfd_link_hash_defweak
496	  && blhe->type != bfd_link_hash_common)
497	{
498	  /* We should not have a new, indirect or warning symbol here.  */
499	  einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
500		 called_plugin->name, blhe->type);
501	}
502
503      /* Find out which section owns the symbol.  Since it's not undef,
504	 it must have an owner; if it's not a common symbol, both defs
505	 and weakdefs keep it in the same place. */
506      owner_sec = (blhe->type == bfd_link_hash_common
507		   ? blhe->u.c.p->section
508		   : blhe->u.def.section);
509
510      /* We need to know if the sym is referenced from non-IR files.  Or
511	 even potentially-referenced, perhaps in a future final link if
512	 this is a partial one, perhaps dynamically at load-time if the
513	 symbol is externally visible.  */
514      ironly = !(blhe->non_ir_ref
515		 || is_visible_from_outside (&syms[n], owner_sec, blhe));
516
517      /* If it was originally undefined or common, then it has been
518	 resolved; determine how.  */
519      if (syms[n].def == LDPK_UNDEF
520	  || syms[n].def == LDPK_WEAKUNDEF
521	  || syms[n].def == LDPK_COMMON)
522	{
523	  if (owner_sec->owner == link_info.output_bfd)
524	    syms[n].resolution = LDPR_RESOLVED_EXEC;
525	  else if (owner_sec->owner == abfd)
526	    syms[n].resolution = (ironly
527				  ? LDPR_PREVAILING_DEF_IRONLY
528				  : LDPR_PREVAILING_DEF);
529	  else if (is_ir_dummy_bfd (owner_sec->owner))
530	    syms[n].resolution = LDPR_RESOLVED_IR;
531	  else if (owner_sec->owner != NULL
532		   && (owner_sec->owner->flags & DYNAMIC) != 0)
533	    syms[n].resolution =  LDPR_RESOLVED_DYN;
534	  else
535	    syms[n].resolution = LDPR_RESOLVED_EXEC;
536	  goto report_symbol;
537	}
538
539      /* Was originally def, or weakdef.  Does it prevail?  If the
540	 owner is the original dummy bfd that supplied it, then this
541	 is the definition that has prevailed.  */
542      if (owner_sec->owner == link_info.output_bfd)
543	syms[n].resolution = LDPR_PREEMPTED_REG;
544      else if (owner_sec->owner == abfd)
545	{
546	  syms[n].resolution = (ironly
547				? LDPR_PREVAILING_DEF_IRONLY
548				: LDPR_PREVAILING_DEF);
549	  goto report_symbol;
550	}
551
552      /* Was originally def, weakdef, or common, but has been pre-empted.  */
553      syms[n].resolution = (is_ir_dummy_bfd (owner_sec->owner)
554			    ? LDPR_PREEMPTED_IR
555			    : LDPR_PREEMPTED_REG);
556
557    report_symbol:
558      if (report_plugin_symbols)
559	einfo (_("%P: %B: symbol `%s' "
560		 "definition: %d, visibility: %d, resolution: %d\n"),
561	       abfd, syms[n].name,
562	       syms[n].def, syms[n].visibility, syms[n].resolution);
563    }
564  return LDPS_OK;
565}
566
567/* Add a new (real) input file generated by a plugin.  */
568static enum ld_plugin_status
569add_input_file (const char *pathname)
570{
571  ASSERT (called_plugin);
572  if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
573			    NULL))
574    return LDPS_ERR;
575  return LDPS_OK;
576}
577
578/* Add a new (real) library required by a plugin.  */
579static enum ld_plugin_status
580add_input_library (const char *pathname)
581{
582  ASSERT (called_plugin);
583  if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
584			    NULL))
585    return LDPS_ERR;
586  return LDPS_OK;
587}
588
589/* Set the extra library path to be used by libraries added via
590   add_input_library.  */
591static enum ld_plugin_status
592set_extra_library_path (const char *path)
593{
594  ASSERT (called_plugin);
595  ldfile_add_library_path (xstrdup (path), FALSE);
596  return LDPS_OK;
597}
598
599/* Issue a diagnostic message from a plugin.  */
600static enum ld_plugin_status
601message (int level, const char *format, ...)
602{
603  va_list args;
604  va_start (args, format);
605
606  switch (level)
607    {
608    case LDPL_INFO:
609      vfinfo (stdout, format, args, FALSE);
610      putchar ('\n');
611      break;
612    case LDPL_WARNING:
613      vfinfo (stdout, format, args, TRUE);
614      putchar ('\n');
615      break;
616    case LDPL_FATAL:
617    case LDPL_ERROR:
618    default:
619      {
620	char *newfmt = ACONCAT ((level == LDPL_FATAL ? "%P%F: " : "%P%X: ",
621				 format, "\n", (const char *) NULL));
622	fflush (stdout);
623	vfinfo (stderr, newfmt, args, TRUE);
624	fflush (stderr);
625      }
626      break;
627    }
628
629  va_end (args);
630  return LDPS_OK;
631}
632
633/* Helper to size leading part of tv array and set it up. */
634static size_t
635set_tv_header (struct ld_plugin_tv *tv)
636{
637  size_t i;
638
639  /* Version info.  */
640  static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
641  static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
642
643  if (!tv)
644    return tv_header_size;
645
646  for (i = 0; i < tv_header_size; i++)
647    {
648      tv[i].tv_tag = tv_header_tags[i];
649#define TVU(x) tv[i].tv_u.tv_ ## x
650      switch (tv[i].tv_tag)
651	{
652	case LDPT_MESSAGE:
653	  TVU(message) = message;
654	  break;
655	case LDPT_API_VERSION:
656	  TVU(val) = LD_PLUGIN_API_VERSION;
657	  break;
658	case LDPT_GNU_LD_VERSION:
659	  TVU(val) = major * 100 + minor;
660	  break;
661	case LDPT_LINKER_OUTPUT:
662	  TVU(val) = (link_info.relocatable
663		      ? LDPO_REL
664		      : (link_info.shared ? LDPO_DYN : LDPO_EXEC));
665	  break;
666	case LDPT_OUTPUT_NAME:
667	  TVU(string) = output_filename;
668	  break;
669	case LDPT_REGISTER_CLAIM_FILE_HOOK:
670	  TVU(register_claim_file) = register_claim_file;
671	  break;
672	case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
673	  TVU(register_all_symbols_read) = register_all_symbols_read;
674	  break;
675	case LDPT_REGISTER_CLEANUP_HOOK:
676	  TVU(register_cleanup) = register_cleanup;
677	  break;
678	case LDPT_ADD_SYMBOLS:
679	  TVU(add_symbols) = add_symbols;
680	  break;
681	case LDPT_GET_INPUT_FILE:
682	  TVU(get_input_file) = get_input_file;
683	  break;
684	case LDPT_RELEASE_INPUT_FILE:
685	  TVU(release_input_file) = release_input_file;
686	  break;
687	case LDPT_GET_SYMBOLS:
688	  TVU(get_symbols) = get_symbols;
689	  break;
690	case LDPT_ADD_INPUT_FILE:
691	  TVU(add_input_file) = add_input_file;
692	  break;
693	case LDPT_ADD_INPUT_LIBRARY:
694	  TVU(add_input_library) = add_input_library;
695	  break;
696	case LDPT_SET_EXTRA_LIBRARY_PATH:
697	  TVU(set_extra_library_path) = set_extra_library_path;
698	  break;
699	default:
700	  /* Added a new entry to the array without adding
701	     a new case to set up its value is a bug.  */
702	  FAIL ();
703	}
704#undef TVU
705    }
706  return tv_header_size;
707}
708
709/* Append the per-plugin args list and trailing LDPT_NULL to tv.  */
710static void
711set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
712{
713  plugin_arg_t *arg = plugin->args;
714  while (arg)
715    {
716      tv->tv_tag = LDPT_OPTION;
717      tv->tv_u.tv_string = arg->arg;
718      arg = arg->next;
719      tv++;
720    }
721  tv->tv_tag = LDPT_NULL;
722  tv->tv_u.tv_val = 0;
723}
724
725/* Return true if any plugins are active this run.  Only valid
726   after options have been processed.  */
727bfd_boolean
728plugin_active_plugins_p (void)
729{
730  return plugins_list != NULL;
731}
732
733/* Load up and initialise all plugins after argument parsing.  */
734int
735plugin_load_plugins (void)
736{
737  struct ld_plugin_tv *my_tv;
738  unsigned int max_args = 0;
739  plugin_t *curplug = plugins_list;
740
741  /* If there are no plugins, we need do nothing this run.  */
742  if (!curplug)
743    return 0;
744
745  /* First pass over plugins to find max # args needed so that we
746     can size and allocate the tv array.  */
747  while (curplug)
748    {
749      if (curplug->n_args > max_args)
750	max_args = curplug->n_args;
751      curplug = curplug->next;
752    }
753
754  /* Allocate tv array and initialise constant part.  */
755  my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
756  set_tv_header (my_tv);
757
758  /* Pass over plugins again, activating them.  */
759  curplug = plugins_list;
760  while (curplug)
761    {
762      enum ld_plugin_status rv;
763      ld_plugin_onload onloadfn = dlsym (curplug->dlhandle, "onload");
764      if (!onloadfn)
765	onloadfn = dlsym (curplug->dlhandle, "_onload");
766      if (!onloadfn)
767	return set_plugin_error (curplug->name);
768      set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
769      called_plugin = curplug;
770      rv = (*onloadfn) (my_tv);
771      called_plugin = NULL;
772      if (rv != LDPS_OK)
773	return set_plugin_error (curplug->name);
774      curplug = curplug->next;
775    }
776
777  /* Since plugin(s) inited ok, assume they're going to want symbol
778     resolutions, which needs us to track which symbols are referenced
779     by non-IR files using the linker's notice callback.  */
780  orig_notice_all = link_info.notice_all;
781  orig_callbacks = link_info.callbacks;
782  plugin_callbacks = *orig_callbacks;
783  plugin_callbacks.notice = &plugin_notice;
784  link_info.notice_all = TRUE;
785  link_info.callbacks = &plugin_callbacks;
786
787  return 0;
788}
789
790/* Call 'claim file' hook for all plugins.  */
791static int
792plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
793{
794  plugin_t *curplug = plugins_list;
795  *claimed = FALSE;
796  if (no_more_claiming)
797    return 0;
798  while (curplug && !*claimed)
799    {
800      if (curplug->claim_file_handler)
801	{
802	  enum ld_plugin_status rv;
803	  called_plugin = curplug;
804	  rv = (*curplug->claim_file_handler) (file, claimed);
805	  called_plugin = NULL;
806	  if (rv != LDPS_OK)
807	    set_plugin_error (curplug->name);
808	}
809      curplug = curplug->next;
810    }
811  return plugin_error_p () ? -1 : 0;
812}
813
814void
815plugin_maybe_claim (struct ld_plugin_input_file *file,
816		    lang_input_statement_type *entry)
817{
818  int claimed = 0;
819
820  /* We create a dummy BFD, initially empty, to house whatever symbols
821     the plugin may want to add.  */
822  file->handle = plugin_get_ir_dummy_bfd (entry->the_bfd->filename,
823					  entry->the_bfd);
824  if (plugin_call_claim_file (file, &claimed))
825    einfo (_("%P%F: %s: plugin reported error claiming file\n"),
826	   plugin_error_plugin ());
827  /* fd belongs to us, not the plugin; but we don't need it.  */
828  close (file->fd);
829  if (claimed)
830    {
831      /* Discard the real file's BFD and substitute the dummy one.  */
832
833      /* BFD archive handling caches elements so we can't call
834	 bfd_close for archives.  */
835      if (entry->the_bfd->my_archive == NULL)
836	bfd_close (entry->the_bfd);
837      entry->the_bfd = file->handle;
838      entry->claimed = TRUE;
839      bfd_make_readable (entry->the_bfd);
840    }
841  else
842    {
843      /* If plugin didn't claim the file, we don't need the dummy bfd.
844	 Can't avoid speculatively creating it, alas.  */
845      bfd_close_all_done (file->handle);
846      entry->claimed = FALSE;
847    }
848}
849
850/* Call 'all symbols read' hook for all plugins.  */
851int
852plugin_call_all_symbols_read (void)
853{
854  plugin_t *curplug = plugins_list;
855
856  /* Disable any further file-claiming.  */
857  no_more_claiming = TRUE;
858
859  while (curplug)
860    {
861      if (curplug->all_symbols_read_handler)
862	{
863	  enum ld_plugin_status rv;
864	  called_plugin = curplug;
865	  rv = (*curplug->all_symbols_read_handler) ();
866	  called_plugin = NULL;
867	  if (rv != LDPS_OK)
868	    set_plugin_error (curplug->name);
869	}
870      curplug = curplug->next;
871    }
872  return plugin_error_p () ? -1 : 0;
873}
874
875/* Call 'cleanup' hook for all plugins at exit.  */
876void
877plugin_call_cleanup (void)
878{
879  plugin_t *curplug = plugins_list;
880  while (curplug)
881    {
882      if (curplug->cleanup_handler && !curplug->cleanup_done)
883	{
884	  enum ld_plugin_status rv;
885	  curplug->cleanup_done = TRUE;
886	  called_plugin = curplug;
887	  rv = (*curplug->cleanup_handler) ();
888	  called_plugin = NULL;
889	  if (rv != LDPS_OK)
890	    set_plugin_error (curplug->name);
891	  dlclose (curplug->dlhandle);
892	}
893      curplug = curplug->next;
894    }
895  if (plugin_error_p ())
896    info_msg (_("%P: %s: error in plugin cleanup (ignored)\n"),
897	      plugin_error_plugin ());
898}
899
900/* To determine which symbols should be resolved LDPR_PREVAILING_DEF
901   and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
902   the linker adds them to the linker hash table.  Mark those
903   referenced from a non-IR file with non_ir_ref.  We have to
904   notice_all symbols, because we won't necessarily know until later
905   which ones will be contributed by IR files.  */
906static bfd_boolean
907plugin_notice (struct bfd_link_info *info,
908	       struct bfd_link_hash_entry *h,
909	       bfd *abfd,
910	       asection *section,
911	       bfd_vma value,
912	       flagword flags,
913	       const char *string)
914{
915  if (h != NULL)
916    {
917      bfd *sym_bfd;
918
919      /* No further processing if this def/ref is from an IR dummy BFD.  */
920      if (is_ir_dummy_bfd (abfd))
921	return TRUE;
922
923      /* Making an indirect symbol counts as a reference unless this
924	 is a brand new symbol.  */
925      if (bfd_is_ind_section (section)
926	  || (flags & BSF_INDIRECT) != 0)
927	{
928	  if (h->type != bfd_link_hash_new)
929	    {
930	      struct bfd_link_hash_entry *inh;
931
932	      h->non_ir_ref = TRUE;
933	      inh = bfd_wrapped_link_hash_lookup (abfd, info, string, FALSE,
934						  FALSE, FALSE);
935	      if (inh != NULL)
936		inh->non_ir_ref = TRUE;
937	    }
938	}
939
940      /* Nothing to do here for warning symbols.  */
941      else if ((flags & BSF_WARNING) != 0)
942	;
943
944      /* Nothing to do here for constructor symbols.  */
945      else if ((flags & BSF_CONSTRUCTOR) != 0)
946	;
947
948      /* If this is a ref, set non_ir_ref.  */
949      else if (bfd_is_und_section (section))
950	h->non_ir_ref = TRUE;
951
952      /* Otherwise, it must be a new def.  Ensure any symbol defined
953	 in an IR dummy BFD takes on a new value from a real BFD.
954	 Weak symbols are not normally overridden by a new weak
955	 definition, and strong symbols will normally cause multiple
956	 definition errors.  Avoid this by making the symbol appear
957	 to be undefined.  */
958      else if (((h->type == bfd_link_hash_defweak
959		 || h->type == bfd_link_hash_defined)
960		&& is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
961	       || (h->type == bfd_link_hash_common
962		   && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
963	{
964	  h->type = bfd_link_hash_undefweak;
965	  h->u.undef.abfd = sym_bfd;
966	}
967    }
968
969  /* Continue with cref/nocrossref/trace-sym processing.  */
970  if (h == NULL
971      || orig_notice_all
972      || (info->notice_hash != NULL
973	  && bfd_hash_lookup (info->notice_hash, h->root.string,
974			      FALSE, FALSE) != NULL))
975    return (*orig_callbacks->notice) (info, h,
976				      abfd, section, value, flags, string);
977  return TRUE;
978}
979