gcc/
[official-gcc.git] / gcc / plugin.c
blob8debc09cada18a08f961f633851a8c394f163807
1 /* Support for GCC plugin mechanism.
2 Copyright (C) 2009-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC 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, or (at your option)
9 any later version.
11 GCC 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.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file contains the support for GCC plugin mechanism based on the
21 APIs described in doc/plugin.texi. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "hash-table.h"
27 #include "diagnostic-core.h"
28 #include "tree.h"
29 #include "tree-pass.h"
30 #include "intl.h"
31 #include "plugin.h"
32 #include "ggc.h"
34 #ifdef ENABLE_PLUGIN
35 #include "plugin-version.h"
36 #endif
38 #define GCC_PLUGIN_STRINGIFY0(X) #X
39 #define GCC_PLUGIN_STRINGIFY1(X) GCC_PLUGIN_STRINGIFY0 (X)
41 /* Event names as strings. Keep in sync with enum plugin_event. */
42 static const char *plugin_event_name_init[] =
44 # define DEFEVENT(NAME) GCC_PLUGIN_STRINGIFY1 (NAME),
45 # include "plugin.def"
46 # undef DEFEVENT
49 /* A printf format large enough for the largest event above. */
50 #define FMT_FOR_PLUGIN_EVENT "%-32s"
52 const char **plugin_event_name = plugin_event_name_init;
54 /* Event hashtable helpers. */
56 struct event_hasher : typed_noop_remove <const char *>
58 typedef const char *value_type;
59 typedef const char *compare_type;
60 static inline hashval_t hash (const value_type *);
61 static inline bool equal (const value_type *, const compare_type *);
64 /* Helper function for the event hash table that hashes the entry V. */
66 inline hashval_t
67 event_hasher::hash (const value_type *v)
69 return htab_hash_string (*v);
72 /* Helper function for the event hash table that compares the name of an
73 existing entry (S1) with the given string (S2). */
75 inline bool
76 event_hasher::equal (const value_type *s1, const compare_type *s2)
78 return !strcmp (*s1, *s2);
81 /* A hash table to map event names to the position of the names in the
82 plugin_event_name table. */
83 static hash_table<event_hasher> *event_tab;
85 /* Keep track of the limit of allocated events and space ready for
86 allocating events. */
87 static int event_last = PLUGIN_EVENT_FIRST_DYNAMIC;
88 static int event_horizon = PLUGIN_EVENT_FIRST_DYNAMIC;
90 /* Hash table for the plugin_name_args objects created during command-line
91 parsing. */
92 static htab_t plugin_name_args_tab = NULL;
94 /* List node for keeping track of plugin-registered callback. */
95 struct callback_info
97 const char *plugin_name; /* Name of plugin that registers the callback. */
98 plugin_callback_func func; /* Callback to be called. */
99 void *user_data; /* plugin-specified data. */
100 struct callback_info *next;
103 /* An array of lists of 'callback_info' objects indexed by the event id. */
104 static struct callback_info *plugin_callbacks_init[PLUGIN_EVENT_FIRST_DYNAMIC];
105 static struct callback_info **plugin_callbacks = plugin_callbacks_init;
107 /* For invoke_plugin_callbacks(), see plugin.h. */
108 bool flag_plugin_added = false;
110 #ifdef ENABLE_PLUGIN
111 /* Each plugin should define an initialization function with exactly
112 this name. */
113 static const char *str_plugin_init_func_name = "plugin_init";
115 /* Each plugin should define this symbol to assert that it is
116 distributed under a GPL-compatible license. */
117 static const char *str_license = "plugin_is_GPL_compatible";
118 #endif
120 /* Helper function for the hash table that compares the base_name of the
121 existing entry (S1) with the given string (S2). */
123 static int
124 htab_str_eq (const void *s1, const void *s2)
126 const struct plugin_name_args *plugin = (const struct plugin_name_args *) s1;
127 return !strcmp (plugin->base_name, (const char *) s2);
131 /* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so,
132 return NAME. */
134 static char *
135 get_plugin_base_name (const char *full_name)
137 /* First get the base name part of the full-path name, i.e. NAME.so. */
138 char *base_name = xstrdup (lbasename (full_name));
140 /* Then get rid of '.so' part of the name. */
141 strip_off_ending (base_name, strlen (base_name));
143 return base_name;
147 /* Create a plugin_name_args object for the given plugin and insert it
148 to the hash table. This function is called when
149 -fplugin=/path/to/NAME.so or -fplugin=NAME option is processed. */
151 void
152 add_new_plugin (const char* plugin_name)
154 struct plugin_name_args *plugin;
155 void **slot;
156 char *base_name;
157 bool name_is_short;
158 const char *pc;
160 flag_plugin_added = true;
162 /* Replace short names by their full path when relevant. */
163 name_is_short = !IS_ABSOLUTE_PATH (plugin_name);
164 for (pc = plugin_name; name_is_short && *pc; pc++)
165 if (*pc == '.' || IS_DIR_SEPARATOR (*pc))
166 name_is_short = false;
168 if (name_is_short)
170 base_name = CONST_CAST (char*, plugin_name);
171 /* FIXME: the ".so" suffix is currently builtin, since plugins
172 only work on ELF host systems like e.g. Linux or Solaris.
173 When plugins shall be available on non ELF systems such as
174 Windows or MacOS, this code has to be greatly improved. */
175 plugin_name = concat (default_plugin_dir_name (), "/",
176 plugin_name, ".so", NULL);
177 if (access (plugin_name, R_OK))
178 fatal_error
179 ("inaccessible plugin file %s expanded from short plugin name %s: %m",
180 plugin_name, base_name);
182 else
183 base_name = get_plugin_base_name (plugin_name);
185 /* If this is the first -fplugin= option we encounter, create
186 'plugin_name_args_tab' hash table. */
187 if (!plugin_name_args_tab)
188 plugin_name_args_tab = htab_create (10, htab_hash_string, htab_str_eq,
189 NULL);
191 slot = htab_find_slot (plugin_name_args_tab, base_name, INSERT);
193 /* If the same plugin (name) has been specified earlier, either emit an
194 error or a warning message depending on if they have identical full
195 (path) names. */
196 if (*slot)
198 plugin = (struct plugin_name_args *) *slot;
199 if (strcmp (plugin->full_name, plugin_name))
200 error ("plugin %s was specified with different paths:\n%s\n%s",
201 plugin->base_name, plugin->full_name, plugin_name);
202 return;
205 plugin = XCNEW (struct plugin_name_args);
206 plugin->base_name = base_name;
207 plugin->full_name = plugin_name;
209 *slot = plugin;
213 /* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a
214 'plugin_argument' object for the parsed key-value pair. ARG is
215 the <name>-<key>[=<value>] part of the option. */
217 void
218 parse_plugin_arg_opt (const char *arg)
220 size_t len = 0, name_len = 0, key_len = 0, value_len = 0;
221 const char *ptr, *name_start = arg, *key_start = NULL, *value_start = NULL;
222 char *name, *key, *value;
223 void **slot;
224 bool name_parsed = false, key_parsed = false;
226 /* Iterate over the ARG string and identify the starting character position
227 of 'name', 'key', and 'value' and their lengths. */
228 for (ptr = arg; *ptr; ++ptr)
230 /* Only the first '-' encountered is considered a separator between
231 'name' and 'key'. All the subsequent '-'s are considered part of
232 'key'. For example, given -fplugin-arg-foo-bar-primary-key=value,
233 the plugin name is 'foo' and the key is 'bar-primary-key'. */
234 if (*ptr == '-' && !name_parsed)
236 name_len = len;
237 len = 0;
238 key_start = ptr + 1;
239 name_parsed = true;
240 continue;
242 else if (*ptr == '=')
244 if (!key_parsed)
246 key_len = len;
247 len = 0;
248 value_start = ptr + 1;
249 key_parsed = true;
251 continue;
253 else
254 ++len;
257 if (!key_start)
259 error ("malformed option -fplugin-arg-%s (missing -<key>[=<value>])",
260 arg);
261 return;
264 /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN.
265 Otherwise, it is the VALUE_LEN. */
266 if (!value_start)
267 key_len = len;
268 else
269 value_len = len;
271 name = XNEWVEC (char, name_len + 1);
272 strncpy (name, name_start, name_len);
273 name[name_len] = '\0';
275 /* Check if the named plugin has already been specified earlier in the
276 command-line. */
277 if (plugin_name_args_tab
278 && ((slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT))
279 != NULL))
281 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
283 key = XNEWVEC (char, key_len + 1);
284 strncpy (key, key_start, key_len);
285 key[key_len] = '\0';
286 if (value_start)
288 value = XNEWVEC (char, value_len + 1);
289 strncpy (value, value_start, value_len);
290 value[value_len] = '\0';
292 else
293 value = NULL;
295 /* Create a plugin_argument object for the parsed key-value pair.
296 If there are already arguments for this plugin, we will need to
297 adjust the argument array size by creating a new array and deleting
298 the old one. If the performance ever becomes an issue, we can
299 change the code by pre-allocating a larger array first. */
300 if (plugin->argc > 0)
302 struct plugin_argument *args = XNEWVEC (struct plugin_argument,
303 plugin->argc + 1);
304 memcpy (args, plugin->argv,
305 sizeof (struct plugin_argument) * plugin->argc);
306 XDELETEVEC (plugin->argv);
307 plugin->argv = args;
308 ++plugin->argc;
310 else
312 gcc_assert (plugin->argv == NULL);
313 plugin->argv = XNEWVEC (struct plugin_argument, 1);
314 plugin->argc = 1;
317 plugin->argv[plugin->argc - 1].key = key;
318 plugin->argv[plugin->argc - 1].value = value;
320 else
321 error ("plugin %s should be specified before -fplugin-arg-%s "
322 "in the command line", name, arg);
324 /* We don't need the plugin's name anymore. Just release it. */
325 XDELETEVEC (name);
328 /* Register additional plugin information. NAME is the name passed to
329 plugin_init. INFO is the information that should be registered. */
331 static void
332 register_plugin_info (const char* name, struct plugin_info *info)
334 void **slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT);
335 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
336 plugin->version = info->version;
337 plugin->help = info->help;
340 /* Look up the event id for NAME. If the name is not found, return -1
341 if INSERT is NO_INSERT. */
344 get_named_event_id (const char *name, enum insert_option insert)
346 const char ***slot;
348 if (!event_tab)
350 int i;
352 event_tab = new hash_table<event_hasher> (150);
353 for (i = 0; i < event_last; i++)
355 slot = event_tab->find_slot (&plugin_event_name[i], INSERT);
356 gcc_assert (*slot == HTAB_EMPTY_ENTRY);
357 *slot = &plugin_event_name[i];
360 slot = event_tab->find_slot (&name, insert);
361 if (slot == NULL)
362 return -1;
363 if (*slot != HTAB_EMPTY_ENTRY)
364 return *slot - &plugin_event_name[0];
366 if (event_last >= event_horizon)
368 event_horizon = event_last * 2;
369 if (plugin_event_name == plugin_event_name_init)
371 plugin_event_name = XNEWVEC (const char *, event_horizon);
372 memcpy (plugin_event_name, plugin_event_name_init,
373 sizeof plugin_event_name_init);
374 plugin_callbacks = XNEWVEC (struct callback_info *, event_horizon);
375 memcpy (plugin_callbacks, plugin_callbacks_init,
376 sizeof plugin_callbacks_init);
378 else
380 plugin_event_name
381 = XRESIZEVEC (const char *, plugin_event_name, event_horizon);
382 plugin_callbacks = XRESIZEVEC (struct callback_info *,
383 plugin_callbacks, event_horizon);
385 /* All the pointers in the hash table will need to be updated. */
386 delete event_tab;
387 event_tab = NULL;
389 else
390 *slot = &plugin_event_name[event_last];
391 plugin_event_name[event_last] = name;
392 return event_last++;
395 /* Called from the plugin's initialization code. Register a single callback.
396 This function can be called multiple times.
398 PLUGIN_NAME - display name for this plugin
399 EVENT - which event the callback is for
400 CALLBACK - the callback to be called at the event
401 USER_DATA - plugin-provided data */
403 void
404 register_callback (const char *plugin_name,
405 int event,
406 plugin_callback_func callback,
407 void *user_data)
409 switch (event)
411 case PLUGIN_PASS_MANAGER_SETUP:
412 gcc_assert (!callback);
413 register_pass ((struct register_pass_info *) user_data);
414 break;
415 case PLUGIN_INFO:
416 gcc_assert (!callback);
417 register_plugin_info (plugin_name, (struct plugin_info *) user_data);
418 break;
419 case PLUGIN_REGISTER_GGC_ROOTS:
420 gcc_assert (!callback);
421 ggc_register_root_tab ((const struct ggc_root_tab*) user_data);
422 break;
423 case PLUGIN_REGISTER_GGC_CACHES:
424 gcc_assert (!callback);
425 ggc_register_cache_tab ((const struct ggc_cache_tab*) user_data);
426 break;
427 case PLUGIN_EVENT_FIRST_DYNAMIC:
428 default:
429 if (event < PLUGIN_EVENT_FIRST_DYNAMIC || event >= event_last)
431 error ("unknown callback event registered by plugin %s",
432 plugin_name);
433 return;
435 /* Fall through. */
436 case PLUGIN_FINISH_TYPE:
437 case PLUGIN_FINISH_DECL:
438 case PLUGIN_START_UNIT:
439 case PLUGIN_FINISH_UNIT:
440 case PLUGIN_PRE_GENERICIZE:
441 case PLUGIN_GGC_START:
442 case PLUGIN_GGC_MARKING:
443 case PLUGIN_GGC_END:
444 case PLUGIN_ATTRIBUTES:
445 case PLUGIN_PRAGMAS:
446 case PLUGIN_FINISH:
447 case PLUGIN_ALL_PASSES_START:
448 case PLUGIN_ALL_PASSES_END:
449 case PLUGIN_ALL_IPA_PASSES_START:
450 case PLUGIN_ALL_IPA_PASSES_END:
451 case PLUGIN_OVERRIDE_GATE:
452 case PLUGIN_PASS_EXECUTION:
453 case PLUGIN_EARLY_GIMPLE_PASSES_START:
454 case PLUGIN_EARLY_GIMPLE_PASSES_END:
455 case PLUGIN_NEW_PASS:
456 case PLUGIN_INCLUDE_FILE:
458 struct callback_info *new_callback;
459 if (!callback)
461 error ("plugin %s registered a null callback function "
462 "for event %s", plugin_name, plugin_event_name[event]);
463 return;
465 new_callback = XNEW (struct callback_info);
466 new_callback->plugin_name = plugin_name;
467 new_callback->func = callback;
468 new_callback->user_data = user_data;
469 new_callback->next = plugin_callbacks[event];
470 plugin_callbacks[event] = new_callback;
472 break;
476 /* Remove a callback for EVENT which has been registered with for a plugin
477 PLUGIN_NAME. Return PLUGEVT_SUCCESS if a matching callback was
478 found & removed, PLUGEVT_NO_CALLBACK if the event does not have a matching
479 callback, and PLUGEVT_NO_SUCH_EVENT if EVENT is invalid. */
481 unregister_callback (const char *plugin_name, int event)
483 struct callback_info *callback, **cbp;
485 if (event >= event_last)
486 return PLUGEVT_NO_SUCH_EVENT;
488 for (cbp = &plugin_callbacks[event]; (callback = *cbp); cbp = &callback->next)
489 if (strcmp (callback->plugin_name, plugin_name) == 0)
491 *cbp = callback->next;
492 return PLUGEVT_SUCCESS;
494 return PLUGEVT_NO_CALLBACK;
497 /* Invoke all plugin callbacks registered with the specified event,
498 called from invoke_plugin_callbacks(). */
501 invoke_plugin_callbacks_full (int event, void *gcc_data)
503 int retval = PLUGEVT_SUCCESS;
505 timevar_push (TV_PLUGIN_RUN);
507 switch (event)
509 case PLUGIN_EVENT_FIRST_DYNAMIC:
510 default:
511 gcc_assert (event >= PLUGIN_EVENT_FIRST_DYNAMIC);
512 gcc_assert (event < event_last);
513 /* Fall through. */
514 case PLUGIN_FINISH_TYPE:
515 case PLUGIN_FINISH_DECL:
516 case PLUGIN_START_UNIT:
517 case PLUGIN_FINISH_UNIT:
518 case PLUGIN_PRE_GENERICIZE:
519 case PLUGIN_ATTRIBUTES:
520 case PLUGIN_PRAGMAS:
521 case PLUGIN_FINISH:
522 case PLUGIN_GGC_START:
523 case PLUGIN_GGC_MARKING:
524 case PLUGIN_GGC_END:
525 case PLUGIN_ALL_PASSES_START:
526 case PLUGIN_ALL_PASSES_END:
527 case PLUGIN_ALL_IPA_PASSES_START:
528 case PLUGIN_ALL_IPA_PASSES_END:
529 case PLUGIN_OVERRIDE_GATE:
530 case PLUGIN_PASS_EXECUTION:
531 case PLUGIN_EARLY_GIMPLE_PASSES_START:
532 case PLUGIN_EARLY_GIMPLE_PASSES_END:
533 case PLUGIN_NEW_PASS:
534 case PLUGIN_INCLUDE_FILE:
536 /* Iterate over every callback registered with this event and
537 call it. */
538 struct callback_info *callback = plugin_callbacks[event];
540 if (!callback)
541 retval = PLUGEVT_NO_CALLBACK;
542 for ( ; callback; callback = callback->next)
543 (*callback->func) (gcc_data, callback->user_data);
545 break;
547 case PLUGIN_PASS_MANAGER_SETUP:
548 case PLUGIN_REGISTER_GGC_ROOTS:
549 case PLUGIN_REGISTER_GGC_CACHES:
550 gcc_assert (false);
553 timevar_pop (TV_PLUGIN_RUN);
554 return retval;
557 #ifdef ENABLE_PLUGIN
558 /* We need a union to cast dlsym return value to a function pointer
559 as ISO C forbids assignment between function pointer and 'void *'.
560 Use explicit union instead of __extension__(<union_cast>) for
561 portability. */
562 #define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; }
563 #define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q)
564 #define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq)
566 /* Try to initialize PLUGIN. Return true if successful. */
568 static bool
569 try_init_one_plugin (struct plugin_name_args *plugin)
571 void *dl_handle;
572 plugin_init_func plugin_init;
573 const char *err;
574 PTR_UNION_TYPE (plugin_init_func) plugin_init_union;
576 /* We use RTLD_NOW to accelerate binding and detect any mismatch
577 between the API expected by the plugin and the GCC API; we use
578 RTLD_GLOBAL which is useful to plugins which themselves call
579 dlopen. */
580 dl_handle = dlopen (plugin->full_name, RTLD_NOW | RTLD_GLOBAL);
581 if (!dl_handle)
583 error ("cannot load plugin %s\n%s", plugin->full_name, dlerror ());
584 return false;
587 /* Clear any existing error. */
588 dlerror ();
590 /* Check the plugin license. */
591 if (dlsym (dl_handle, str_license) == NULL)
592 fatal_error ("plugin %s is not licensed under a GPL-compatible license\n"
593 "%s", plugin->full_name, dlerror ());
595 PTR_UNION_AS_VOID_PTR (plugin_init_union) =
596 dlsym (dl_handle, str_plugin_init_func_name);
597 plugin_init = PTR_UNION_AS_CAST_PTR (plugin_init_union);
599 if ((err = dlerror ()) != NULL)
601 error ("cannot find %s in plugin %s\n%s", str_plugin_init_func_name,
602 plugin->full_name, err);
603 return false;
606 /* Call the plugin-provided initialization routine with the arguments. */
607 if ((*plugin_init) (plugin, &gcc_version))
609 error ("fail to initialize plugin %s", plugin->full_name);
610 return false;
613 return true;
617 /* Routine to dlopen and initialize one plugin. This function is passed to
618 (and called by) the hash table traverse routine. Return 1 for the
619 htab_traverse to continue scan, 0 to stop.
621 SLOT - slot of the hash table element
622 INFO - auxiliary pointer handed to hash table traverse routine
623 (unused in this function) */
625 static int
626 init_one_plugin (void **slot, void * ARG_UNUSED (info))
628 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
629 bool ok = try_init_one_plugin (plugin);
630 if (!ok)
632 htab_remove_elt (plugin_name_args_tab, plugin->base_name);
633 XDELETE (plugin);
635 return 1;
638 #endif /* ENABLE_PLUGIN */
640 /* Main plugin initialization function. Called from compile_file() in
641 toplev.c. */
643 void
644 initialize_plugins (void)
646 /* If no plugin was specified in the command-line, simply return. */
647 if (!plugin_name_args_tab)
648 return;
650 timevar_push (TV_PLUGIN_INIT);
652 #ifdef ENABLE_PLUGIN
653 /* Traverse and initialize each plugin specified in the command-line. */
654 htab_traverse_noresize (plugin_name_args_tab, init_one_plugin, NULL);
655 #endif
657 timevar_pop (TV_PLUGIN_INIT);
660 /* Release memory used by one plugin. */
662 static int
663 finalize_one_plugin (void **slot, void * ARG_UNUSED (info))
665 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
666 XDELETE (plugin);
667 return 1;
670 /* Free memory allocated by the plugin system. */
672 void
673 finalize_plugins (void)
675 if (!plugin_name_args_tab)
676 return;
678 /* We can now delete the plugin_name_args object as it will no longer
679 be used. Note that base_name and argv fields (both of which were also
680 dynamically allocated) are not freed as they could still be used by
681 the plugin code. */
683 htab_traverse_noresize (plugin_name_args_tab, finalize_one_plugin, NULL);
685 /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it. */
686 htab_delete (plugin_name_args_tab);
687 plugin_name_args_tab = NULL;
690 /* Used to pass options to htab_traverse callbacks. */
692 struct print_options
694 FILE *file;
695 const char *indent;
698 /* Print the version of one plugin. */
700 static int
701 print_version_one_plugin (void **slot, void *data)
703 struct print_options *opt = (struct print_options *) data;
704 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
705 const char *version = plugin->version ? plugin->version : "Unknown version.";
707 fprintf (opt->file, " %s%s: %s\n", opt->indent, plugin->base_name, version);
708 return 1;
711 /* Print the version of each plugin. */
713 void
714 print_plugins_versions (FILE *file, const char *indent)
716 struct print_options opt;
717 opt.file = file;
718 opt.indent = indent;
719 if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
720 return;
722 fprintf (file, "%sVersions of loaded plugins:\n", indent);
723 htab_traverse_noresize (plugin_name_args_tab, print_version_one_plugin, &opt);
726 /* Print help for one plugin. SLOT is the hash table slot. DATA is the
727 argument to htab_traverse_noresize. */
729 static int
730 print_help_one_plugin (void **slot, void *data)
732 struct print_options *opt = (struct print_options *) data;
733 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
734 const char *help = plugin->help ? plugin->help : "No help available .";
736 char *dup = xstrdup (help);
737 char *p, *nl;
738 fprintf (opt->file, " %s%s:\n", opt->indent, plugin->base_name);
740 for (p = nl = dup; nl; p = nl)
742 nl = strchr (nl, '\n');
743 if (nl)
745 *nl = '\0';
746 nl++;
748 fprintf (opt->file, " %s %s\n", opt->indent, p);
751 free (dup);
752 return 1;
755 /* Print help for each plugin. The output goes to FILE and every line starts
756 with INDENT. */
758 void
759 print_plugins_help (FILE *file, const char *indent)
761 struct print_options opt;
762 opt.file = file;
763 opt.indent = indent;
764 if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
765 return;
767 fprintf (file, "%sHelp for the loaded plugins:\n", indent);
768 htab_traverse_noresize (plugin_name_args_tab, print_help_one_plugin, &opt);
772 /* Return true if plugins have been loaded. */
774 bool
775 plugins_active_p (void)
777 int event;
779 for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
780 if (plugin_callbacks[event])
781 return true;
783 return false;
787 /* Dump to FILE the names and associated events for all the active
788 plugins. */
790 DEBUG_FUNCTION void
791 dump_active_plugins (FILE *file)
793 int event;
795 if (!plugins_active_p ())
796 return;
798 fprintf (file, FMT_FOR_PLUGIN_EVENT " | %s\n", _("Event"), _("Plugins"));
799 for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
800 if (plugin_callbacks[event])
802 struct callback_info *ci;
804 fprintf (file, FMT_FOR_PLUGIN_EVENT " |", plugin_event_name[event]);
806 for (ci = plugin_callbacks[event]; ci; ci = ci->next)
807 fprintf (file, " %s", ci->plugin_name);
809 putc ('\n', file);
814 /* Dump active plugins to stderr. */
816 DEBUG_FUNCTION void
817 debug_active_plugins (void)
819 dump_active_plugins (stderr);
822 /* Give a warning if plugins are present, before an ICE message asking
823 to submit a bug report. */
825 void
826 warn_if_plugins (void)
828 if (plugins_active_p ())
830 fnotice (stderr, "*** WARNING *** there are active plugins, do not report"
831 " this as a bug unless you can reproduce it without enabling"
832 " any plugins.\n");
833 dump_active_plugins (stderr);
838 /* Likewise, as a callback from the diagnostics code. */
840 void
841 plugins_internal_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
842 const char *msgid ATTRIBUTE_UNUSED,
843 va_list *ap ATTRIBUTE_UNUSED)
845 warn_if_plugins ();
848 /* The default version check. Compares every field in VERSION. */
850 bool
851 plugin_default_version_check (struct plugin_gcc_version *gcc_version,
852 struct plugin_gcc_version *plugin_version)
854 if (!gcc_version || !plugin_version)
855 return false;
857 if (strcmp (gcc_version->basever, plugin_version->basever))
858 return false;
859 if (strcmp (gcc_version->datestamp, plugin_version->datestamp))
860 return false;
861 if (strcmp (gcc_version->devphase, plugin_version->devphase))
862 return false;
863 if (strcmp (gcc_version->revision, plugin_version->revision))
864 return false;
865 if (strcmp (gcc_version->configuration_arguments,
866 plugin_version->configuration_arguments))
867 return false;
868 return true;
872 /* Return the current value of event_last, so that plugins which provide
873 additional functionality for events for the benefit of high-level plugins
874 know how many valid entries plugin_event_name holds. */
877 get_event_last (void)
879 return event_last;
883 /* Retrieve the default plugin directory. The gcc driver should have passed
884 it as -iplugindir <dir> to the cc1 program, and it is queriable through the
885 -print-file-name=plugin option to gcc. */
886 const char*
887 default_plugin_dir_name (void)
889 if (!plugindir_string)
890 fatal_error ("-iplugindir <dir> option not passed from the gcc driver");
891 return plugindir_string;